@antelopejs/dms-ai 0.1.3 → 0.1.5

package/frontend-vue/app/runtime/current-page.ts

@@ -1,32 +1,66 @@
-import { router } from '@inertiajs/vue3'
-import { HOST_STATE_UPDATE_TYPE } from './constants'
+import { router } from "@inertiajs/vue3";
+import { HOST_STATE_UPDATE_TYPE } from "./constants";
 
 interface CurrentPagePayload {
-	path: string
+	path: string;
+	title?: string;
 }
 
 interface HostStateUpdateMessage {
-	type: typeof HOST_STATE_UPDATE_TYPE
-	currentPage: CurrentPagePayload
+	type: typeof HOST_STATE_UPDATE_TYPE;
+	currentPage: CurrentPagePayload;
 }
 
 interface InstallCurrentPageTrackerOptions {
-	send: (msg: HostStateUpdateMessage) => void
+	send: (msg: HostStateUpdateMessage) => void;
 }
 
-/** The state update announcing the page at `url`. */
+const TITLE_OBSERVER_OPTIONS: MutationObserverInit = {
+	subtree: true,
+	childList: true,
+	characterData: true,
+};
+
+function readTitle(): string | undefined {
+	const title = document.title.trim();
+	return title === "" ? undefined : title;
+}
+
+function buildCurrentPage(url: string): CurrentPagePayload {
+	const path = new URL(url, window.location.origin).pathname;
+	const title = readTitle();
+	return title === undefined ? { path } : { path, title };
+}
+
+/** The state update announcing the page at `url`, titled after the document. */
 export function buildCurrentPageUpdate(url: string): HostStateUpdateMessage {
-	return {
-		type: HOST_STATE_UPDATE_TYPE,
-		currentPage: { path: new URL(url, window.location.origin).pathname },
-	}
+	return { type: HOST_STATE_UPDATE_TYPE, currentPage: buildCurrentPage(url) };
 }
 
+/**
+ * Reports the displayed page on every Inertia navigation, and again whenever
+ * the document title changes after the page has rendered.
+ */
 export function installCurrentPageTracker(
 	options: InstallCurrentPageTrackerOptions,
 ): () => void {
-	const pushFor = (url: string): void => options.send(buildCurrentPageUpdate(url))
-	const stop = router.on('navigate', (event) => pushFor(event.detail.page.url))
-	pushFor(window.location.href)
-	return stop
+	let currentUrl = window.location.href;
+	let sentTitle = readTitle();
+	const push = (): void => {
+		sentTitle = readTitle();
+		options.send(buildCurrentPageUpdate(currentUrl));
+	};
+	const stopNavigation = router.on("navigate", (event) => {
+		currentUrl = event.detail.page.url;
+		push();
+	});
+	const titleObserver = new MutationObserver(() => {
+		if (readTitle() !== sentTitle) push();
+	});
+	titleObserver.observe(document.head, TITLE_OBSERVER_OPTIONS);
+	push();
+	return () => {
+		stopNavigation();
+		titleObserver.disconnect();
+	};
 }

package/frontend-vue/app/runtime/event-stream.ts

@@ -1,53 +1,53 @@
 export interface StreamEvent {
-	name: string
-	data: string
+	name: string;
+	data: string;
 }
 
-const DEFAULT_EVENT_NAME = 'message'
-const FRAME_SEPARATOR = /\r?\n\r?\n/
-const LINE_SEPARATOR = /\r?\n/
-const FIELD_SEPARATOR = ':'
-const EVENT_FIELD = 'event'
-const DATA_FIELD = 'data'
+const DEFAULT_EVENT_NAME = "message";
+const FRAME_SEPARATOR = /\r?\n\r?\n/;
+const LINE_SEPARATOR = /\r?\n/;
+const FIELD_SEPARATOR = ":";
+const EVENT_FIELD = "event";
+const DATA_FIELD = "data";
 
 interface Field {
-	name: string
-	value: string
+	name: string;
+	value: string;
 }
 
 function parseField(line: string): Field {
-	const boundary = line.indexOf(FIELD_SEPARATOR)
-	if (boundary === -1) return { name: line, value: '' }
-	const raw = line.slice(boundary + FIELD_SEPARATOR.length)
+	const boundary = line.indexOf(FIELD_SEPARATOR);
+	if (boundary === -1) return { name: line, value: "" };
+	const raw = line.slice(boundary + FIELD_SEPARATOR.length);
 	return {
 		name: line.slice(0, boundary),
-		value: raw.startsWith(' ') ? raw.slice(1) : raw,
-	}
+		value: raw.startsWith(" ") ? raw.slice(1) : raw,
+	};
 }
 
 function parseFrame(frame: string): StreamEvent | null {
-	let name = DEFAULT_EVENT_NAME
-	const data: string[] = []
+	let name = DEFAULT_EVENT_NAME;
+	const data: string[] = [];
 	for (const line of frame.split(LINE_SEPARATOR)) {
-		const field = parseField(line)
-		if (field.name === EVENT_FIELD) name = field.value
-		if (field.name === DATA_FIELD) data.push(field.value)
+		const field = parseField(line);
+		if (field.name === EVENT_FIELD) name = field.value;
+		if (field.name === DATA_FIELD) data.push(field.value);
 	}
-	if (data.length === 0) return null
-	return { name, data: data.join('\n') }
+	if (data.length === 0) return null;
+	return { name, data: data.join("\n") };
 }
 
 function dispatchFrames(
 	buffer: string,
 	onEvent: (event: StreamEvent) => void,
 ): string {
-	const frames = buffer.split(FRAME_SEPARATOR)
-	const rest = frames.pop() ?? ''
+	const frames = buffer.split(FRAME_SEPARATOR);
+	const rest = frames.pop() ?? "";
 	for (const frame of frames) {
-		const event = parseFrame(frame)
-		if (event !== null) onEvent(event)
+		const event = parseFrame(frame);
+		if (event !== null) onEvent(event);
 	}
-	return rest
+	return rest;
 }
 
 /**
@@ -59,17 +59,17 @@ export async function readEventStream(
 	body: ReadableStream<Uint8Array>,
 	onEvent: (event: StreamEvent) => void,
 ): Promise<void> {
-	const reader = body.getReader()
-	const decoder = new TextDecoder()
-	let buffer = ''
+	const reader = body.getReader();
+	const decoder = new TextDecoder();
+	let buffer = "";
 	try {
 		while (true) {
-			const chunk = await reader.read()
-			if (chunk.done) return
-			buffer += decoder.decode(chunk.value, { stream: true })
-			buffer = dispatchFrames(buffer, onEvent)
+			const chunk = await reader.read();
+			if (chunk.done) return;
+			buffer += decoder.decode(chunk.value, { stream: true });
+			buffer = dispatchFrames(buffer, onEvent);
 		}
 	} finally {
-		reader.releaseLock()
+		reader.releaseLock();
 	}
 }

package/frontend-vue/app/runtime/frame-router.ts

@@ -0,0 +1,30 @@
+import { HOST_COMMAND_TYPES } from "./constants";
+import { isTypedMessage, type TypedMessage } from "./typed-message";
+
+export interface FrameRoutes {
+	host: (msg: TypedMessage) => void;
+	chat: (msg: TypedMessage) => void;
+}
+
+function parseFrame(raw: string): TypedMessage | null {
+	try {
+		const parsed: unknown = JSON.parse(raw);
+		return isTypedMessage(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+
+/**
+ * The dashboard and its chat share the tab's one sidecar socket: each frame is
+ * parsed once, then handed to the dashboard when it is a host command and to
+ * the chat otherwise. A frame that is not a typed message reaches neither.
+ */
+export function createFrameRouter(routes: FrameRoutes): (raw: string) => void {
+	return (raw) => {
+		const msg = parseFrame(raw);
+		if (msg === null) return;
+		const route = HOST_COMMAND_TYPES.has(msg.type) ? routes.host : routes.chat;
+		route(msg);
+	};
+}

package/frontend-vue/app/runtime/header-action.ts

@@ -1,4 +1,4 @@
-import { useDmsState as useState } from '#dms/frontend-module'
+import { useDmsState as useState } from "#dms/frontend-module";
 import {
 	HEADER_ACTIONS_STATE_KEY,
 	LAUNCHER_ACTION_ID,
@@ -7,14 +7,14 @@ import {
 	LAUNCHER_ORDER,
 	TOGGLE_SHORTCUT_LABEL_MAC,
 	TOGGLE_SHORTCUT_LABEL_OTHER,
-} from './constants'
+} from "./constants";
 
 interface UserAgentData {
-	platform?: string
+	platform?: string;
 }
 
 interface NavigatorUserAgentData {
-	userAgentData?: UserAgentData
+	userAgentData?: UserAgentData;
 }
 
 // The shortcut combo accepts meta OR ctrl, so show the modifier each platform
@@ -22,35 +22,35 @@ interface NavigatorUserAgentData {
 function isApplePlatform(): boolean {
 	const nav = globalThis.navigator as
 		| (Navigator & NavigatorUserAgentData)
-		| undefined
-	if (nav === undefined) return false
-	const platform = nav.userAgentData?.platform ?? nav.platform ?? ''
-	return /mac|iphone|ipad|ipod/i.test(platform)
+		| undefined;
+	if (nav === undefined) return false;
+	const platform = nav.userAgentData?.platform ?? nav.platform ?? "";
+	return /mac|iphone|ipad|ipod/i.test(platform);
 }
 
 function launcherLabel(): string {
 	const shortcut = isApplePlatform()
 		? TOGGLE_SHORTCUT_LABEL_MAC
-		: TOGGLE_SHORTCUT_LABEL_OTHER
-	return `${LAUNCHER_LABEL} (${shortcut})`
+		: TOGGLE_SHORTCUT_LABEL_OTHER;
+	return `${LAUNCHER_LABEL} (${shortcut})`;
 }
 
 // Our view of the shared header-action shape the DMS core renders. Declared
 // locally so this layer has no build-time dependency on the core layer; the
 // only contract is the state key and these fields.
 interface HeaderAction {
-	id: string
-	icon: string
-	label: string
-	onSelect: () => void
-	order?: number
+	id: string;
+	icon: string;
+	label: string;
+	onSelect: () => void;
+	order?: number;
 }
 
 // Register the assistant launcher in the core's generic header-action registry.
 // Idempotent so a re-running plugin can't add a duplicate button.
 export function registerLauncherAction(onSelect: () => void): void {
-	const actions = useState<HeaderAction[]>(HEADER_ACTIONS_STATE_KEY, () => [])
-	if (actions.value.some((action) => action.id === LAUNCHER_ACTION_ID)) return
+	const actions = useState<HeaderAction[]>(HEADER_ACTIONS_STATE_KEY, () => []);
+	if (actions.value.some((action) => action.id === LAUNCHER_ACTION_ID)) return;
 	actions.value = [
 		...actions.value,
 		{
@@ -60,5 +60,5 @@ export function registerLauncherAction(onSelect: () => void): void {
 			order: LAUNCHER_ORDER,
 			onSelect,
 		},
-	]
+	];
 }

package/frontend-vue/app/runtime/host-commands.ts

@@ -1,7 +1,8 @@
-import { HOST_COMMAND_NAVIGATE_TYPE, LOG_PREFIX } from './constants'
+import { HOST_COMMAND_NAVIGATE_TYPE, LOG_PREFIX } from "./constants";
+import { isTypedMessage } from "./typed-message";
 
 interface RouterLike {
-	push: (path: string) => unknown
+	push: (path: string) => unknown;
 }
 
 /**
@@ -10,22 +11,23 @@ interface RouterLike {
  * timeout.
  */
 export interface DevReloadWaiter {
-	awaitRoute: (path: string) => Promise<boolean>
+	awaitRoute: (path: string) => Promise<boolean>;
 }
 
 export interface HostCommandContext {
-	router: RouterLike
-	devReload: DevReloadWaiter
+	router: RouterLike;
+	devReload: DevReloadWaiter;
 }
 
 export interface HostCommandNavigateMessage {
-	type: typeof HOST_COMMAND_NAVIGATE_TYPE
-	path: string
+	type: typeof HOST_COMMAND_NAVIGATE_TYPE;
+	path: string;
 }
 
-export type HostCommandMessage = HostCommandNavigateMessage
+export type HostCommandMessage = HostCommandNavigateMessage;
 
-export type HostCommandDispatcher = (raw: unknown) => void
+/** Takes a sidecar message already parsed; anything that is not a host command is ignored. */
+export type HostCommandDispatcher = (msg: unknown) => void;
 
 /**
  * Commands run one at a time on `tail`. `nextPath` holds the newest navigation
@@ -33,20 +35,22 @@ export type HostCommandDispatcher = (raw: unknown) => void
  * the latest path instead of racing and landing on the oldest one.
  */
 interface DispatcherState {
-	ctx: HostCommandContext
-	tail: Promise<void>
-	nextPath: string | null
+	ctx: HostCommandContext;
+	tail: Promise<void>;
+	nextPath: string | null;
 }
 
 type HostCommandHandler = (
 	msg: HostCommandMessage,
 	state: DispatcherState,
-) => void
+) => void;
+
+const IN_APP_PATH = /^\/(?![/\\])/;
 
 function enqueue(state: DispatcherState, job: () => Promise<void>): void {
 	state.tail = state.tail.then(job).catch((err: unknown) => {
-		console.error(`${LOG_PREFIX} host command failed`, err)
-	})
+		console.error(`${LOG_PREFIX} host command failed`, err);
+	});
 }
 
 // The agent asks to navigate right after writing the page, while the host is
@@ -60,52 +64,50 @@ async function awaitRouteThenPush(
 	ctx: HostCommandContext,
 ): Promise<void> {
 	try {
-		await ctx.devReload.awaitRoute(path)
+		await ctx.devReload.awaitRoute(path);
 	} catch (err: unknown) {
-		console.error(`${LOG_PREFIX} dev reload wait failed for ${path}`, err)
+		console.error(`${LOG_PREFIX} dev reload wait failed for ${path}`, err);
 	}
-	void ctx.router.push(path)
+	void ctx.router.push(path);
 }
 
 async function runNavigate(state: DispatcherState): Promise<void> {
-	const path = state.nextPath
+	const path = state.nextPath;
 	// A newer navigate already claimed this slot's target: this one is superseded
 	// and must not drag the user back to the older path.
-	if (path === null) return
-	state.nextPath = null
-	await awaitRouteThenPush(path, state.ctx)
-}
-
-function handleNavigate(
-	msg: HostCommandMessage,
-	state: DispatcherState,
-): void {
-	if (msg.type !== HOST_COMMAND_NAVIGATE_TYPE) return
-	state.nextPath = msg.path
-	enqueue(state, () => runNavigate(state))
-}
-
-const COMMAND_HANDLERS: Record<string, HostCommandHandler> = {
-	[HOST_COMMAND_NAVIGATE_TYPE]: handleNavigate,
-}
-
-function isHostCommand(value: unknown): value is HostCommandMessage {
-	if (value === null || typeof value !== 'object') return false
-	const candidate = value as { type?: unknown }
-	return typeof candidate.type === 'string'
+	if (path === null) return;
+	state.nextPath = null;
+	await awaitRouteThenPush(path, state.ctx);
 }
 
-function parseRaw(raw: unknown): HostCommandMessage | null {
-	if (typeof raw !== 'string') return null
+/**
+ * Whether the agent may send the dashboard to `path`. What it asks for comes
+ * from model output, so it may only ever lead to a page of this origin.
+ */
+export function isInAppPath(path: unknown): path is string {
+	if (typeof path !== "string" || !IN_APP_PATH.test(path)) return false;
 	try {
-		const parsed = JSON.parse(raw) as unknown
-		if (!isHostCommand(parsed)) return null
-		return parsed
+		const origin = globalThis.location.origin;
+		return new URL(path, origin).origin === origin;
 	} catch {
-		return null
+		return false;
+	}
+}
+
+function handleNavigate(msg: HostCommandMessage, state: DispatcherState): void {
+	if (msg.type !== HOST_COMMAND_NAVIGATE_TYPE) return;
+	if (!isInAppPath(msg.path)) {
+		console.warn(`${LOG_PREFIX} refused to navigate off the dashboard`);
+		return;
 	}
+	state.nextPath = msg.path;
+	enqueue(state, () => runNavigate(state));
 }
 
+const COMMAND_HANDLERS: Record<string, HostCommandHandler> = {
+	[HOST_COMMAND_NAVIGATE_TYPE]: handleNavigate,
+};
+
 export function createHostCommandDispatcher(
 	ctx: HostCommandContext,
 ): HostCommandDispatcher {
@@ -113,15 +115,14 @@ export function createHostCommandDispatcher(
 		ctx,
 		tail: Promise.resolve(),
 		nextPath: null,
-	}
-	return (raw: unknown): void => {
-		const msg = parseRaw(raw)
-		if (msg === null) return
-		const handler = COMMAND_HANDLERS[msg.type]
+	};
+	return (msg: unknown): void => {
+		if (!isTypedMessage<HostCommandMessage>(msg)) return;
+		const handler = COMMAND_HANDLERS[msg.type];
 		if (handler === undefined) {
-			console.warn(`${LOG_PREFIX} unknown host command type=${msg.type}`)
-			return
+			console.warn(`${LOG_PREFIX} unknown host command type=${msg.type}`);
+			return;
 		}
-		handler(msg, state)
-	}
+		handler(msg, state);
+	};
 }

package/frontend-vue/app/runtime/listeners.ts

@@ -0,0 +1,31 @@
+import { LOG_PREFIX } from "./constants";
+
+export type Listener<T> = (value: T) => void;
+
+export interface Listeners<T> {
+	add: (listener: Listener<T>) => () => void;
+	emit: Listener<T>;
+}
+
+/**
+ * A set of listeners notified in order. A listener belongs to a component that
+ * may already be failing: one throwing must not stop the others.
+ */
+export function createListeners<T>(): Listeners<T> {
+	const listeners = new Set<Listener<T>>();
+	return {
+		add: (listener) => {
+			listeners.add(listener);
+			return () => listeners.delete(listener);
+		},
+		emit: (value) => {
+			for (const listener of listeners) {
+				try {
+					listener(value);
+				} catch (error: unknown) {
+					console.error(`${LOG_PREFIX} listener failed`, error);
+				}
+			}
+		},
+	};
+}

package/frontend-vue/app/runtime/navigation-complete.ts

@@ -1,22 +1,22 @@
-import { router } from '@inertiajs/vue3'
-import { HOST_NAVIGATION_COMPLETE_TYPE } from './constants'
+import { router } from "@inertiajs/vue3";
+import { HOST_NAVIGATION_COMPLETE_TYPE } from "./constants";
 
 export interface HostNavigationCompleteMessage {
-	type: typeof HOST_NAVIGATION_COMPLETE_TYPE
-	path: string
+	type: typeof HOST_NAVIGATION_COMPLETE_TYPE;
+	path: string;
 }
 
 interface InstallNavigationCompleteEmitterOptions {
-	send: (msg: HostNavigationCompleteMessage) => void
+	send: (msg: HostNavigationCompleteMessage) => void;
 }
 
 export function installNavigationCompleteEmitter(
 	options: InstallNavigationCompleteEmitterOptions,
 ): () => void {
-	return router.on('navigate', (event) =>
+	return router.on("navigate", (event) =>
 		options.send({
 			type: HOST_NAVIGATION_COMPLETE_TYPE,
 			path: new URL(event.detail.page.url, window.location.origin).pathname,
 		}),
-	)
+	);
 }

package/frontend-vue/app/runtime/overlay-prefs.ts

@@ -1,89 +1,89 @@
 import {
 	OVERLAY_PREFS_DEBOUNCE_MS,
 	OVERLAY_PREFS_STORAGE_KEY,
-} from './constants'
+} from "./constants";
 
 export interface OverlayPrefs {
-	width: number
-	isOpen: boolean
+	width: number;
+	isOpen: boolean;
 }
 
-let pendingTimer: ReturnType<typeof setTimeout> | null = null
-let pendingPrefs: OverlayPrefs | null = null
+let pendingTimer: ReturnType<typeof setTimeout> | null = null;
+let pendingPrefs: OverlayPrefs | null = null;
 
 function tryReadStorage(): string | null {
 	try {
-		return globalThis.localStorage.getItem(OVERLAY_PREFS_STORAGE_KEY)
+		return globalThis.localStorage.getItem(OVERLAY_PREFS_STORAGE_KEY);
 	} catch {
-		return null
+		return null;
 	}
 }
 
 function tryWriteStorage(payload: string): void {
 	try {
-		globalThis.localStorage.setItem(OVERLAY_PREFS_STORAGE_KEY, payload)
+		globalThis.localStorage.setItem(OVERLAY_PREFS_STORAGE_KEY, payload);
 	} catch {
-		return
+		return;
 	}
 }
 
 function isFiniteNumber(value: unknown): value is number {
-	return typeof value === 'number' && Number.isFinite(value)
+	return typeof value === "number" && Number.isFinite(value);
 }
 
 function isValidPrefs(value: unknown): value is OverlayPrefs {
-	if (value === null || typeof value !== 'object') return false
-	const candidate = value as Record<string, unknown>
-	if (!isFiniteNumber(candidate.width)) return false
-	if (typeof candidate.isOpen !== 'boolean') return false
-	return true
+	if (value === null || typeof value !== "object") return false;
+	const candidate = value as Record<string, unknown>;
+	if (!isFiniteNumber(candidate.width)) return false;
+	if (typeof candidate.isOpen !== "boolean") return false;
+	return true;
 }
 
 function parsePrefs(raw: string): OverlayPrefs | null {
 	try {
-		const parsed: unknown = JSON.parse(raw)
-		return isValidPrefs(parsed) ? parsed : null
+		const parsed: unknown = JSON.parse(raw);
+		return isValidPrefs(parsed) ? parsed : null;
 	} catch {
-		return null
+		return null;
 	}
 }
 
 export function readPrefs(): OverlayPrefs | null {
-	const raw = tryReadStorage()
-	if (raw === null) return null
-	return parsePrefs(raw)
+	const raw = tryReadStorage();
+	if (raw === null) return null;
+	return parsePrefs(raw);
 }
 
 function flushPending(): void {
-	if (pendingPrefs === null) return
-	tryWriteStorage(JSON.stringify(pendingPrefs))
-	pendingPrefs = null
-	pendingTimer = null
+	if (pendingPrefs === null) return;
+	tryWriteStorage(JSON.stringify(pendingPrefs));
+	pendingPrefs = null;
+	pendingTimer = null;
 }
 
 export function writePrefsDebounced(prefs: OverlayPrefs): void {
-	pendingPrefs = prefs
-	if (pendingTimer !== null) clearTimeout(pendingTimer)
-	pendingTimer = setTimeout(flushPending, OVERLAY_PREFS_DEBOUNCE_MS)
+	pendingPrefs = prefs;
+	if (pendingTimer !== null) clearTimeout(pendingTimer);
+	pendingTimer = setTimeout(flushPending, OVERLAY_PREFS_DEBOUNCE_MS);
 }
 
 export function flushPrefsForTesting(): void {
 	if (pendingTimer !== null) {
-		clearTimeout(pendingTimer)
-		pendingTimer = null
+		clearTimeout(pendingTimer);
+		pendingTimer = null;
 	}
-	flushPending()
+	flushPending();
 }
 
 export function resetPrefsForTesting(): void {
 	if (pendingTimer !== null) {
-		clearTimeout(pendingTimer)
-		pendingTimer = null
+		clearTimeout(pendingTimer);
+		pendingTimer = null;
 	}
-	pendingPrefs = null
+	pendingPrefs = null;
 	try {
-		globalThis.localStorage.removeItem(OVERLAY_PREFS_STORAGE_KEY)
+		globalThis.localStorage.removeItem(OVERLAY_PREFS_STORAGE_KEY);
 	} catch {
-		return
+		return;
 	}
 }