@antelopejs/dms-ai 0.0.5 → 0.0.6

package/README.md

@@ -33,6 +33,7 @@ Install dependencies and run the backend and sidecar checks from the repository
 ```bash
 pnpm install
 pnpm build
+pnpm build:sidecar
 pnpm test
 ```
 

package/frontend-vue/app/plugins/ai.client.ts

@@ -1,4 +1,8 @@
-import { defineDmsPlugin, useDmsRouter } from '#dms/frontend-module'
+import {
+	type DmsAppContext,
+	defineDmsPlugin,
+	useDmsRouter,
+} from '#dms/frontend-module'
 import {
 	SIDECAR_HOST_NAME,
 	SIDECAR_INFO_PATH,
@@ -14,6 +18,7 @@ import { registerLauncherAction } from '../runtime/header-action'
 import { createHostCommandDispatcher } from '../runtime/host-commands'
 import { installNavigationCompleteEmitter } from '../runtime/navigation-complete'
 import { injectOverlay } from '../runtime/overlay'
+import { runWhenLoggedIn } from '../runtime/session-gate'
 import { installToggleShortcut } from '../runtime/shortcuts'
 import {
 	createSidecarStatusController,
@@ -30,10 +35,7 @@ function buildIframeUrl(port: number, token: string): string {
 	return `${SIDECAR_PROBE_HOST}:${port}/?theme=${mode}#token=${encodeURIComponent(token)}`
 }
 
-export default defineDmsPlugin(async ({ vueApp }) => {
-	if (!import.meta.env.DEV) return
-	const { loggedIn } = useUserSession()
-	if (!loggedIn.value) return
+async function startAssistant({ vueApp }: DmsAppContext): Promise<void> {
 	const { $authFetch } = useAuthFetch()
 	const controller = createSidecarStatusController(() =>
 		$authFetch(SIDECAR_INFO_PATH),
@@ -106,4 +108,14 @@ export default defineDmsPlugin(async ({ vueApp }) => {
 	}
 	vueApp.onUnmount(stop)
 	import.meta.hot?.dispose(stop)
+}
+
+export default defineDmsPlugin((context) => {
+	if (!import.meta.env.DEV) return
+	const { loggedIn } = useUserSession()
+	const stopGate = runWhenLoggedIn(
+		() => loggedIn.value,
+		() => void context.runWithContext(() => startAssistant(context)),
+	)
+	context.vueApp.onUnmount(stopGate)
 })

package/frontend-vue/app/runtime/session-gate.ts

@@ -0,0 +1,22 @@
+import { watch } from 'vue'
+
+// Plugins run once, when the Vue app boots, on whatever page the browser landed
+// on. Landing on the sign-in screen means there is no session yet, and signing
+// in is a client-side navigation that never re-creates the app: a plugin that
+// gave up there would stay silent until the next full page load. Wait for the
+// session to appear instead, then run exactly once.
+export function runWhenLoggedIn(
+	isLoggedIn: () => boolean,
+	start: () => void,
+): () => void {
+	if (isLoggedIn()) {
+		start()
+		return () => undefined
+	}
+	const stop = watch(isLoggedIn, (loggedIn) => {
+		if (!loggedIn) return
+		stop()
+		start()
+	})
+	return stop
+}

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

@@ -0,0 +1,39 @@
+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)
+	})
+
+	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 = 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)
+
+		stop()
+		loggedIn.value = true
+		await nextTick()
+		expect(start).not.toHaveBeenCalled()
+	})
+})

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

@@ -1,13 +1,29 @@
 import { readFileSync } from 'node:fs'
 import { resolve } from 'node:path'
 import ts from 'typescript'
+import { nextTick, ref, type Ref } from 'vue'
 import { expect, it, vi } from 'vitest'
+import { runWhenLoggedIn } from '../app/runtime/session-gate'
 
 interface PluginExports {
-	default: (context: unknown) => Promise<void>
+	default: (context: unknown) => void | Promise<void>
 }
 
-it('does not invoke authenticated fetching or inject the assistant for a guest', async () => {
+interface PluginHarness {
+	useAuthFetch: ReturnType<typeof vi.fn>
+	run: () => void | Promise<void>
+}
+
+const SESSION_GATE_MODULE = '../runtime/session-gate'
+const SIDECAR_STATUS_MODULE = '../runtime/sidecar-status'
+
+// A first probe reporting "no assistant here" stops the startup right after the
+// authenticated fetch, which is all these tests need to observe.
+const silentController = {
+	createSidecarStatusController: () => ({ init: async () => false }),
+}
+
+function loadPlugin(loggedIn: Ref<boolean>): PluginHarness {
 	const source = readFileSync(
 		resolve(__dirname, '../app/plugins/ai.client.ts'),
 		'utf8',
@@ -16,30 +32,48 @@ it('does not invoke authenticated fetching or inject the assistant for a guest',
 		source
 			.replace('import.meta.env.DEV', 'true')
 			.replace('import.meta.hot', 'undefined'),
-		{
-			compilerOptions: { module: ts.ModuleKind.CommonJS },
-		},
+		{ 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/frontend-module'
-			? { defineDmsPlugin: (plugin: unknown) => plugin }
-			: {}
+	const useAuthFetch = vi.fn(() => ({ $authFetch: vi.fn() }))
+	const requireModule = (name: string) => {
+		if (name === '#dms/frontend-module') {
+			return { defineDmsPlugin: (plugin: unknown) => plugin }
+		}
+		if (name === SESSION_GATE_MODULE) return { runWhenLoggedIn }
+		if (name === SIDECAR_STATUS_MODULE) return silentController
+		return {}
+	}
 	new Function(
 		'require',
 		'exports',
 		'useUserSession',
 		'useAuthFetch',
 		compiled.outputText,
-	)(
-		requireModule,
-		exports,
-		() => ({ loggedIn: { value: false } }),
+	)(requireModule, exports, () => ({ loggedIn }), useAuthFetch)
+	return {
 		useAuthFetch,
-	)
-	await exports.default({})
-	expect(useAuthFetch).not.toHaveBeenCalled()
+		run: () =>
+			exports.default({
+				vueApp: { onUnmount: vi.fn() },
+				runWithContext: (callback: () => unknown) => callback(),
+			}),
+	}
+}
+
+it('does not invoke authenticated fetching or inject the assistant for a guest', async () => {
+	const plugin = loadPlugin(ref(false))
+	await plugin.run()
+	expect(plugin.useAuthFetch).not.toHaveBeenCalled()
+})
+
+it('starts the assistant when a guest signs in without reloading the page', async () => {
+	const loggedIn = ref(false)
+	const plugin = loadPlugin(loggedIn)
+	await plugin.run()
+	expect(plugin.useAuthFetch).not.toHaveBeenCalled()
+
+	loggedIn.value = true
+	await nextTick()
+	expect(plugin.useAuthFetch).toHaveBeenCalledTimes(1)
 })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@antelopejs/dms-ai",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "license": "Apache-2.0",
   "repository": {
     "type": "git",
@@ -38,6 +38,7 @@
     "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:release-script": "node --test tests/release-script.test.cjs",
     "test:e2e": "cd sidecar && pnpm test:e2e",