Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
/** Same-origin daemon polling over the existing sequential HTTP transport.
* Off means zero requests. Cursors are committed only after a validated page;
* reconnects retain state, and a replaced SQLite database resets its generation. */
import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
import type { AgentEvent } from './agent-event';
import { readAgentEvent } from './agent-event';
import { emptyAgentsState, withEvent } from './agent-store';
import type { AgentsState } from './agent-store';
/** Kept as a source compatibility name; the current daemon port is used. */
export const DEFAULT_BRIDGE_PORT = 9749;
export const RECONNECT_MS = 3000;
export const POLL_MS = 1000;
export function bridgeCommand(_port: number): string {
return 'codebase-memory-mcp --ui';
}
/** Die Lage der Quelle. */
export type SourceState =
/** Der Live-Modus ist aus. Es geht keine Anfrage hinaus. */
| 'off'
/** Eine Verbindung laeuft gerade an. */
| 'connecting'
/** Der Daemon antwortet mit gespeicherten Ereignissen. */
| 'connected'
/** Der Modus ist an und niemand antwortet. */
| 'no-source';
/** Quelleninformation des Daemons (Feldnamen kompatibel zum bisherigen HUD). */
export interface BridgeHello {
/** `live` liest die lokale SQLite-Historie, `replay` bezeichnet Testaufzeichnungen. */
mode: string;
/** Lesbare Bezeichnung der Datenquelle. */
file: string;
/** Wie viele Ereignisse der Daemon aktuell aufbewahrt. */
events: number;
/** Wie viele empfangene Ereignisse nicht lesbar waren. */
unreadable: number;
}
/** Was die Oberflaeche ueber ihre Quelle weiss. */
export interface AgentSourceStatus {
state: SourceState;
/** Der Ursprung, mit dem geredet wird. Leer, solange der Modus aus ist. */
origin: string;
/** Wie viele Anfragen dieses Modul gestellt hat, seit die Seite laedt. */
requests: number;
/** Wie oft die Verbindung abgerissen ist. */
drops: number;
/** Metadaten der zuletzt gelesenen Daemon-Antwort. */
hello: BridgeHello | undefined;
/** Der letzte Fehler, woertlich. Leer, wenn keiner. */
error: string;
}
/** Ein Rahmen des Ereignisstroms: der Name und der Rumpf. */
export interface SseFrame {
event: string;
data: string;
}
/**
* Einen Rahmen lesen.
*
* Nur die zwei Felder, die dieser Draht braucht. Zeilen, die mit einem
* Doppelpunkt beginnen, sind Kommentare (die Bruecke schickt sie, damit die
* Leitung offen bleibt) und ergeben nichts.
*/
export function parseSseFrame(raw: string): SseFrame | undefined {
let name = 'message';
const data: string[] = [];
for (const line of raw.split('\n')) {
if (line.startsWith(':') || line.length === 0) {
continue;
}
if (line.startsWith('event:')) {
name = line.slice(6).trim();
continue;
}
if (line.startsWith('data:')) {
data.push(line.slice(5).trimStart());
}
}
return data.length === 0 ? undefined : { event: name, data: data.join('\n') };
}
/** Der aktuelle Daemon-Port; ein alter agents-Parameter hat keine Wirkung. */
export function bridgePortFromSearch(_search: string): number {
return typeof location === 'undefined' ? DEFAULT_BRIDGE_PORT : Number(location.port) || 80;
}
export interface AgentStreamOptions {
/** Ob der Live-Modus an ist. Aus heisst: keine Anfrage. */
on: boolean;
/** Kompatibilitaetsfeld fuer alte Aufrufer; der Transport verwendet same-origin. */
port?: number;
project?: string;
/** Ersetzbares fetch, damit Tests ohne Netz laufen. */
fetch?: typeof globalThis.fetch | undefined;
}
/** Was der Aufrufer bekommt. */
export interface AgentStream {
state: AgentsState;
status: AgentSourceStatus;
/** Ein eigenes Browsereignis lokal dazulegen. */
push: (event: AgentEvent, you: boolean) => void;
}
/**
* Der Strom, wie ihn die Panels bekommen: samt Port, damit das Instrument den
* vorhandenen Daemon-Port anzeigen kann.
*/
export interface AgentsRuntime extends AgentStream {
port: number;
/** Ob der Live-Modus an ist. */
on: boolean;
}
/**
* Den Strom fuehren.
*
* Der Zustand liegt in einem Ref und wird in den React-Zustand gespiegelt: eine
* Verbindung, die zwanzig Ereignisse in einer Sekunde liefert, soll nicht
* zwanzig Zustandsketten aufmachen, aus denen jede die vorige ueberschreibt.
*/
export function useAgentStream(options: AgentStreamOptions): AgentStream {
const project = options.project ?? '';
const fetchImpl = options.fetch;
const on = options.on;
const stateRef = useRef<AgentsState>(emptyAgentsState());
const [reading, setReading] = useState({ project, value: stateRef.current });
const requests = useRef(0);
const drops = useRef(0);
const cursor = useRef(0);
const incomplete = useRef(false);
const generation = useRef<string | undefined>(undefined);
const previousProject = useRef(project);
const [source, setSource] = useState<{ project: string; value: AgentSourceStatus }>({ project, value: {
state: 'off',
origin: '',
requests: 0,
drops: 0,
hello: undefined,
error: '',
} });
const push = useCallback((event: AgentEvent, you: boolean) => {
if (previousProject.current !== project) return;
const next = withEvent(stateRef.current, event);
stateRef.current = you
? {
...next,
actors: next.actors.map((actor) =>
(actor.id === event.agent ? { ...actor, you: true } : actor)),
}
: next;
setReading({ project, value: stateRef.current });
}, [project]);
useEffect(() => {
if (previousProject.current !== project) {
previousProject.current = project;
cursor.current = 0;
generation.current = undefined;
incomplete.current = false;
stateRef.current = emptyAgentsState();
setReading({ project, value: stateRef.current });
}
if (!on) {
setSource({ project, value: {
state: 'off',
origin: '',
requests: requests.current,
drops: drops.current,
hello: undefined,
error: '',
} });
return;
}
const origin = typeof location === 'undefined' ? '' : location.origin;
const doFetch = fetchImpl ?? globalThis.fetch;
let stopped = false;
let controller: AbortController | null = null;
let timer: ReturnType<typeof setTimeout> | undefined;
const announce = (patch: Partial<AgentSourceStatus>): void => {
setSource((current) => ({ project, value: {
...(current.project === project ? current.value : { state: 'connecting', hello: undefined, error: '' }),
origin,
requests: requests.current,
drops: drops.current,
...patch,
} }));
};
const connect = async (): Promise<void> => {
if (stopped) {
return;
}
controller = new AbortController();
const url = `/api/agent-events?project=${encodeURIComponent(project)}&after=${cursor.current}&limit=200`;
requests.current += 1;
if (cursor.current === 0) announce({ state: 'connecting', error: '' });
try {
const response = await doFetch(url, { signal: controller.signal });
if (!response.ok) throw new Error(`daemon activity: HTTP ${response.status}`);
const page = await response.json() as {
events: unknown[]; cursor: number; generation: string; reset: boolean;
has_more: boolean; truncated: boolean; retained: number;
};
if (!Array.isArray(page.events) || !Number.isSafeInteger(page.cursor)
|| page.cursor < 0 || typeof page.generation !== 'string') {
throw new Error('Invalid daemon activity response');
}
if (stopped) return;
if (page.reset || (generation.current !== undefined && generation.current !== page.generation)) {
stateRef.current = emptyAgentsState();
cursor.current = 0;
incomplete.current = false;
generation.current = page.generation;
setReading({ project, value: stateRef.current });
timer = setTimeout(() => void connect(), 0);
return;
}
generation.current = page.generation;
let next = stateRef.current;
for (const raw of page.events) {
const event = readAgentEvent(raw);
if (event !== undefined) next = withEvent(next, event);
else next = { ...next, unreadable: next.unreadable + 1 };
}
stateRef.current = next;
cursor.current = page.cursor;
incomplete.current ||= page.truncated;
setReading({ project, value: next });
announce({ state: 'connected', error: incomplete.current
? 'Older activity expired from local retention; this history is incomplete.' : '',
hello: { mode: 'live', file: 'daemon SQLite activity', events: page.retained, unreadable: next.unreadable } });
timer = setTimeout(() => void connect(), page.has_more ? 0 : POLL_MS);
} catch (failure) {
if (stopped) return;
drops.current += 1;
announce({ state: 'no-source', error: failure instanceof Error ? failure.message : String(failure) });
timer = setTimeout(() => void connect(), RECONNECT_MS);
}
};
void connect();
return () => {
stopped = true;
if (timer !== undefined) {
clearTimeout(timer);
}
controller?.abort();
};
}, [on, project, fetchImpl]);
// A passive effect resets the cursor, but the first render of another
// project must already hide the previous project's events and provenance.
return useMemo(() => ({
state: reading.project === project ? reading.value : emptyAgentsState(),
status: source.project === project ? source.value : {
state: on ? 'connecting' as const : 'off' as const, origin: '',
requests: requests.current, drops: drops.current, hello: undefined, error: '',
},
push,
}), [reading, source, project, on, push]);
}