import { runScenarios } from '../../../scripts/test-scenarios.mjs' import { createServer, type Server } from 'node:http' import type { IncomingMessage, ServerResponse } from 'node:http' import type { AddressInfo } from 'node:net' import type { ControlResult } from '../src/control-result.js' import { afterEach, describe, expect, it, vi } from 'vitest' import { CONTROL_RPC_PREFIX, registerControlRoute, STATUS_STREAM_PATH, type ControlRouteHandler, type HostWebServerLike, } from '../src/control-route.js' import { ControlStatusStream } from '../src/control-stream.js' import type { HostAuthorizationControl, HostConnectionHandle } from '../src/client-runtime.js' import { resolveConfig } from '../src/config.js' import { PluginControlRuntime } from '../src/control-runtime.js' const servers: Server[] = [] const cleanupContract1 = async () => { vi.useRealTimers() await Promise.all( servers.splice(0).map( (server) => new Promise((resolve) => { server.closeAllConnections() server.close(() => { resolve() }) }), ), ) } afterEach(cleanupContract1) describe('loopback status event stream', () => { it('sends status baselines and changes to current and late subscribers', async () => { await runScenarios( [ { name: 'writes the retry hint and the current status as the first frame', run: async () => { const stream = new ControlStatusStream(async () => ({ mode: 'remote', connected: true }), { retryMs: 3_000, }) const response = fakeResponse() await stream.handle(response.response) expect(response.statusCode).toBe(200) expect(response.headers).toMatchObject({ 'content-type': 'text/event-stream', 'cache-control': 'no-store', }) expect(response.chunks).toEqual(['retry: 3000\n\n', 'data: {"mode":"remote","connected":true}\n\n']) stream.close() }, }, { name: 'pushes a frame only when the sampled status changes', run: async () => { vi.useFakeTimers() let status: Record = { mode: 'local' } const readStatus = vi.fn(async () => status) const stream = new ControlStatusStream(readStatus, { sampleIntervalMs: 10 }) const response = fakeResponse() await stream.handle(response.response) await vi.advanceTimersByTimeAsync(35) expect(readStatus).toHaveBeenCalledTimes(4) expect(response.chunks).toHaveLength(2) status = { mode: 'remote' } await vi.advanceTimersByTimeAsync(10) expect(response.chunks.at(-1)).toBe('data: {"mode":"remote"}\n\n') stream.close() }, }, { name: 'serves a late subscriber the current status without waiting for a change', run: async () => { const stream = new ControlStatusStream(async () => ({ mode: 'remote' })) const first = fakeResponse() await stream.handle(first.response) const second = fakeResponse() await stream.handle(second.response) expect(second.chunks.at(-1)).toBe('data: {"mode":"remote"}\n\n') stream.close() }, }, ], async () => { await cleanupContract1() }, ) }, 15000) it('keeps an idle connection alive with a comment frame', async () => { vi.useFakeTimers() const stream = new ControlStatusStream(async () => ({ mode: 'local' }), { sampleIntervalMs: 10, heartbeatIntervalMs: 50, }) const response = fakeResponse() await stream.handle(response.response) await vi.advanceTimersByTimeAsync(60) expect(response.chunks.filter(chunk => chunk === ': keep-alive\n\n').length).toBeGreaterThan(0) stream.close() }) it('cleans up disconnected, failed and disposed status streams', async () => { await runScenarios( [ { name: 'stops sampling when the client disconnects', run: async () => { vi.useFakeTimers() const readStatus = vi.fn(async () => ({ mode: 'local' })) const stream = new ControlStatusStream(readStatus, { sampleIntervalMs: 10 }) const response = fakeResponse() await stream.handle(response.response) response.disconnect() await vi.advanceTimersByTimeAsync(100) expect(readStatus).toHaveBeenCalledTimes(1) stream.close() }, }, { name: 'drops a subscriber whose response fails and ends every stream on close', run: async () => { vi.useFakeTimers() const broken = fakeResponse({ failWrites: true }) const healthy = fakeResponse() const stream = new ControlStatusStream(async () => ({ mode: 'local' }), { sampleIntervalMs: 10 }) await stream.handle(broken.response) await stream.handle(healthy.response) const writesBefore = broken.writes await vi.advanceTimersByTimeAsync(30) expect(broken.writes).toBe(writesBefore) expect(healthy.chunks.length).toBeGreaterThanOrEqual(2) stream.close() expect(healthy.ended).toBe(true) const refused = fakeResponse() await stream.handle(refused.response) expect(refused.statusCode).toBe(503) }, }, { name: 'ends an open stream when the control route is disposed', run: async () => { const stream = new ControlStatusStream(async () => ({ mode: 'remote' })) const route = captureRoute() const dispose = registerControlRoute( connectionHandle(), async () => ({ ok: true, value: {} }), route.webServer, stream, ) const base = await listen((req, res) => { route.handle(req, res) }) const response = await fetch(`${base}${STATUS_STREAM_PATH}`) const reader = response.body!.getReader() await readText(reader, (text) => text.includes('data: ')) await dispose() await expect(reader.read()).resolves.toMatchObject({ done: true }) }, }, ], async () => { await cleanupContract1() }, ) }, 15000) it('keeps the connection open when the status read fails', async () => { vi.useFakeTimers() let readable = false const stream = new ControlStatusStream(async () => { if (!readable) throw new Error('transport stats unavailable') return { mode: 'remote' } }, { sampleIntervalMs: 10 }) const response = fakeResponse() await stream.handle(response.response) expect(response.chunks).toEqual(['retry: 3000\n\n']) readable = true await vi.advanceTimersByTimeAsync(10) expect(response.chunks.at(-1)).toBe('data: {"mode":"remote"}\n\n') stream.close() }) it('serves the stream over the registered loopback route and keeps the RPC path intact', async () => { const calls: string[] = [] const handler: ControlRouteHandler = async (endpoint, payload): Promise> => { calls.push(`${endpoint}:${JSON.stringify(payload)}`) return { ok: true, value: { mode: 'local' } } } const stream = new ControlStatusStream(async () => ({ mode: 'remote', deviceName: 'host-one' })) const route = captureRoute() const dispose = registerControlRoute(connectionHandle(), handler, route.webServer, stream) const base = await listen((req, res) => { route.handle(req, res) }) const response = await fetch(`${base}${STATUS_STREAM_PATH}`) expect(response.status).toBe(200) expect(response.headers.get('content-type')).toBe('text/event-stream') const reader = response.body!.getReader() const head = await readText(reader, text => text.includes('data: ')) expect(head).toContain('retry: 3000') expect(head).toContain('data: {"mode":"remote","deviceName":"host-one"}') // The RPC path keeps owning POST on the same endpoint name. await expect(fetch(`${base}${STATUS_STREAM_PATH}`, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ type: 'client-request', rpcId: 'rpc-1', method: 'status.events', payload: {} }), })).resolves.toMatchObject({ status: 200 }) await expect(fetch(`${base}${CONTROL_RPC_PREFIX}/settings.get`, { method: 'GET' })).resolves.toMatchObject({ status: 404 }) expect(calls).toEqual(['status.events:{}']) await reader.cancel() await dispose() expect(route.registered).toBe(false) await expect(fetch(`${base}${STATUS_STREAM_PATH}`)).resolves.toMatchObject({ status: 404 }) }) it('streams the control runtime status and ends it with the control route', async () => { const runtime = new PluginControlRuntime( resolveConfig(), '/unused', undefined, undefined, hostControl(), ) const route = captureRoute() const dispose = runtime.register(connectionHandle(), route.webServer) const response = fakeResponse() await route.dispatch({ method: 'GET', url: STATUS_STREAM_PATH, headers: {} }, response.response) expect(response.statusCode).toBe(200) const head = response.chunks.join('') expect(head).toContain('"mode":"local"') expect(head).toContain('"online":true') await dispose() expect(response.ended).toBe(true) }) it('keeps the connection rejection policy in front of the stream', async () => { const stream = new ControlStatusStream(async () => ({ mode: 'local' })) const route = captureRoute() registerControlRoute(connectionHandle(401), async () => ({ ok: true, value: {} }), route.webServer, stream) const base = await listen((req, res) => { route.handle(req, res) }) const response = await fetch(`${base}${STATUS_STREAM_PATH}`) expect(response.status).toBe(401) await expect(response.text()).resolves.toBe('unauthorized') }) it('does not throw when a carrier has no web server or rpc handle', async () => { const dispose = registerControlRoute( { rpc: {} } as unknown as HostConnectionHandle, async () => ({ ok: true, value: {} }), ) await expect(dispose()).resolves.toBeUndefined() }) }) interface FakeResponse { response: ServerResponse readonly chunks: string[] readonly writes: number readonly statusCode: number | undefined readonly headers: Record | undefined readonly ended: boolean disconnect(): void } function fakeResponse(options: { failWrites?: boolean } = {}): FakeResponse { const chunks: string[] = [] const listeners = new Map void)[]>() let statusCode: number | undefined let headers: Record | undefined let ended = false let writes = 0 const response = { destroyed: false, writableEnded: false, writeHead(status: number, next?: Record) { statusCode = status headers = next }, write(chunk: string) { writes += 1 if (options.failWrites === true) throw new Error('write failed') chunks.push(chunk) return true }, end() { ended = true response.writableEnded = true }, on(event: string, listener: () => void) { listeners.set(event, [...(listeners.get(event) ?? []), listener]) return response }, } return { response: response as unknown as ServerResponse, chunks, get writes() { return writes }, get statusCode() { return statusCode }, get headers() { return headers }, get ended() { return ended }, disconnect() { for (const listener of listeners.get('close') ?? []) listener() }, } } function hostControl(): HostAuthorizationControl { return { hostStatus: () => ({ configured: true, online: true, reconnecting: false, authorized: true, accountRequired: false, }), reconnectHost: () => undefined, clearHostAuthorization: async () => undefined, authorizeHostAsOwned: async () => undefined, authorizeHostWithAccount: async () => undefined, authorizeHostWithCode: async () => undefined, } } function connectionHandle(rejection?: number): HostConnectionHandle { return { requestRejection: () => rejection, rpc: { handle: () => async () => undefined }, } as unknown as HostConnectionHandle } /** Stands in for the Host Web server prefix table. */ function captureRoute() { let handler: ((req: IncomingMessage, res: ServerResponse) => void | Promise) | undefined return { webServer: { register: (route: { handler: (req: IncomingMessage, res: ServerResponse) => void | Promise }) => { handler = route.handler return () => { handler = undefined } }, } as unknown as HostWebServerLike, get registered() { return handler !== undefined }, /** Drive one request through the registered prefix route. */ async dispatch(request: { method: string; url: string; headers: Record }, res: ServerResponse): Promise { if (handler === undefined) throw new Error('the loopback prefix route is not registered') await handler(request as unknown as IncomingMessage, res) }, handle(req: IncomingMessage, res: ServerResponse): void { if (handler === undefined) { res.writeHead(404) res.end() return } void handler(req, res) }, } } async function listen(serve: (req: IncomingMessage, res: ServerResponse) => void): Promise { const server = createServer(serve) servers.push(server) await new Promise(resolve => { server.listen(0, '127.0.0.1', resolve) }) const { port } = server.address() as AddressInfo return `http://127.0.0.1:${String(port)}` } async function readText( reader: ReadableStreamDefaultReader, until: (text: string) => boolean, ): Promise { const decoder = new TextDecoder() let text = '' for (let chunk = 0; chunk < 8 && !until(text); chunk += 1) { const { value, done } = await reader.read() if (done) break text += decoder.decode(value, { stream: true }) } return text }