@schlessera/brain-ui-react 0.34.1 → 0.35.0

package/src/lib/api-client.ts

@@ -81,6 +81,26 @@ export interface BackendInfo {
   };
 }
 
+/** One active browser/device or delegated agent credential. */
+export interface PrincipalSummary {
+  id: string;
+  kind: "owner" | "agent" | "ambient" | "system";
+  auth_method: "password" | "passkey" | "delegated" | "ambient";
+  label: string;
+  created_at: number;
+  expires_at: number;
+  last_seen_at: number | null;
+  is_own: boolean;
+}
+
+/** The response to minting an agent. `cookie` is intentionally returned once. */
+export interface MintedAgent {
+  id: string;
+  label: string;
+  expiresAt: number;
+  cookie: string;
+}
+
 /** Auth status of one configured pi provider (mirror of the server view). */
 export interface PiAuthProviderStatus {
   providerId: string;
@@ -242,13 +262,18 @@ export const api = {
     }),
 
   brainAdd: (content: string, opts?: { type?: string; title?: string; tags?: string[] }) =>
-    fetchJson<{ success: boolean }>("/brain/add", {
+    fetchJson<{ success: boolean; path?: string; indexed?: boolean; indexError?: string }>("/brain/add", {
       method: "POST",
       body: JSON.stringify({ content, ...opts }),
     }),
 
+  brainIndex: () => fetchJson<{ success: boolean }>("/brain/index", {
+    method: "POST", body: "{}",
+  }),
+
   sessions: () =>
     fetchJson<{
+      unavailableBackends?: string[];
       sessions: Array<{
         id: string;
         title: string | null;
@@ -448,6 +473,20 @@ export const api = {
   logout: () =>
     fetchJson<{ ok: true }>("/auth/logout", { method: "POST" }),
 
+  principals: () =>
+    fetchJson<{ principals: PrincipalSummary[] }>("/auth/principals"),
+
+  principalMint: (label: string, ttlDays: number) =>
+    fetchJson<MintedAgent>("/auth/principals", {
+      method: "POST",
+      body: JSON.stringify({ label, ttlDays }),
+    }),
+
+  principalRevoke: (id: string) =>
+    fetchJson<{ ok: true }>(`/auth/principals/${encodeURIComponent(id)}`, {
+      method: "DELETE",
+    }),
+
   /** Which login methods the server offers (public; drives the login screen). */
   authMethods: () =>
     fetchJson<{ password: boolean; passkey: boolean }>("/auth/methods"),

package/src/lib/format-time.ts

@@ -0,0 +1,20 @@
+/** Relative timestamp for list rows ("3m ago"); dates beyond a week. */
+export function formatRelativeTime(ms: number): string {
+  const diff = Date.now() - ms;
+  const future = diff < 0;
+  const distance = Math.abs(diff);
+  if (distance < 60_000) return future ? "in less than a minute" : "just now";
+  const minutes = future
+    ? Math.ceil(distance / 60_000)
+    : Math.floor(distance / 60_000);
+  if (minutes < 60) return future ? `in ${minutes}m` : `${minutes}m ago`;
+  const hours = future
+    ? Math.ceil(distance / 3_600_000)
+    : Math.floor(distance / 3_600_000);
+  if (hours < 24) return future ? `in ${hours}h` : `${hours}h ago`;
+  const days = future
+    ? Math.ceil(distance / 86_400_000)
+    : Math.floor(distance / 86_400_000);
+  if (days < 7) return future ? `in ${days}d` : `${days}d ago`;
+  return new Date(ms).toLocaleDateString();
+}

package/src/lib/push-registration.ts

@@ -0,0 +1,29 @@
+import { api } from "./api-client.js";
+
+/**
+ * Re-assert an existing browser subscription after authentication changes.
+ * This does not request permission or create a subscription: it only binds an
+ * already-enabled endpoint to the newly issued server principal.
+ */
+export async function rebindPushSubscriptionAfterLogin(): Promise<void> {
+  if (
+    typeof Notification === "undefined" ||
+    Notification.permission !== "granted" ||
+    typeof navigator === "undefined" ||
+    !("serviceWorker" in navigator)
+  ) {
+    return;
+  }
+
+  // Capture before awaiting: the page may begin navigating immediately after
+  // login while the service-worker readiness promise settles.
+  const serviceWorker = navigator.serviceWorker;
+  const label =
+    typeof navigator.userAgent === "string"
+      ? navigator.userAgent.slice(0, 100)
+      : undefined;
+  const registration = await serviceWorker.ready;
+  const subscription = await registration.pushManager.getSubscription();
+  if (!subscription) return;
+  await api.pushSubscribe(subscription.toJSON(), label);
+}

package/src/stores/file-store.ts

@@ -86,8 +86,8 @@ async function fetchTree(path: string): Promise<FileEntry[]> {
   return data.entries;
 }
 
-async function fetchContent(path: string): Promise<FileContentResponse> {
-  const res = await fetch(`${apiBase()}/files/content?path=${encodeURIComponent(path)}`);
+async function fetchContent(path: string, signal: AbortSignal): Promise<FileContentResponse> {
+  const res = await fetch(`${apiBase()}/files/content?path=${encodeURIComponent(path)}`, { signal });
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: res.statusText }));
     const err = new Error(body.error || `HTTP ${res.status}`);
@@ -98,8 +98,8 @@ async function fetchContent(path: string): Promise<FileContentResponse> {
   return res.json();
 }
 
-async function fetchResolve(path: string): Promise<FileResolveResponse> {
-  const res = await fetch(`${apiBase()}/files/resolve?path=${encodeURIComponent(path)}`);
+async function fetchResolve(path: string, signal: AbortSignal): Promise<FileResolveResponse> {
+  const res = await fetch(`${apiBase()}/files/resolve?path=${encodeURIComponent(path)}`, { signal });
   if (!res.ok) {
     const body = await res.json().catch(() => ({ error: res.statusText }));
     throw new Error(body.error || `HTTP ${res.status}`);
@@ -116,6 +116,10 @@ async function fetchWikilinks(): Promise<WikilinkMapResponse> {
   return res.json();
 }
 
+let fileRequest: AbortController | null = null;
+let directoryRequest: AbortController | null = null;
+let cacheEpoch = 0;
+
 export const useFileStore = create<FileState>((set, get) => ({
   dirCache: {},
   loadingDirs: new Set(),
@@ -135,6 +139,7 @@ export const useFileStore = create<FileState>((set, get) => ({
   wikilinkLoading: false,
 
   loadDir: async (path) => {
+    const epoch = cacheEpoch;
     const { dirCache, loadingDirs } = get();
     if (dirCache[path] || loadingDirs.has(path)) return;
     const next = new Set(loadingDirs);
@@ -142,6 +147,7 @@ export const useFileStore = create<FileState>((set, get) => ({
     set({ loadingDirs: next });
     try {
       const entries = await fetchTree(path);
+      if (epoch !== cacheEpoch) return;
       set((s) => {
         const loading = new Set(s.loadingDirs);
         loading.delete(path);
@@ -154,6 +160,7 @@ export const useFileStore = create<FileState>((set, get) => ({
         };
       });
     } catch (err) {
+      if (epoch !== cacheEpoch) return;
       set((s) => {
         const loading = new Set(s.loadingDirs);
         loading.delete(path);
@@ -189,13 +196,19 @@ export const useFileStore = create<FileState>((set, get) => ({
   },
 
   openFile: async (path) => {
+    fileRequest?.abort();
+    directoryRequest?.abort();
+    const request = new AbortController();
+    fileRequest = request;
+    const ownsRequest = () => fileRequest === request && !request.signal.aborted;
     const normalized = path.replace(/^\/+/, "").replace(/\\/g, "/");
     set({ currentPath: normalized, contentLoading: true, contentError: null, currentContent: null, treeExpanded: false });
 
     // Fire-and-await: load ancestor chain then content in parallel
     const ancestorsPromise = (async () => {
       try {
-        const r = await fetchResolve(normalized);
+        const r = await fetchResolve(normalized, request.signal);
+        if (!ownsRequest()) return;
         // Expand each ancestor and root, load their contents
         const dirsToLoad = ["", ...r.ancestors];
         set((s) => {
@@ -210,12 +223,12 @@ export const useFileStore = create<FileState>((set, get) => ({
     })();
 
     try {
-      const content = await fetchContent(normalized);
+      const content = await fetchContent(normalized, request.signal);
       // Drop a response the user has already navigated away from. Two rapid
       // clicks race, and without this the SLOWER fetch wins: the viewer showed
       // the newer file's path with the older file's content, which reads as
       // corruption rather than as a stale load.
-      if (get().currentPath !== normalized) return;
+      if (!ownsRequest()) return;
       set({ currentContent: content, contentLoading: false });
       // Default mode: prefer preview when available; persist otherwise
       const { viewMode } = get();
@@ -233,7 +246,7 @@ export const useFileStore = create<FileState>((set, get) => ({
       else if (e.message === "invalid_path") msg = "Invalid path.";
       // Same guard: a failure for a file the user already left must not
       // replace the file they are now looking at with an error.
-      if (get().currentPath !== normalized) return;
+      if (!ownsRequest()) return;
       set({ contentError: msg, contentLoading: false });
     } finally {
       await ancestorsPromise;
@@ -241,10 +254,15 @@ export const useFileStore = create<FileState>((set, get) => ({
   },
 
   closeFile: () => {
-    set({ currentPath: null, currentContent: null, contentError: null, treeExpanded: true });
+    fileRequest?.abort();
+    fileRequest = null;
+    set({ currentPath: null, currentContent: null, contentError: null, contentLoading: false, treeExpanded: true });
   },
 
   openDir: async (path) => {
+    directoryRequest?.abort();
+    const request = new AbortController();
+    directoryRequest = request;
     const normalized = path
       .replace(/^\/+/, "")
       .replace(/\\/g, "/")
@@ -258,7 +276,8 @@ export const useFileStore = create<FileState>((set, get) => ({
     set({ treeExpanded: true, highlightedDir: normalized });
 
     try {
-      const r = await fetchResolve(normalized);
+      const r = await fetchResolve(normalized, request.signal);
+      if (directoryRequest !== request || request.signal.aborted) return;
       const dirs = ["", ...r.ancestors, normalized];
       set((s) => {
         const next = new Set(s.expandedDirs);
@@ -278,11 +297,13 @@ export const useFileStore = create<FileState>((set, get) => ({
   setHighlightedDir: (path) => set({ highlightedDir: path }),
 
   ensureWikilinks: async () => {
+    const epoch = cacheEpoch;
     const { wikilinkLoaded, wikilinkLoading } = get();
     if (wikilinkLoaded || wikilinkLoading) return;
     set({ wikilinkLoading: true });
     try {
       const data = await fetchWikilinks();
+      if (epoch !== cacheEpoch) return;
       set({
         wikilinkMap: data.slugs,
         wikilinkLoaded: true,
@@ -290,6 +311,7 @@ export const useFileStore = create<FileState>((set, get) => ({
       });
     } catch {
       // Soft-fail — leave the map empty; wikilinks will render as plain text
+      if (epoch !== cacheEpoch) return;
       set({ wikilinkLoading: false });
     }
   },
@@ -304,15 +326,23 @@ export const useFileStore = create<FileState>((set, get) => ({
       return { frontmatterCollapsed: next };
     }),
 
-  reset: () =>
+  reset: () => {
+    fileRequest?.abort();
+    directoryRequest?.abort();
+    fileRequest = null;
+    directoryRequest = null;
+    cacheEpoch++;
     set({
+      dirCache: {}, loadingDirs: new Set(), dirErrors: {}, expandedDirs: new Set([""]),
+      highlightedDir: null, wikilinkMap: {}, wikilinkLoaded: false, wikilinkLoading: false,
       currentPath: null,
       currentContent: null,
       contentLoading: false,
       contentError: null,
       viewMode: "preview",
       treeExpanded: true,
-    }),
+    });
+  },
 }));
 
 /**

package/src/stores/principal-store.ts

@@ -0,0 +1,38 @@
+import { create } from "zustand";
+import { api, type MintedAgent } from "../lib/api-client.js";
+
+interface PrincipalState {
+  mintPending: boolean;
+  mintError: string | null;
+  oneTimeCredential: MintedAgent | null;
+  mintAgent: (label: string, ttlDays: number) => Promise<void>;
+  acknowledgeAgentCredential: () => void;
+}
+
+/**
+ * Mint state lives above Settings because the response contains an
+ * unrecoverable, one-time value. Closing a panel or changing views must not
+ * discard either the request in flight or the value it eventually returns.
+ */
+export const usePrincipalStore = create<PrincipalState>((set, get) => ({
+  mintPending: false,
+  mintError: null,
+  oneTimeCredential: null,
+
+  mintAgent: async (label, ttlDays) => {
+    if (get().mintPending || get().oneTimeCredential) return;
+    set({ mintPending: true, mintError: null });
+    try {
+      const oneTimeCredential = await api.principalMint(label, ttlDays);
+      set({ mintPending: false, oneTimeCredential });
+    } catch (error) {
+      set({
+        mintPending: false,
+        mintError:
+          error instanceof Error ? error.message : "Could not create agent access",
+      });
+    }
+  },
+
+  acknowledgeAgentCredential: () => set({ oneTimeCredential: null }),
+}));

package/src/stores/ui-store.ts

@@ -1,7 +1,7 @@
 import { create } from "zustand";
 
 /** Which tab the settings panel opens on. */
-export type SettingsTab = "models" | "skills" | "security";
+export type SettingsTab = "models" | "skills" | "security" | "devices";
 
 /** Full-screen surface currently shown inside the AppShell. */
 export type ActiveView = "chat" | "graph" | "activity";