@schlessera/brain-ui-server 0.13.0 → 0.14.0

package/src/routes/graph.ts

@@ -49,8 +49,10 @@ function invalid(param: string) {
   return { error: "invalid_param", param } as const;
 }
 
-export const graphRoutes = new Hono()
-  .get("/graph/meta", (c) => c.json(getGraphMeta()))
+export function createGraphRoutes(deps: { brainRoot: string }): Hono {
+  const { brainRoot } = deps;
+  return new Hono()
+  .get("/graph/meta", (c) => c.json(getGraphMeta({ brainPath: brainRoot })))
 
   .get("/graph/clusters", (c) => {
     const rawCommunity = c.req.query("community");
@@ -61,7 +63,7 @@ export const graphRoutes = new Hono()
     }
 
     try {
-      return c.json(getClusters({ community, includeIsolates: c.req.query("isolates") === "1" }));
+      return c.json(getClusters({ brainPath: brainRoot, community, includeIsolates: c.req.query("isolates") === "1" }));
     } catch (err) {
       const { body, status } = errorResponse(err);
       return c.json(body, status);
@@ -77,7 +79,7 @@ export const graphRoutes = new Hono()
     if (direction === null) return c.json(invalid("direction"), 400);
 
     try {
-      return c.json(getNeighborhood({ center, depth, direction }));
+      return c.json(getNeighborhood({ brainPath: brainRoot, center, depth, direction }));
     } catch (err) {
       const { body, status } = errorResponse(err);
       return c.json(body, status);
@@ -92,7 +94,7 @@ export const graphRoutes = new Hono()
     if (maxDepth === null) return c.json(invalid("maxDepth"), 400);
 
     try {
-      return c.json(getDiscovery({ root, direction, maxDepth }));
+      return c.json(getDiscovery({ brainPath: brainRoot, root, direction, maxDepth }));
     } catch (err) {
       const { body, status } = errorResponse(err);
       return c.json(body, status);
@@ -104,9 +106,10 @@ export const graphRoutes = new Hono()
     if (staleDays === null) return c.json(invalid("staleDays"), 400);
 
     try {
-      return c.json(getMaintenance({ staleDays }));
+      return c.json(getMaintenance({ brainPath: brainRoot, staleDays }));
     } catch (err) {
       const { body, status } = errorResponse(err);
       return c.json(body, status);
     }
   });
+}

package/src/routes/health.ts

@@ -1,6 +1,4 @@
 import { Hono } from "hono";
-import { getCronStatus } from "../cron/scheduler.js";
-import { isTurnActive } from "../ws/handler.js";
 
 const startTime = Date.now();
 
@@ -15,15 +13,24 @@ export const healthRoutes = new Hono().get("/health", (c) => {
   });
 });
 
+export interface StatusDeps {
+  /** Git SHA baked at build time (SOURCE_COMMIT), "dev" when unset. */
+  sourceCommit: string;
+  getCronStatus(): unknown;
+  isTurnActive(): boolean;
+}
+
 // Operational status. Registered BEHIND the auth guard: it exposes the git SHA,
 // cron job errors (raw stderr with filesystem paths), and whether a turn is
 // active — none of which should be readable unauthenticated.
-export const statusRoutes = new Hono().get("/status", (c) => {
-  return c.json({
-    healthy: true,
-    uptime: Date.now() - startTime,
-    version: process.env.SOURCE_COMMIT ?? "dev",
-    cronJobs: getCronStatus(),
-    activeSession: isTurnActive(),
+export function createStatusRoutes(deps: StatusDeps): Hono {
+  return new Hono().get("/status", (c) => {
+    return c.json({
+      healthy: true,
+      uptime: Date.now() - startTime,
+      version: deps.sourceCommit,
+      cronJobs: deps.getCronStatus(),
+      activeSession: deps.isTurnActive(),
+    });
   });
-});
+}

package/src/routes/models.ts

@@ -6,22 +6,25 @@
 // was last refreshed and why it might be stale.
 
 import { Hono } from "hono";
+import type { Database } from "bun:sqlite";
 import type {
   ModelCatalogEntry,
   ModelCatalogResponse,
 } from "@schlessera/brain-ui-sdk";
-import {
-  getModelSource,
-  invalidateProfiles,
-  listAllProviders,
-} from "../agent/backend.js";
+import type { BackendRegistry } from "../agent/backend.js";
 import { getHiddenModelIds, setHiddenModelIds } from "../db/settings.js";
 
-async function buildCatalog(): Promise<ModelCatalogResponse> {
-  const source = await getModelSource();
-  const hidden = new Set(getHiddenModelIds());
+export function createModelRoutes(deps: {
+  registry: BackendRegistry;
+  db: Database;
+}): Hono {
+  const { registry, db } = deps;
+
+  async function buildCatalog(): Promise<ModelCatalogResponse> {
+  const source = await registry.getModelSource();
+  const hidden = new Set(getHiddenModelIds(db));
   const models: ModelCatalogEntry[] = (
-    await listAllProviders({ includeHidden: true })
+    await registry.listAllProviders({ includeHidden: true })
   ).map((profile) => ({ ...profile, hidden: hidden.has(profile.id) }));
 
   const state = source?.state();
@@ -36,11 +39,11 @@ async function buildCatalog(): Promise<ModelCatalogResponse> {
   };
 }
 
-export const modelRoutes = new Hono()
+  return new Hono()
   .get("/models", async (c) => {
     // Serves the cached roster immediately and refreshes behind the response
     // when stale; only a cold start (nothing cached) waits on the network.
-    const source = await getModelSource();
+    const source = await registry.getModelSource();
     await source?.ensureFresh();
     return c.json(await buildCatalog());
   })
@@ -55,14 +58,14 @@ export const modelRoutes = new Hono()
       return c.json({ error: "hidden must be an array of profile ids" }, 400);
     }
 
-    setHiddenModelIds(hidden as string[]);
+    setHiddenModelIds(db, hidden as string[]);
     // The picker reads through a memo — drop it so the change is immediate.
-    invalidateProfiles();
+    registry.invalidateProfiles();
     return c.json(await buildCatalog());
   })
 
   .post("/models/refresh", async (c) => {
-    const source = await getModelSource();
+    const source = await registry.getModelSource();
     if (!source) {
       return c.json(
         { error: "Model discovery is not available on this backend" },
@@ -80,6 +83,7 @@ export const modelRoutes = new Hono()
         }`
       );
     }
-    invalidateProfiles();
+    registry.invalidateProfiles();
     return c.json(await buildCatalog());
   });
+}

package/src/routes/providers.ts

@@ -1,19 +1,18 @@
 import { Hono } from "hono";
-import {
-  getBackendsInfo,
-  getModelSource,
-  listAllProviders,
-} from "../agent/backend.js";
+import type { BackendRegistry } from "../agent/backend.js";
 
-export const providerRoutes = new Hono().get("/providers", async (c) => {
-  // Keeps the roster current without a restart: serves the cached list and
-  // refreshes behind the response when it has gone stale. Only a cold start
-  // (nothing cached yet) waits on the Models API.
-  const source = await getModelSource();
-  await source?.ensureFresh();
+export function createProviderRoutes(deps: { registry: BackendRegistry }): Hono {
+  const { registry } = deps;
+  return new Hono().get("/providers", async (c) => {
+    // Keeps the roster current without a restart: serves the cached list and
+    // refreshes behind the response when it has gone stale. Only a cold start
+    // (nothing cached yet) waits on the Models API.
+    const source = await registry.getModelSource();
+    await source?.ensureFresh();
 
-  return c.json({
-    providers: await listAllProviders(),
-    backends: await getBackendsInfo(),
+    return c.json({
+      providers: await registry.listAllProviders(),
+      backends: await registry.getBackendsInfo(),
+    });
   });
-});
+}

package/src/routes/sessions.ts

@@ -1,18 +1,24 @@
 import { Hono } from "hono";
-import { getBackendForSession, getBackends } from "../agent/backend.js";
-import { getDb } from "../db/client.js";
+import type { Database } from "bun:sqlite";
+import type { BackendRegistry } from "../agent/backend.js";
 
-function getStoredBackendId(sessionId: string): string | null {
-  const row = getDb()
-    .query("SELECT backend_id AS backendId FROM sessions WHERE id = ?")
-    .get(sessionId) as { backendId: string | null } | null;
-  return row?.backendId ?? null;
-}
+export function createSessionRoutes(deps: {
+  registry: BackendRegistry;
+  db: Database;
+}): Hono {
+  const { registry, db } = deps;
+
+  function getStoredBackendId(sessionId: string): string | null {
+    const row = db
+      .query("SELECT backend_id AS backendId FROM sessions WHERE id = ?")
+      .get(sessionId) as { backendId: string | null } | null;
+    return row?.backendId ?? null;
+  }
 
-export const sessionRoutes = new Hono()
+  return new Hono()
   .get("/sessions", async (c) => {
     try {
-      const backends = await getBackends();
+      const backends = await registry.getBackends();
       const sessions = (
         await Promise.all(
           backends.map(async (backend) =>
@@ -37,7 +43,7 @@ export const sessionRoutes = new Hono()
   .get("/sessions/:id", async (c) => {
     const id = c.req.param("id");
     try {
-      const backend = await getBackendForSession(getStoredBackendId(id));
+      const backend = await registry.getBackendForSession(getStoredBackendId(id));
       const messages = await backend.getHistory(id);
       return c.json({ id, messages });
     } catch (err) {
@@ -47,3 +53,4 @@ export const sessionRoutes = new Hono()
       );
     }
   });
+}

package/src/routes/share.ts

@@ -82,39 +82,49 @@ export const shareTargetFallbackRoutes = new Hono().post("/share-target", (c) =>
   c.redirect("/?share_error=no_worker", 303)
 );
 
-/**
- * In-flight intakes. Each one holds its whole payload in memory while the
- * multipart parser runs, so without a bound the per-share cap multiplies by
- * however many clients ask at once — on a box that also runs headless Chrome
- * for the renderer.
- */
-let inFlight = 0;
-
-/** At most one sweep per interval: the intake path should not stat the inbox on every upload. */
-let lastPrune = 0;
 const PRUNE_INTERVAL_MS = 10 * 60 * 1000;
 
-function maybePrune(): void {
-  const now = Date.now();
-  if (now - lastPrune < PRUNE_INTERVAL_MS) return;
-  lastPrune = now;
-  // Deliberately not awaited: pruning is housekeeping, and the client is
-  // waiting on the staging result, not on it.
-  void pruneShareStaging().catch((err) => {
-    console.error("[share] prune failed:", err);
-  });
-}
-
 function firstString(form: FormData, name: string): string | undefined {
   const value = form.get(name);
   return typeof value === "string" && value.trim() ? value : undefined;
 }
 
-export const shareRoutes = new Hono().post("/share", async (c) => {
+export interface ShareRoutesDeps {
+  brainRoot: string;
+  /** ALLOWED_ORIGINS — the same-origin check's split-topology allowlist. */
+  allowedOrigins: string[];
+}
+
+export function createShareRoutes(deps: ShareRoutesDeps): Hono {
+  const { brainRoot, allowedOrigins } = deps;
+
+  /**
+   * In-flight intakes. Each one holds its whole payload in memory while the
+   * multipart parser runs, so without a bound the per-share cap multiplies by
+   * however many clients ask at once — on a box that also runs headless Chrome
+   * for the renderer.
+   */
+  let inFlight = 0;
+
+  /** At most one sweep per interval: the intake path should not stat the inbox on every upload. */
+  let lastPrune = 0;
+
+  function maybePrune(): void {
+    const now = Date.now();
+    if (now - lastPrune < PRUNE_INTERVAL_MS) return;
+    lastPrune = now;
+    // Deliberately not awaited: pruning is housekeeping, and the client is
+    // waiting on the staging result, not on it.
+    void pruneShareStaging(brainRoot).catch((err) => {
+      console.error("[share] prune failed:", err);
+    });
+  }
+
+  return new Hono().post("/share", async (c) => {
   // See middleware/origin.ts: a multipart POST is a CORS-simple request, so it
   // reaches this route with no preflight, and in tailscale mode the credential
   // is the source IP. This route is only ever called by the app itself.
-  if (!isSameOriginRequest(c)) {
+  if (!isSameOriginRequest(c, allowedOrigins)) {
     return c.json({ error: "cross_origin_rejected" }, 403);
   }
 
@@ -154,7 +164,7 @@ export const shareRoutes = new Hono().post("/share", async (c) => {
 
   inFlight += 1;
   try {
-    const result = await stageShare({
+    const result = await stageShare(brainRoot, {
       title: firstString(form, "title"),
       text: firstString(form, "text"),
       url: firstString(form, "url"),
@@ -176,3 +186,4 @@ export const shareRoutes = new Hono().post("/share", async (c) => {
     inFlight -= 1;
   }
 });
+}

package/src/routes/voice.ts

@@ -4,77 +4,87 @@ import type {
   VoiceTokenResponse,
   VoiceSessionResponse,
 } from "@schlessera/brain-ui-sdk/protocol";
+import type { VoiceConfig } from "../config/env.js";
 import { mintDeepgramToken } from "../voice/deepgram-token.js";
-import { getKeyterms } from "../voice/keyterm-builder.js";
+import { getKeyterms, type KeytermSettings } from "../voice/keyterm-builder.js";
 import { pickSpeechProvider } from "../voice/speech-providers.js";
 
-export const voiceRoutes = new Hono()
-  .post("/voice/session", async (c) => {
-    try {
-      const provider = pickSpeechProvider();
-      // Only fetch domain keyterms when the provider can use them.
-      const keyterms = provider.capabilities.keyterms
-        ? getKeyterms(false).keyterms
-        : [];
-      const session = await provider.createSession({ keyterms });
-      const body: VoiceSessionResponse = {
-        providerId: provider.id,
-        url: session.url,
-        ...(session.token !== undefined ? { token: session.token } : {}),
-        ...(session.params !== undefined ? { params: session.params } : {}),
-        expiresAt: session.expiresAt,
-        capabilities: provider.capabilities,
-      };
-      return c.json(body);
-    } catch (err) {
-      return c.json(
-        { error: err instanceof Error ? err.message : "Voice session failed" },
-        500
-      );
-    }
-  })
+export interface VoiceRoutesDeps {
+  voice: VoiceConfig;
+  keyterms: KeytermSettings;
+}
 
-  // Deprecated alias, kept for client transition. Returns the old token shape
-  // by minting a Deepgram token directly; new clients use /voice/session.
-  .post("/voice/token", async (c) => {
-    try {
-      const { token, expiresAt } = await mintDeepgramToken(60);
-      const body: VoiceTokenResponse = { token, expiresAt };
-      return c.json(body);
-    } catch (err) {
-      return c.json(
-        { error: err instanceof Error ? err.message : "Token mint failed" },
-        500
-      );
-    }
-  })
+export function createVoiceRoutes(deps: VoiceRoutesDeps): Hono {
+  const { voice, keyterms } = deps;
 
-  .get("/voice/keyterms", async (c) => {
-    const force = c.req.query("rebuild") === "1";
-    try {
-      const cache = getKeyterms(force);
-      const body: VoiceKeytermsResponse = {
-        keyterms: cache.keyterms,
-        generatedAt: cache.generatedAt,
-        count: cache.count,
-      };
-      return c.json(body);
-    } catch (err) {
-      return c.json(
-        { error: err instanceof Error ? err.message : "Keyterms failed" },
-        500
-      );
-    }
-  })
+  return new Hono()
+    .post("/voice/session", async (c) => {
+      try {
+        const provider = pickSpeechProvider(voice);
+        // Only fetch domain keyterms when the provider can use them.
+        const terms = provider.capabilities.keyterms
+          ? getKeyterms(keyterms, false).keyterms
+          : [];
+        const session = await provider.createSession({ keyterms: terms });
+        const body: VoiceSessionResponse = {
+          providerId: provider.id,
+          url: session.url,
+          ...(session.token !== undefined ? { token: session.token } : {}),
+          ...(session.params !== undefined ? { params: session.params } : {}),
+          expiresAt: session.expiresAt,
+          capabilities: provider.capabilities,
+        };
+        return c.json(body);
+      } catch (err) {
+        return c.json(
+          { error: err instanceof Error ? err.message : "Voice session failed" },
+          500
+        );
+      }
+    })
 
-  .get("/voice/overrides", async (c) => {
-    try {
-      const cache = getKeyterms(false);
-      return c.json({ overrides: cache.overrides });
-    } catch (err) {
-      return c.json(
-        { error: err instanceof Error ? err.message : "Overrides failed" },
-        500
-      );
-    }
-  });
+    // Deprecated alias, kept for client transition. Returns the old token shape
+    // by minting a Deepgram token directly; new clients use /voice/session.
+    .post("/voice/token", async (c) => {
+      try {
+        const { token, expiresAt } = await mintDeepgramToken(voice.deepgramApiKey, 60);
+        const body: VoiceTokenResponse = { token, expiresAt };
+        return c.json(body);
+      } catch (err) {
+        return c.json(
+          { error: err instanceof Error ? err.message : "Token mint failed" },
+          500
+        );
+      }
+    })
+
+    .get("/voice/keyterms", async (c) => {
+      const force = c.req.query("rebuild") === "1";
+      try {
+        const cache = getKeyterms(keyterms, force);
+        const body: VoiceKeytermsResponse = {
+          keyterms: cache.keyterms,
+          generatedAt: cache.generatedAt,
+          count: cache.count,
+        };
+        return c.json(body);
+      } catch (err) {
+        return c.json(
+          { error: err instanceof Error ? err.message : "Keyterms failed" },
+          500
+        );
+      }
+    })
+
+    .get("/voice/overrides", async (c) => {
+      try {
+        const cache = getKeyterms(keyterms, false);
+        return c.json({ overrides: cache.overrides });
+      } catch (err) {
+        return c.json(
+          { error: err instanceof Error ? err.message : "Overrides failed" },
+          500
+        );
+      }
+    });
+}

package/src/share/staging.ts

@@ -12,7 +12,6 @@ import {
   type ShareIntakeResult,
   type ShareStagingManifest,
 } from "@schlessera/brain-ui-sdk/protocol";
-import { getBrainRoot } from "../files/walker.js";
 
 /**
  * Staging for an incoming system share.
@@ -123,9 +122,9 @@ export interface ShareInput {
   files: File[];
 }
 
-/** Absolute staging root. Read per call, so a test can move BRAIN_PATH. */
-export function shareStagingRoot(): string {
-  return join(getBrainRoot(), SHARE_STAGING_DIR);
+/** Absolute staging root inside the given brain repo. */
+export function shareStagingRoot(brainPath: string): string {
+  return join(brainPath, SHARE_STAGING_DIR);
 }
 
 /**
@@ -270,7 +269,10 @@ async function countStaged(root: string): Promise<number> {
  * observe a share that is missing files or a manifest — not even if the process
  * is killed mid-write, which `try/catch` cleanup cannot cover.
  */
-export async function stageShare(input: ShareInput): Promise<ShareIntakeResult> {
+export async function stageShare(
+  brainPath: string,
+  input: ShareInput
+): Promise<ShareIntakeResult> {
   const title = cleanTextField(input.title);
   const rawUrl = cleanTextField(input.url);
   const { url, leftover } = splitUrl(rawUrl);
@@ -297,7 +299,7 @@ export async function stageShare(input: ShareInput): Promise<ShareIntakeResult>
     throw new ShareTooLargeError("share_too_large", SHARE_MAX_TOTAL_BYTES);
   }
 
-  const root = shareStagingRoot();
+  const root = shareStagingRoot(brainPath);
   if ((await countStaged(root)) >= SHARE_MAX_STAGED) {
     throw new ShareTooLargeError("inbox_full", SHARE_MAX_STAGED);
   }
@@ -392,8 +394,8 @@ export async function stageShare(input: ShareInput): Promise<ShareIntakeResult>
  * deployment can sweep at boot too — scheduling belongs to the container
  * crontab, and this sweep is cheap and bounded.
  */
-export async function pruneShareStaging(now = Date.now()): Promise<number> {
-  const root = shareStagingRoot();
+export async function pruneShareStaging(brainPath: string, now = Date.now()): Promise<number> {
+  const root = shareStagingRoot(brainPath);
   let entries;
   try {
     entries = await readdir(root, { withFileTypes: true });

package/src/voice/deepgram-token.ts

@@ -32,11 +32,13 @@ function requestGrant(apiKey: string, ttlSeconds: number): Promise<Response> {
   });
 }
 
-export async function mintDeepgramToken(ttlSeconds = 60): Promise<{
+export async function mintDeepgramToken(
+  apiKey: string | null,
+  ttlSeconds = 60
+): Promise<{
   token: string;
   expiresAt: number;
 }> {
-  const apiKey = process.env.DEEPGRAM_API_KEY;
   if (!apiKey) {
     throw new Error("DEEPGRAM_API_KEY is not set");
   }