@antelopejs/dms-ai 0.1.2 → 0.1.3

package/frontend-vue/app/runtime/channel-client.ts

@@ -0,0 +1,265 @@
+import {
+	type BackoffState,
+	createBackoff,
+	nextDelay,
+	resetBackoff,
+} from './backoff'
+import {
+	CHANNEL_EVENT_READY,
+	CHANNEL_EVENTS_SEGMENT,
+	CHANNEL_LIST_SEPARATOR,
+	CHANNEL_MESSAGES_SEGMENT,
+	CHANNEL_RECONNECT_DELAYS_MS,
+	CHANNEL_STATUS_CONNECTED,
+	CHANNEL_STATUS_CONNECTING,
+	CHANNEL_STATUS_DISCONNECTED,
+	CHANNEL_STATUS_RECONNECTING,
+	CHANNELS_PATH,
+	EVENT_STREAM_TYPE,
+} from './constants'
+import { readEventStream, type StreamEvent } from './event-stream'
+
+export type ChannelStatus =
+	| typeof CHANNEL_STATUS_CONNECTING
+	| typeof CHANNEL_STATUS_CONNECTED
+	| typeof CHANNEL_STATUS_DISCONNECTED
+	| typeof CHANNEL_STATUS_RECONNECTING
+
+/** Posts one message as JSON; `$authFetch` in the dashboard refreshes a stale session. */
+export type PostMessage = (path: string, body: unknown) => Promise<unknown>
+
+/** Opens the event stream of a set of channels. */
+export type OpenStream = (path: string, signal: AbortSignal) => Promise<Response>
+
+export interface ChannelClientOptions {
+	channels: readonly string[]
+	post: PostMessage
+	openStream?: OpenStream
+	/** Every connection is a new sidecar socket per channel: identify on it here. */
+	onReady?: () => void
+	/** Raw sidecar frame, as the socket of that channel delivered it. */
+	onFrame?: (channel: string, raw: string) => void
+	onStatusChange?: (status: ChannelStatus) => void
+}
+
+export interface ChannelClient {
+	/**
+	 * Queued and posted one at a time, in order. False when it was dropped
+	 * because the stream is not connected, so the caller knows nothing left.
+	 */
+	send: (channel: string, msg: unknown) => boolean
+	isConnected: () => boolean
+	getStatus: () => ChannelStatus
+	/** Opens the stream if it is not open yet. */
+	start: () => void
+	/** Closes the stream until the next `start`. */
+	stop: () => void
+	/**
+	 * Drops any pending backoff and replaces the stream at once, if started.
+	 * The status says connecting until the new stream is ready, since nothing
+	 * can be sent in between.
+	 */
+	reconnectNow: () => void
+}
+
+interface ReadyPayload {
+	connections?: Record<string, unknown>
+}
+
+interface QueuedMessage {
+	channel: string
+	msg: unknown
+}
+
+interface ClientState {
+	options: ChannelClientOptions
+	status: ChannelStatus
+	connections: Record<string, string> | null
+	stream: AbortController | null
+	retryTimer: ReturnType<typeof setTimeout> | null
+	queue: QueuedMessage[]
+	isDraining: boolean
+	isStarted: boolean
+	backoff: BackoffState
+}
+
+export function channelEventsPath(channels: readonly string[]): string {
+	return `${CHANNELS_PATH}/${channels.join(CHANNEL_LIST_SEPARATOR)}/${CHANNEL_EVENTS_SEGMENT}`
+}
+
+export function channelMessagesPath(connectionId: string): string {
+	return `${CHANNELS_PATH}/${encodeURIComponent(connectionId)}/${CHANNEL_MESSAGES_SEGMENT}`
+}
+
+function openEventStream(path: string, signal: AbortSignal): Promise<Response> {
+	return fetch(path, {
+		headers: { accept: EVENT_STREAM_TYPE },
+		credentials: 'same-origin',
+		cache: 'no-store',
+		signal,
+	})
+}
+
+function setStatus(state: ClientState, next: ChannelStatus): void {
+	if (state.status === next) return
+	state.status = next
+	state.options.onStatusChange?.(next)
+}
+
+function readConnections(data: string): Record<string, string> | null {
+	try {
+		const { connections } = JSON.parse(data) as ReadyPayload
+		if (connections === undefined || connections === null) return null
+		const entries = Object.entries(connections).filter(
+			(entry): entry is [string, string] => typeof entry[1] === 'string',
+		)
+		return Object.fromEntries(entries)
+	} catch {
+		return null
+	}
+}
+
+function handleReady(state: ClientState, event: StreamEvent): void {
+	state.connections = readConnections(event.data)
+	resetBackoff(state.backoff)
+	setStatus(state, CHANNEL_STATUS_CONNECTED)
+	state.options.onReady?.()
+}
+
+function handleEvent(state: ClientState, event: StreamEvent): void {
+	if (event.name === CHANNEL_EVENT_READY) return handleReady(state, event)
+	if (!state.options.channels.includes(event.name)) return
+	state.options.onFrame?.(event.name, event.data)
+}
+
+function scheduleRetry(state: ClientState): void {
+	if (state.retryTimer !== null) return
+	const delay = nextDelay(state.backoff, CHANNEL_RECONNECT_DELAYS_MS)
+	state.retryTimer = setTimeout(() => {
+		state.retryTimer = null
+		connect(state)
+	}, delay)
+}
+
+function lose(state: ClientState): void {
+	state.connections = null
+	state.queue = []
+	if (!state.isStarted) return
+	setStatus(state, CHANNEL_STATUS_RECONNECTING)
+	scheduleRetry(state)
+}
+
+async function run(state: ClientState, controller: AbortController): Promise<void> {
+	const open = state.options.openStream ?? openEventStream
+	try {
+		const response = await open(
+			channelEventsPath(state.options.channels),
+			controller.signal,
+		)
+		if (!response.ok || response.body === null) return
+		await readEventStream(response.body, (event) => handleEvent(state, event))
+	} catch {
+		return
+	} finally {
+		if (!controller.signal.aborted) lose(state)
+	}
+}
+
+function connect(state: ClientState): void {
+	if (!state.isStarted) return
+	state.stream?.abort()
+	state.connections = null
+	const controller = new AbortController()
+	state.stream = controller
+	void run(state, controller)
+}
+
+function restart(state: ClientState): void {
+	state.stream?.abort()
+	lose(state)
+}
+
+async function drain(state: ClientState): Promise<void> {
+	if (state.isDraining) return
+	state.isDraining = true
+	while (state.queue.length > 0 && state.connections !== null) {
+		const next = state.queue.shift() as QueuedMessage
+		const connectionId = state.connections[next.channel]
+		if (connectionId === undefined) continue
+		try {
+			await state.options.post(channelMessagesPath(connectionId), next.msg)
+		} catch {
+			restart(state)
+		}
+	}
+	state.isDraining = false
+}
+
+function send(state: ClientState, channel: string, msg: unknown): boolean {
+	if (state.connections?.[channel] === undefined) return false
+	state.queue.push({ channel, msg })
+	void drain(state)
+	return true
+}
+
+function clearRetry(state: ClientState): void {
+	if (state.retryTimer !== null) clearTimeout(state.retryTimer)
+	state.retryTimer = null
+}
+
+function start(state: ClientState): void {
+	if (state.isStarted) return
+	state.isStarted = true
+	resetBackoff(state.backoff)
+	setStatus(state, CHANNEL_STATUS_CONNECTING)
+	connect(state)
+}
+
+function stop(state: ClientState): void {
+	if (!state.isStarted) return
+	state.isStarted = false
+	clearRetry(state)
+	state.stream?.abort()
+	state.connections = null
+	state.queue = []
+	setStatus(state, CHANNEL_STATUS_DISCONNECTED)
+}
+
+function reconnectNow(state: ClientState): void {
+	if (!state.isStarted) return
+	clearRetry(state)
+	resetBackoff(state.backoff)
+	setStatus(state, CHANNEL_STATUS_CONNECTING)
+	connect(state)
+}
+
+/**
+ * One stream to the sidecar through the DMS carrying several channels, and
+ * sequential POSTs to send on each. Browsers keep at most six HTTP/1.1
+ * connections per origin, so a tab holds one such stream and only while it
+ * needs it: the caller starts and stops it. While started, any end of the
+ * stream — a sidecar that went down, a hot reload of dms-ai, a network drop —
+ * reconnects with backoff, and each new connection is announced through
+ * `onReady` so the caller identifies itself again.
+ */
+export function createChannelClient(options: ChannelClientOptions): ChannelClient {
+	const state: ClientState = {
+		options,
+		status: CHANNEL_STATUS_DISCONNECTED,
+		connections: null,
+		stream: null,
+		retryTimer: null,
+		queue: [],
+		isDraining: false,
+		isStarted: false,
+		backoff: createBackoff(),
+	}
+	return {
+		send: (channel, msg) => send(state, channel, msg),
+		isConnected: () => state.connections !== null,
+		getStatus: () => state.status,
+		start: () => start(state),
+		stop: () => stop(state),
+		reconnectNow: () => reconnectNow(state),
+	}
+}

package/frontend-vue/app/runtime/chat-transport.ts

@@ -0,0 +1,82 @@
+import type { ChannelStatus } from './channel-client'
+import { CHAT_TRANSPORT_KEY, LOG_PREFIX } from './constants'
+
+/**
+ * What the chat document, same-origin with the dashboard, reads on its parent
+ * window to reach the sidecar: the dashboard owns the tab's only stream and
+ * lends the chat its channel of it.
+ */
+export interface ChatTransport {
+	/** Raw sidecar frames of the chat channel, in order. */
+	onFrame: (listener: (raw: string) => void) => () => void
+	/** Every (re)connection is a new sidecar socket: the chat says hello again. */
+	onReady: (listener: () => void) => () => void
+	onStatus: (listener: (status: ChannelStatus) => void) => () => void
+	getStatus: () => ChannelStatus
+	/** False when the message was dropped because the channel is not connected. */
+	send: (msg: unknown) => boolean
+	reconnect: () => void
+}
+
+export interface ChatTransportActions {
+	send: (msg: unknown) => boolean
+	reconnect: () => void
+	getStatus: () => ChannelStatus
+}
+
+export interface ChatTransportHub {
+	transport: ChatTransport
+	deliverFrame: (raw: string) => void
+	announceReady: () => void
+	announceStatus: (status: ChannelStatus) => void
+}
+
+interface Listeners<T> {
+	add: (listener: (value: T) => void) => () => void
+	emit: (value: T) => void
+}
+
+function createListeners<T>(): Listeners<T> {
+	const listeners = new Set<(value: T) => void>()
+	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} chat listener failed`, error)
+				}
+			}
+		},
+	}
+}
+
+export function createChatTransport(
+	actions: ChatTransportActions,
+): ChatTransportHub {
+	const frames = createListeners<string>()
+	const ready = createListeners<undefined>()
+	const statuses = createListeners<ChannelStatus>()
+	return {
+		transport: {
+			onFrame: frames.add,
+			onReady: (listener) => ready.add(() => listener()),
+			onStatus: statuses.add,
+			getStatus: actions.getStatus,
+			send: actions.send,
+			reconnect: actions.reconnect,
+		},
+		deliverFrame: frames.emit,
+		announceReady: () => ready.emit(undefined),
+		announceStatus: statuses.emit,
+	}
+}
+
+/** Publishes the transport where the chat document looks for it. */
+export function exposeChatTransport(transport: ChatTransport): void {
+	Reflect.set(globalThis, CHAT_TRANSPORT_KEY, transport)
+}

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

@@ -3,17 +3,36 @@ export const OVERLAY_Z_INDEX = 999_999
 export const OVERLAY_DOM_ID = 'dms-ai-overlay-root'
 export const OVERLAY_IFRAME_ID = 'dms-ai-overlay-iframe'
 export const SIDECAR_INFO_PATH = '/ai/sidecar-info'
-export const SIDECAR_PROBE_HOST = 'http://localhost'
+/** The chat document, served through the DMS from the dashboard's own origin. */
+export const CHATBOX_PATH = '/api/ai/chatbox/'
+/** Event stream to receive, POST to send: HTTP the DMS frontend server relays. */
+export const CHANNELS_PATH = '/ai/channels'
+export const CHANNEL_EVENTS_SEGMENT = 'events'
+export const CHANNEL_MESSAGES_SEGMENT = 'messages'
+export const CHANNEL_LIST_SEPARATOR = ','
+export const HOST_CHANNEL = 'host'
+export const CHAT_CHANNEL = 'chat'
+export const CHANNEL_EVENT_READY = 'ready'
+/**
+ * How long the stream outlives a closed panel or a hidden tab, so a quick
+ * close and reopen does not reconnect, while a tab left in the background soon
+ * gives back its one of the browser's six HTTP/1.1 connections to the dashboard.
+ */
+export const CHANNEL_IDLE_STOP_MS = 2_000
+export const VISIBILITY_CHANGE_EVENT = 'visibilitychange'
+/** Where the chat document, same-origin, finds the dashboard's chat transport. */
+export const CHAT_TRANSPORT_KEY = 'dmsAiChatTransport'
+export const OVERLAY_OPEN_CHANGE_EVENT = 'dms-ai:open-change'
+export const EVENT_STREAM_TYPE = 'text/event-stream'
+export const JSON_CONTENT_TYPE = 'application/json'
 export const OVERLAY_BOX_SHADOW = '0 8px 24px rgba(0, 0, 0, 0.18)'
-export const SIDECAR_HOST_NAME = 'localhost'
-export const WS_HOST_PATH = '/ws/host'
-export const WS_RECONNECT_DELAYS_MS = [
+export const CHANNEL_RECONNECT_DELAYS_MS = [
 	1000, 2000, 4000, 8000, 15000, 30000,
 ] as const
 // Sidecar reachability, as seen by the host. `reviving` is the self-healing
-// state (idle-exited / crashed-respawning): the probe loop is relearning the new
-// random port and will repoint the frame. `unavailable` is terminal (the crash
-// budget is spent) and needs a reload.
+// state (idle-exited / crashed-respawning): the probe loop revives the sidecar
+// and the channels reconnect once it answers. `unavailable` is terminal (the
+// crash budget is spent) and needs a reload.
 export const SIDECAR_STATUS_CONNECTING = 'connecting'
 export const SIDECAR_STATUS_CONNECTED = 'connected'
 export const SIDECAR_STATUS_REVIVING = 'reviving'
@@ -30,13 +49,10 @@ export const PLACEHOLDER_REVIVING_TEXT = 'Reconnecting the assistant…'
 export const PLACEHOLDER_UNAVAILABLE_TITLE = 'Assistant unavailable'
 export const PLACEHOLDER_UNAVAILABLE_TEXT = 'Reload the page to try again.'
 
-export const WS_STATUS_CONNECTING = 'connecting'
-export const WS_STATUS_CONNECTED = 'connected'
-export const WS_STATUS_DISCONNECTED = 'disconnected'
-export const WS_STATUS_RECONNECTING = 'reconnecting'
-export const WS_PROTOCOL_SECURE = 'wss:'
-export const WS_PROTOCOL_INSECURE = 'ws:'
-export const PAGE_PROTOCOL_SECURE = 'https:'
+export const CHANNEL_STATUS_CONNECTING = 'connecting'
+export const CHANNEL_STATUS_CONNECTED = 'connected'
+export const CHANNEL_STATUS_DISCONNECTED = 'disconnected'
+export const CHANNEL_STATUS_RECONNECTING = 'reconnecting'
 export const HOST_ROLE = 'host'
 export const HELLO_MESSAGE_TYPE = 'hello'
 export const LOG_PREFIX = '[dms-ai]'

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

@@ -14,14 +14,18 @@ interface InstallCurrentPageTrackerOptions {
 	send: (msg: HostStateUpdateMessage) => void
 }
 
+/** The state update announcing the page at `url`. */
+export function buildCurrentPageUpdate(url: string): HostStateUpdateMessage {
+	return {
+		type: HOST_STATE_UPDATE_TYPE,
+		currentPage: { path: new URL(url, window.location.origin).pathname },
+	}
+}
+
 export function installCurrentPageTracker(
 	options: InstallCurrentPageTrackerOptions,
 ): () => void {
-	const pushFor = (url: string): void =>
-		options.send({
-			type: HOST_STATE_UPDATE_TYPE,
-			currentPage: { path: new URL(url, window.location.origin).pathname },
-		})
+	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

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

@@ -0,0 +1,75 @@
+export interface StreamEvent {
+	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'
+
+interface Field {
+	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)
+	return {
+		name: line.slice(0, boundary),
+		value: raw.startsWith(' ') ? raw.slice(1) : raw,
+	}
+}
+
+function parseFrame(frame: string): StreamEvent | null {
+	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)
+	}
+	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() ?? ''
+	for (const frame of frames) {
+		const event = parseFrame(frame)
+		if (event !== null) onEvent(event)
+	}
+	return rest
+}
+
+/**
+ * Delivers every event of a text/event-stream body until it ends. Read over
+ * fetch rather than EventSource, like the DMS realtime stream, so a failed
+ * request surfaces its status and nothing reconnects behind the caller's back.
+ */
+export async function readEventStream(
+	body: ReadableStream<Uint8Array>,
+	onEvent: (event: StreamEvent) => void,
+): Promise<void> {
+	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)
+		}
+	} finally {
+		reader.releaseLock()
+	}
+}

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

@@ -4,6 +4,7 @@ import {
 	OVERLAY_DOM_ID,
 	OVERLAY_IFRAME_ID,
 	OVERLAY_MIN_WIDTH_PX,
+	OVERLAY_OPEN_CHANGE_EVENT,
 	OVERLAY_OUTSIDE_TOGGLE_SUPPRESS_MS,
 	OVERLAY_PLACEHOLDER_ID,
 	OVERLAY_RESIZE_HANDLE_SIZE_PX,
@@ -21,6 +22,7 @@ import {
 import {
 	type HostTheme,
 	installThemeBridge,
+	isFromFrame,
 	readHostMode,
 } from './theme-bridge'
 
@@ -37,7 +39,9 @@ export interface OverlayHandle {
 	// use `toggleOpen` so it is never suppressed.
 	toggleFromLauncher: () => void
 	isOpen: () => boolean
-	// Point the frame at a (possibly new) sidecar URL. A no-op when the URL is
+	/** Called on every open or close, however the panel was toggled. */
+	onOpenChange: (listener: (isOpen: boolean) => void) => () => void
+	// Point the frame at the chat document. A no-op when the URL is
 	// unchanged and already loaded, so a redundant `connected` notify won't reload
 	// the chatbox; otherwise it reloads and shows a connecting placeholder until
 	// the frame paints.
@@ -106,9 +110,9 @@ function buildContainer(): HTMLDivElement {
 	return container
 }
 
-// Built with no `src`: the frame is only pointed at the sidecar via `repoint`
-// once the status controller confirms a reachable port, so the browser never
-// renders its native "can't reach" page for a dead port.
+// Built with no `src`: the frame is only pointed at the chat via `repoint` once
+// the status controller confirms the sidecar runs, so it never renders the
+// error page of a sidecar that is down.
 function buildIframe(): HTMLIFrameElement {
 	const iframe = document.createElement('iframe')
 	iframe.id = OVERLAY_IFRAME_ID
@@ -291,8 +295,8 @@ function createPlaceholderController(
 }
 
 // Repoint the frame at `url`, deferring the placeholder-hide until it paints so a
-// port change reloads the chatbox without flashing the previous dead frame. A
-// no-op reload when the URL is already loaded.
+// reload of the chatbox never flashes the previous frame. A no-op reload when
+// the URL is already loaded.
 function createRepointer(
 	iframe: HTMLIFrameElement,
 	placeholder: PlaceholderController,
@@ -321,9 +325,14 @@ function setOpen(
 	stateRef: OverlayPrefsRef,
 	isOpen: boolean,
 ): void {
+	const hasChanged = stateRef.value.isOpen !== isOpen
 	stateRef.value = { ...stateRef.value, isOpen }
 	applyPrefs(elements, stateRef.value)
 	writePrefsDebounced(stateRef.value)
+	if (!hasChanged) return
+	elements.container.dispatchEvent(
+		new CustomEvent(OVERLAY_OPEN_CHANGE_EVENT, { detail: isOpen }),
+	)
 }
 
 export function injectOverlay(): OverlayHandle | null {
@@ -360,6 +369,7 @@ export function injectOverlay(): OverlayHandle | null {
 	// The chatbox header's close button lives inside the iframe; it asks the
 	// host to slide the panel away via postMessage.
 	globalThis.addEventListener('message', (event: MessageEvent) => {
+		if (!isFromFrame(event, elements.iframe)) return
 		const type = (event.data as MessageData)?.type
 		if (typeof type === 'string' && CLOSE_MESSAGE_TYPES.has(type)) {
 			setOpen(elements, stateRef, false)
@@ -377,6 +387,13 @@ export function injectOverlay(): OverlayHandle | null {
 			toggle()
 		},
 		isOpen: (): boolean => stateRef.value.isOpen,
+		onOpenChange: (listener) => {
+			const onChange = (event: Event): void =>
+				listener((event as CustomEvent<boolean>).detail)
+			elements.container.addEventListener(OVERLAY_OPEN_CHANGE_EVENT, onChange)
+			return () =>
+				elements.container.removeEventListener(OVERLAY_OPEN_CHANGE_EVENT, onChange)
+		},
 		repoint,
 		showPlaceholder: (kind) => placeholder.show(kind),
 	}

package/frontend-vue/app/runtime/sidecar-status.ts

@@ -14,8 +14,6 @@ export type SidecarStatus =
 	| typeof SIDECAR_STATUS_UNAVAILABLE
 
 interface SidecarInfo {
-	port: number | null
-	clientToken: string | null
 	isRunning: boolean
 	hasGivenUp: boolean
 	disabled: boolean
@@ -27,14 +25,14 @@ export interface SidecarStatusController {
 	// is disabled for this process — so the caller skips injection entirely.
 	init: () => Promise<boolean>
 	getStatus: () => SidecarStatus
-	getPort: () => number | null
-	getClientToken: () => string | null
 	// Subscribe to status changes; fires immediately with the current status so a
 	// late subscriber (overlay/icon injected after init) reflects it right away.
 	subscribe: (cb: (status: SidecarStatus) => void) => () => void
-	// The host WebSocket dropped: re-probe now to relearn a possibly-new port
-	// rather than let the socket keep retrying the dead one.
-	reportWsDown: () => void
+	/**
+	 * The host channel dropped: re-probe now, which also revives an idle-exited
+	 * sidecar, and report `connected` again once it answers.
+	 */
+	reportChannelDown: () => void
 	dispose: () => void
 }
 
@@ -46,9 +44,6 @@ async function fetchInfo(
 	try {
 		const body = await fetchDetails()
 		return {
-			port: typeof body.port === 'number' ? body.port : null,
-			clientToken:
-				typeof body.clientToken === 'string' ? body.clientToken : null,
 			isRunning: body.isRunning === true,
 			hasGivenUp: body.hasGivenUp === true,
 			disabled: body.disabled === true,
@@ -64,8 +59,6 @@ export function createSidecarStatusController(
 	const backoff = createBackoff()
 	const subscribers = new Set<(status: SidecarStatus) => void>()
 	let status: SidecarStatus = SIDECAR_STATUS_CONNECTING
-	let port: number | null = null
-	let clientToken: string | null = null
 	let pollTimer: ReturnType<typeof setTimeout> | null = null
 	let disposed = false
 
@@ -105,19 +98,13 @@ export function createSidecarStatusController(
 			setStatus(SIDECAR_STATUS_UNAVAILABLE)
 			return
 		}
-		if (info.isRunning && info.port !== null && info.clientToken) {
-			port = info.port
-			clientToken = info.clientToken
+		if (info.isRunning) {
 			resetBackoff(backoff)
-			// A reviving→connected transition notifies via setStatus; a port change
-			// while already connected leaves the status word unchanged, so force a
-			// notify there too to drive the overlay/WS onto the new port.
-			if (status === SIDECAR_STATUS_CONNECTED) notify()
-			else setStatus(SIDECAR_STATUS_CONNECTED)
+			setStatus(SIDECAR_STATUS_CONNECTED)
 			return
 		}
 		// Down but not terminal — the probe already asked the backend to respawn;
-		// keep polling until it reports a port.
+		// keep polling until it reports the sidecar running.
 		setStatus(SIDECAR_STATUS_REVIVING)
 		schedulePoll()
 	}
@@ -131,8 +118,6 @@ export function createSidecarStatusController(
 			return true
 		},
 		getStatus: () => status,
-		getPort: () => port,
-		getClientToken: () => clientToken,
 		subscribe: (cb) => {
 			subscribers.add(cb)
 			cb(status)
@@ -140,13 +125,13 @@ export function createSidecarStatusController(
 				subscribers.delete(cb)
 			}
 		},
-		reportWsDown: () => {
+		reportChannelDown: () => {
 			if (disposed) return
 			if (status !== SIDECAR_STATUS_CONNECTED) return
 			// Surface the drop right away (amber dot + spinner) instead of waiting on
 			// the re-probe: that probe awaits a respawn and can take a second or two,
 			// during which the icon would otherwise look healthy. poll() flips back
-			// to connected once the new port is live.
+			// to connected once the sidecar answers again.
 			resetBackoff(backoff)
 			setStatus(SIDECAR_STATUS_REVIVING)
 			void poll()