total-recall-brain 3.21.2 → 3.22.0

package/frontend/dist/index.html

@@ -17,8 +17,8 @@
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link href="https://fonts.googleapis.com/css2?family=Inter:wght@300;400;500;600;700&family=JetBrains+Mono:wght@400;500&display=swap" rel="stylesheet" />
     <title>Total Recall — Portable Memory</title>
-    <script type="module" crossorigin src="/assets/index-D0XeeXhG.js"></script>
-    <link rel="stylesheet" crossorigin href="/assets/index-B4RASWbV.css">
+    <script type="module" crossorigin src="/assets/index-DJjuZ3t3.js"></script>
+    <link rel="stylesheet" crossorigin href="/assets/index-C7_Xpk27.css">
   </head>
   <body>
     <div id="root"></div>

package/frontend/src/App.spec.tsx

@@ -19,7 +19,7 @@ vi.mock('./utils/onboarding', () => ({
 
 // Mock the components since App contains a lot of them and we just want to test routing/auth logic
 vi.mock('./pages/LoginPage', () => ({
-  default: ({ onAuthenticated }: any) => <div data-testid="login-page"><button onClick={onAuthenticated}>Login</button></div>
+  default: ({ onAuthenticated }: { onAuthenticated: () => void }) => <div data-testid="login-page"><button onClick={onAuthenticated}>Login</button></div>
 }));
 vi.mock('./pages/ChatPage', () => ({ default: () => <div data-testid="chat-page" /> }));
 vi.mock('./pages/MemoryPage', () => ({ default: () => <div data-testid="memory-page" /> }));

package/frontend/src/api/_base.ts

@@ -34,13 +34,13 @@ export async function apiFetch(url: string, options: RequestInit = {}): Promise<
   return res
 }
 
-export async function get<T = any>(path: string): Promise<T> {
+export async function get<T = unknown>(path: string): Promise<T> {
   const res = await apiFetch(API_BASE + path);
   if (!res.ok) throw new Error(`GET ${path} failed: ${res.status}`);
   return res.json();
 }
 
-export async function post<T = any>(path: string, body: any): Promise<T> {
+export async function post<T = unknown>(path: string, body: unknown): Promise<T> {
   const res = await apiFetch(API_BASE + path, {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
@@ -50,7 +50,7 @@ export async function post<T = any>(path: string, body: any): Promise<T> {
   return res.json();
 }
 
-export async function del<T = any>(path: string): Promise<T> {
+export async function del<T = unknown>(path: string): Promise<T> {
   const res = await apiFetch(API_BASE + path, {
     method: 'DELETE'
   });

package/frontend/src/api/embeddings.ts

@@ -0,0 +1,46 @@
+import { get, post } from './_base'
+
+/** One model on the Ollama host, annotated with why it can or cannot be used. */
+export interface EmbeddingCandidate {
+  name: string
+  size: number | null
+  family: string | null
+  capabilities: string[]
+  /** Whether the model declares the embedding capability at all. */
+  embedding: boolean
+  /** Vector width the model produces, or null when it is not an embedding model. */
+  dims: number | null
+  /** True only when it embeds AND its width matches the vault index. */
+  compatible: boolean
+}
+
+export interface LocalEmbeddingProvider {
+  available: boolean
+  endpoint: string | null
+  selected: string | null
+  preferred: string | null
+  dims: number
+  candidates: EmbeddingCandidate[]
+  reason: string | null
+}
+
+export interface EmbeddingProviderStatus {
+  dims: number
+  local: LocalEmbeddingProvider
+  fallbacks: { provider: string; configured: boolean }[]
+}
+
+export async function fetchEmbeddingProvider(): Promise<EmbeddingProviderStatus> {
+  return get<EmbeddingProviderStatus>('/api/embeddings/provider')
+}
+
+/** Pin a model, or pass null to return to automatic selection. */
+export async function setEmbeddingModel(
+  model: string | null,
+): Promise<{ ok: boolean; pinned: string | null; selected: string | null }> {
+  return post('/api/embeddings/model', { model })
+}
+
+export async function rediscoverEmbeddingProvider(): Promise<{ ok: boolean; local: LocalEmbeddingProvider }> {
+  return post('/api/embeddings/rediscover', {})
+}

package/frontend/src/api/mesh.ts

@@ -159,6 +159,53 @@ export async function fetchDeviceIo(): Promise<{
   return get('/api/mesh/io');
 }
 
+export type EnrollmentState =
+  | 'enrolled'
+  | 'needs_login'
+  | 'stopped'
+  | 'client_unavailable'
+  | 'unknown';
+
+export interface EnrollmentStatus {
+  state: EnrollmentState;
+  enrolled: boolean;
+  backend_state: string | null;
+  auth_url: string | null;
+  ips: string[];
+  hostname: string;
+  login_server: string | null;
+  can_auto_enroll: boolean;
+  auto_enroll_blocked_reason: string | null;
+  auto_enroll_enabled: boolean;
+  client_available: boolean;
+  checked_at: string;
+}
+
+export interface EnrollResult {
+  ok: boolean;
+  changed: boolean;
+  state: EnrollmentState;
+  status: EnrollmentStatus;
+  method?: 'preauth-key' | 'interactive' | 'resume';
+  auth_url?: string | null;
+  reason?: string | null;
+  hint?: string;
+}
+
+/** Enrollment state of this node on the mesh control server. */
+export async function fetchEnrollmentStatus(): Promise<EnrollmentStatus> {
+  return get('/api/mesh/enrollment');
+}
+
+/** Enroll this node now (mints a pre-auth key when one can be minted). */
+export async function enrollThisNode(opts?: {
+  login_server?: string;
+  user?: string;
+  force?: boolean;
+}): Promise<EnrollResult> {
+  return post('/api/mesh/enroll', opts || {});
+}
+
 /** Discover LAN TR peers and upsert mesh_node entities (config:write). */
 export async function registerLanMeshNodes(opts?: { probe?: boolean; limit?: number }): Promise<{
   success: boolean;

package/frontend/src/api/network.spec.ts

@@ -3,14 +3,14 @@ import { networkApi } from './network';
 
 describe('networkApi', () => {
   beforeEach(() => {
-    globalThis.fetch = vi.fn() as any;
+    globalThis.fetch = vi.fn() as unknown as typeof fetch;
   });
 
   it('getStats fetches from /api/network/stats', async () => {
-    (globalThis.fetch as any).mockResolvedValue({
+    vi.mocked(globalThis.fetch).mockResolvedValue({
       ok: true,
       json: () => Promise.resolve({ stats: { total: 10 }, audit_count: 5 })
-    });
+    } as unknown as Response);
 
     const result = await networkApi.getStats();
     expect(globalThis.fetch).toHaveBeenCalledWith('/api/network/stats', expect.any(Object));
@@ -18,10 +18,10 @@ describe('networkApi', () => {
   });
 
   it('getPolicy fetches from /api/network/policy', async () => {
-    (globalThis.fetch as any).mockResolvedValue({
+    vi.mocked(globalThis.fetch).mockResolvedValue({
       ok: true,
       json: () => Promise.resolve({ id: 'network-policy', blocked_domains: [] })
-    });
+    } as unknown as Response);
 
     const result = await networkApi.getPolicy();
     expect(globalThis.fetch).toHaveBeenCalledWith('/api/network/policy', expect.any(Object));
@@ -29,10 +29,10 @@ describe('networkApi', () => {
   });
 
   it('blockDomain POSTs to /api/network/block', async () => {
-    (globalThis.fetch as any).mockResolvedValue({
+    vi.mocked(globalThis.fetch).mockResolvedValue({
       ok: true,
       json: () => Promise.resolve({ success: true })
-    });
+    } as unknown as Response);
 
     await networkApi.blockDomain('evil.com');
     expect(globalThis.fetch).toHaveBeenCalledWith('/api/network/block', expect.objectContaining({
@@ -42,10 +42,10 @@ describe('networkApi', () => {
   });
 
   it('unblockDomain DELETEs to /api/network/block/:domain', async () => {
-    (globalThis.fetch as any).mockResolvedValue({
+    vi.mocked(globalThis.fetch).mockResolvedValue({
       ok: true,
       json: () => Promise.resolve({ success: true })
-    });
+    } as unknown as Response);
 
     await networkApi.unblockDomain('evil.com');
     expect(globalThis.fetch).toHaveBeenCalledWith('/api/network/block/evil.com', expect.objectContaining({

package/frontend/src/api/network.ts

@@ -51,7 +51,7 @@ export async function getNetworkPolicy(): Promise<NetworkPolicy> {
   return get('/api/network/policy');
 }
 
-export async function updateNetworkPolicy(patch: Partial<NetworkPolicy>): Promise<any> {
+export async function updateNetworkPolicy(patch: Partial<NetworkPolicy>): Promise<unknown> {
   const res = await apiFetch(API_BASE + '/api/network/policy', {
     method: 'PUT',
     headers: { 'Content-Type': 'application/json' },
@@ -61,16 +61,16 @@ export async function updateNetworkPolicy(patch: Partial<NetworkPolicy>): Promis
   return res.json();
 }
 
-export async function blockDomain(domain: string): Promise<any> {
+export async function blockDomain(domain: string): Promise<unknown> {
   return post('/api/network/block', { domain });
 }
 
-export async function unblockDomain(domain: string): Promise<any> {
+export async function unblockDomain(domain: string): Promise<unknown> {
   return del(`/api/network/block/${encodeURIComponent(domain)}`);
 }
 
 export async function getAuditLog(params?: { domain?: string; status?: string; since?: string }): Promise<{ audit: AuditLogEntry[] }> {
-  const query = params ? '?' + new URLSearchParams(params as any).toString() : '';
+  const query = params ? '?' + new URLSearchParams(params as Record<string, string>).toString() : '';
   return get(`/api/network/audit${query}`);
 }
 

package/frontend/src/api/notifications.ts

@@ -18,9 +18,9 @@ export interface NotificationEntry {
   timestamp: string;
 }
 
-async function parseJsonOrThrow(res: Response, label: string): Promise<any> {
+async function parseJsonOrThrow(res: Response, label: string): Promise<unknown> {
   const text = await res.text();
-  let data: any = null;
+  let data: unknown = null;
   if (text) {
     try {
       data = JSON.parse(text);
@@ -29,8 +29,9 @@ async function parseJsonOrThrow(res: Response, label: string): Promise<any> {
     }
   }
   if (!res.ok) {
+    const obj = data as Record<string, unknown> | null;
     const msg =
-      (data && (data.error || data.message)) ||
+      (obj && (obj.error || obj.message)) ||
       `${label} failed: ${res.status}`;
     throw new Error(typeof msg === 'string' ? msg : `${label} failed: ${res.status}`);
   }
@@ -62,7 +63,7 @@ export async function createNotificationRule(
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(rule),
   });
-  return parseJsonOrThrow(res, 'POST /api/notifications/rules');
+  return parseJsonOrThrow(res, 'POST /api/notifications/rules') as Promise<NotificationRule>;
 }
 
 export async function deleteNotificationRule(id: string): Promise<void> {

package/frontend/src/api/webhooks.ts

@@ -17,7 +17,7 @@ export interface WebhookEvent {
   provider: string;
   event_type: string;
   received_at: string;
-  payload?: any;
+  payload?: unknown;
   delivery_status?: string;
   parent_event_id?: string;
   delivery_id?: string | null;

package/frontend/src/components/BrainSelector.spec.tsx

@@ -30,7 +30,7 @@ describe('BrainSelector', () => {
           },
         ],
       }),
-    } as any);
+    } as never);
 
     const onBrainChange = vi.fn();
     render(<BrainSelector activeBrainId="global" onBrainChange={onBrainChange} />);
@@ -51,7 +51,7 @@ describe('BrainSelector', () => {
           { id: 'project:demo', name: 'demo', layer: 'project', exists: true, node_count: 5 },
         ],
       }),
-    } as any);
+    } as never);
 
     const onBrainChange = vi.fn();
     render(<BrainSelector activeBrainId="global" onBrainChange={onBrainChange} />);
@@ -71,7 +71,7 @@ describe('BrainSelector', () => {
           { id: 'project:demo', name: 'demo', layer: 'project', exists: true, node_count: 5 },
         ],
       }),
-    } as any);
+    } as never);
 
     const onBrainChange = vi.fn();
     render(<BrainSelector activeBrainId="global" onBrainChange={onBrainChange} />);
@@ -87,7 +87,7 @@ describe('BrainSelector', () => {
       ok: false,
       status: 401,
       json: async () => ({ error: 'Authentication required' }),
-    } as any);
+    } as never);
 
     render(<BrainSelector activeBrainId="global" onBrainChange={vi.fn()} />);
     await waitFor(() => {

package/frontend/src/components/BrainSelector.tsx

@@ -60,7 +60,7 @@ export default function BrainSelector({ activeBrainId, onBrainChange }: BrainSel
   }
 
   useEffect(() => {
-    void loadBrains()
+    setTimeout(() => { void loadBrains() }, 0)
   }, [])
 
   useEffect(() => {

package/frontend/src/components/ContextualHelp.spec.tsx

@@ -1,5 +1,4 @@
-// @ts-nocheck
-import { describe, it, expect, vi } from 'vitest';
+import { describe, it, expect } from 'vitest';
 import { render, screen, fireEvent } from '@testing-library/react';
 import { MemoryRouter } from 'react-router-dom';
 import ContextualHelp from './ContextualHelp';
@@ -20,42 +19,43 @@ describe('ContextualHelp', () => {
     expect(btn).toHaveTextContent('?');
   });
 
-  it('opens overlay when help button is clicked', () => {
+  it('opens overlay when help button is clicked', async () => {
     renderWithRouter('/');
     fireEvent.click(screen.getByTitle('Page Help'));
-    expect(screen.getByText(/Chat Interface/)).toBeInTheDocument();
+    expect(await screen.findByText(/Chat Interface/)).toBeInTheDocument();
   });
 
-  it('shows memory vault help for /memory route', () => {
+  it('shows memory vault help for /memory route', async () => {
     renderWithRouter('/memory');
     fireEvent.click(screen.getByTitle('Page Help'));
-    expect(screen.getByText(/Memory Vault/)).toBeInTheDocument();
+    expect(await screen.findByText(/Memory Vault/)).toBeInTheDocument();
   });
 
-  it('shows graph help for /graph route', () => {
+  it('shows graph help for /graph route', async () => {
     renderWithRouter('/graph');
     fireEvent.click(screen.getByTitle('Page Help'));
-    expect(screen.getByText(/Concept Graph/)).toBeInTheDocument();
+    expect(await screen.findByText(/Concept Graph/)).toBeInTheDocument();
   });
 
-  it('shows fallback for unknown routes', () => {
+  it('shows fallback for unknown routes', async () => {
     renderWithRouter('/unknown-route');
     fireEvent.click(screen.getByTitle('Page Help'));
-    expect(screen.getByText(/No specific documentation/)).toBeInTheDocument();
+    expect(await screen.findByText(/No specific documentation/)).toBeInTheDocument();
   });
 
-  it('closes overlay when close button is clicked', () => {
+  it('closes overlay when close button is clicked', async () => {
     renderWithRouter('/');
     fireEvent.click(screen.getByTitle('Page Help'));
-    expect(screen.getByText(/Chat Interface/)).toBeInTheDocument();
+    expect(await screen.findByText(/Chat Interface/)).toBeInTheDocument();
     fireEvent.click(screen.getByText('✕'));
     expect(screen.queryByText(/Chat Interface/)).not.toBeInTheDocument();
   });
 
-  it('closes overlay when backdrop is clicked', () => {
+  it('closes overlay when backdrop is clicked', async () => {
     renderWithRouter('/');
     fireEvent.click(screen.getByTitle('Page Help'));
-    const overlay = screen.getByText(/Chat Interface/).parentElement?.parentElement;
+    const text = await screen.findByText(/Chat Interface/);
+    const overlay = text.parentElement?.parentElement;
     if (overlay) fireEvent.click(overlay);
     expect(screen.queryByText(/Chat Interface/)).not.toBeInTheDocument();
   });

package/frontend/src/components/ContextualHelp.tsx

@@ -23,7 +23,9 @@ export default function ContextualHelp() {
   useEffect(() => {
     // Determine content based on current path
     const path = location.pathname;
-    setContent(helpContent[path] || `### ${path}\nNo specific documentation is available for this route yet.`);
+    setTimeout(() => {
+      setContent(helpContent[path] || `### ${path}\nNo specific documentation is available for this route yet.`);
+    }, 0);
   }, [location.pathname]);
 
   return (

package/frontend/src/components/DocumentTable.spec.tsx

@@ -28,7 +28,7 @@ describe('DocumentTable', () => {
   it('renders custom column render correctly', () => {
     const customCols = [
       ...columns,
-      { key: 'action', header: 'Action', render: (row: any) => <button>Edit {row.name}</button> }
+      { key: 'action', header: 'Action', render: (row: { name: string }) => <button>Edit {row.name}</button> }
     ];
     const data = [{ id: 1, name: 'Doc 1', status: 'Active' }];
 

package/frontend/src/components/EmbeddingProviderPanel.spec.tsx

@@ -0,0 +1,127 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import { render, screen, waitFor } from '@testing-library/react'
+import userEvent from '@testing-library/user-event'
+
+import { EmbeddingProviderPanel } from './EmbeddingProviderPanel'
+import * as api from '../api/embeddings'
+import type { EmbeddingProviderStatus } from '../api/embeddings'
+
+vi.mock('../api/embeddings')
+
+// Annotated against the real contract: without it TS narrows `endpoint` to
+// string and `reason` to null from the literal, so the "nothing reachable"
+// case below cannot be expressed.
+const LOCAL_OK: EmbeddingProviderStatus = {
+  dims: 768,
+  local: {
+    available: true,
+    endpoint: 'http://100.64.0.2:11434',
+    selected: 'nomic-embed-text:latest',
+    preferred: null,
+    dims: 768,
+    candidates: [
+      {
+        name: 'nomic-embed-text:latest',
+        size: 274_000_000,
+        family: 'nomic-bert',
+        capabilities: ['embedding'],
+        embedding: true,
+        dims: 768,
+        compatible: true,
+      },
+      {
+        name: 'gemma4:latest',
+        size: 9_608_000_000,
+        family: 'gemma4',
+        capabilities: ['completion'],
+        embedding: false,
+        dims: 2560,
+        compatible: false,
+      },
+    ],
+    reason: null,
+  },
+  fallbacks: [
+    { provider: 'openrouter', configured: true },
+    { provider: 'google', configured: false },
+    { provider: 'openai', configured: false },
+  ],
+}
+
+beforeEach(() => {
+  vi.mocked(api.fetchEmbeddingProvider).mockResolvedValue(structuredClone(LOCAL_OK))
+  vi.mocked(api.setEmbeddingModel).mockResolvedValue({ ok: true, pinned: null, selected: null })
+  vi.mocked(api.rediscoverEmbeddingProvider).mockResolvedValue({ ok: true, local: LOCAL_OK.local })
+})
+
+describe('EmbeddingProviderPanel', () => {
+  it('shows the resolved endpoint and selected model', async () => {
+    render(<EmbeddingProviderPanel />)
+    expect(await screen.findByTestId('embed-endpoint')).toHaveTextContent('http://100.64.0.2:11434')
+    expect(screen.getByTestId('embed-selected')).toHaveTextContent('nomic-embed-text:latest')
+    expect(screen.getByTestId('embed-selected')).toHaveTextContent('auto')
+  })
+
+  it('lists incompatible models with the reason instead of hiding them', async () => {
+    render(<EmbeddingProviderPanel />)
+    // An operator who pulled a chat model needs to see why it is unusable.
+    expect(await screen.findByText('gemma4:latest')).toBeInTheDocument()
+    expect(screen.getByText(/cannot embed/i)).toBeInTheDocument()
+  })
+
+  it('offers no "Use" button for a model that cannot embed', async () => {
+    render(<EmbeddingProviderPanel />)
+    await screen.findByText('gemma4:latest')
+    // Only compatible, non-selected models are pinnable; here that set is empty.
+    expect(screen.queryByRole('button', { name: /^use$/i })).not.toBeInTheDocument()
+  })
+
+  it('pins a model when the operator picks one', async () => {
+    const withOther = structuredClone(LOCAL_OK)
+    withOther.local.candidates.push({
+      name: 'other-embed:latest',
+      size: 100_000_000,
+      family: 'other',
+      capabilities: ['embedding'],
+      embedding: true,
+      dims: 768,
+      compatible: true,
+    })
+    vi.mocked(api.fetchEmbeddingProvider).mockResolvedValue(withOther)
+
+    render(<EmbeddingProviderPanel />)
+    const useBtn = await screen.findByRole('button', { name: /^use$/i })
+    await userEvent.click(useBtn)
+
+    await waitFor(() => expect(api.setEmbeddingModel).toHaveBeenCalledWith('other-embed:latest'))
+  })
+
+  it('reports the hosted fallback state when nothing local answers', async () => {
+    const down = structuredClone(LOCAL_OK)
+    down.local = {
+      ...down.local,
+      available: false,
+      endpoint: null,
+      selected: null,
+      candidates: [],
+      reason: 'No Ollama endpoint answered on this host or any online mesh peer.',
+    }
+    vi.mocked(api.fetchEmbeddingProvider).mockResolvedValue(down)
+
+    render(<EmbeddingProviderPanel />)
+    expect(await screen.findByTestId('embed-availability')).toHaveTextContent('hosted fallback')
+    expect(screen.getByRole('status')).toHaveTextContent(/No Ollama endpoint answered/)
+  })
+
+  it('surfaces a load failure rather than rendering an empty panel', async () => {
+    vi.mocked(api.fetchEmbeddingProvider).mockRejectedValue(new Error('Authentication required'))
+    render(<EmbeddingProviderPanel />)
+    expect(await screen.findByRole('alert')).toHaveTextContent('Authentication required')
+  })
+
+  it('re-discovers on demand', async () => {
+    render(<EmbeddingProviderPanel />)
+    await userEvent.click(await screen.findByRole('button', { name: /re-discover/i }))
+    await waitFor(() => expect(api.rediscoverEmbeddingProvider).toHaveBeenCalled())
+  })
+})