total-recall-brain 3.18.1 → 3.18.3

package/frontend/dist/index.html

@@ -17,7 +17,7 @@
     <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-D5xRw5uq.js"></script>
+    <script type="module" crossorigin src="/assets/index-CGqvdwHT.js"></script>
     <link rel="stylesheet" crossorigin href="/assets/index-B4RASWbV.css">
   </head>
   <body>

package/frontend/src/api/config.ts

@@ -21,7 +21,14 @@ export async function saveConfig(name: string, content: string): Promise<void> {
 
 export async function fetchConfigJson(): Promise<ConfigJson> {
   const res = await apiFetch(`${API_BASE}/api/config-json`)
-  if (!res.ok) throw new Error(`Config JSON API error: ${res.status}`)
+  if (!res.ok) {
+    let detail = `Config JSON API error: ${res.status}`
+    try {
+      const body = await res.json()
+      if (body?.error) detail = body.error
+    } catch { /* ignore */ }
+    throw new Error(detail)
+  }
   return res.json()
 }
 
@@ -31,5 +38,12 @@ export async function saveConfigJson(config: ConfigJson): Promise<void> {
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify(config),
   })
-  if (!res.ok) throw new Error(`Config JSON API error: ${res.status}`)
+  if (!res.ok) {
+    let detail = `Config JSON API error: ${res.status}`
+    try {
+      const body = await res.json()
+      if (body?.error) detail = body.error
+    } catch { /* ignore */ }
+    throw new Error(detail)
+  }
 }

package/frontend/src/api/keys.ts

@@ -146,6 +146,27 @@ export interface SecretCatalogKey {
   headscale_url?: string | null
   usage_30d: { events: number; cost_usd: number; input_tokens: number; output_tokens: number }
   tiers: { id: string; label: string; monthly_usd?: number | null }[]
+  /** Live provider account/usage tracking */
+  tracking_status?: 'ok' | 'partial' | 'error' | 'exempt' | 'never' | string | null
+  tracking_error?: string | null
+  tracking_synced_at?: string | null
+  tracking_probe?: string | null
+  tracking_account?: unknown
+  tracking_usage?: unknown
+  tracking_subscription?: unknown
+  tracking_exempt?: boolean
+  account_api?: boolean | null
+  usage_api?: boolean | null
+  subscription_api?: boolean | null
+  key_valid?: boolean | null
+  /** Same credential value under multiple secret names / apps */
+  shared_value?: boolean
+  shared_with?: { key: string; app: string; repo?: string | null; provider?: string | null }[]
+  shared_apps?: string[]
+  shared_value_error?: string | null
+  shared_value_severity?: 'error' | 'ok' | string | null
+  shared_fingerprint?: string | null
+  shared_value_ok?: boolean
 }
 
 export interface SecretCatalog {
@@ -162,17 +183,107 @@ export interface SecretCatalog {
     usage_30d: { events: number; cost_usd: number }
     rotation_overdue: number
     budget: Record<string, unknown>
+    tracking_healthy?: boolean
+    tracking_ok?: number
+    tracking_exempt?: number
+    tracking_errors?: number
+    tracking_error_keys?: {
+      key: string
+      provider?: string | null
+      tracking_status?: string
+      error?: string
+    }[]
+    shared_value_healthy?: boolean
+    shared_value_keys?: number
+    shared_value_multi_app_keys?: number
+    shared_value_groups?: number
+    shared_value_errors?: {
+      fingerprint?: string
+      apps?: string[]
+      keys?: string[]
+      error?: string | null
+    }[]
   }
   by_provider: { provider: string; keys: number; cost_30d: number; monthly_cost: number }[]
   store: string
 }
 
+export interface SharedValueHealth {
+  healthy: boolean
+  message: string
+  error_groups: number
+  multi_app_groups: number
+  shared_keys: number
+  groups: {
+    fingerprint: string
+    apps: string[]
+    keys: string[]
+    severity: string
+    error?: string | null
+    members?: { key: string; app: string; provider?: string | null; masked?: string | null }[]
+  }[]
+  errors?: { fingerprint: string; apps: string[]; keys: string[]; error?: string | null }[]
+}
+
+export interface TrackingHealth {
+  healthy: boolean
+  message: string
+  ok: number
+  exempt: number
+  errors: number
+  error_keys: {
+    key: string
+    provider?: string | null
+    tracking_status?: string
+    error?: string
+  }[]
+}
+
 export async function fetchSecretsCatalog(): Promise<SecretCatalog> {
   const res = await apiFetch(`${API_BASE}/api/secrets`)
   if (!res.ok) throw new Error(`Secrets catalog error: ${res.status}`)
   return res.json()
 }
 
+/** Same credential value reused across secret names / apps — 409 when unhealthy. */
+export async function fetchSharedValues(): Promise<SharedValueHealth> {
+  const res = await apiFetch(`${API_BASE}/api/secrets/shared-values`)
+  const body = await res.json().catch(() => ({}))
+  if (!res.ok && res.status !== 409) {
+    throw new Error(body.error || `Shared values error: ${res.status}`)
+  }
+  return body as SharedValueHealth
+}
+
+/** Provider account/usage tracking health — 409 when untracked keys remain. */
+export async function fetchTrackingHealth(): Promise<TrackingHealth> {
+  const res = await apiFetch(`${API_BASE}/api/secrets/tracking-health`)
+  const body = await res.json().catch(() => ({}))
+  if (!res.ok && res.status !== 409) {
+    throw new Error(body.error || `Tracking health error: ${res.status}`)
+  }
+  return body as TrackingHealth
+}
+
+/** Live-probe vendor account/usage APIs and persist tracking meta. */
+export async function runAccountSync(opts: {
+  key?: string
+  keys?: string[]
+  strict?: boolean
+  use_ai?: boolean
+} = {}): Promise<Record<string, unknown>> {
+  const res = await apiFetch(`${API_BASE}/api/secrets/account-sync`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(opts),
+  })
+  const body = await res.json().catch(() => ({}))
+  if (!res.ok && res.status !== 409) {
+    throw new Error(body.error || `Account sync failed: ${res.status}`)
+  }
+  return body
+}
+
 export async function updateSecretMeta(key: string, patch: Record<string, unknown>): Promise<SecretCatalogKey> {
   const res = await apiFetch(`${API_BASE}/api/secrets/${encodeURIComponent(key)}`, {
     method: 'PATCH',

package/frontend/src/api/notifications.ts

@@ -1,4 +1,4 @@
-import { get, post, del } from './_base';
+import { apiFetch, getApiBase } from './_base';
 
 export interface NotificationRule {
   id: string;
@@ -18,24 +18,72 @@ export interface NotificationEntry {
   timestamp: string;
 }
 
+async function parseJsonOrThrow(res: Response, label: string): Promise<any> {
+  const text = await res.text();
+  let data: any = null;
+  if (text) {
+    try {
+      data = JSON.parse(text);
+    } catch {
+      data = null;
+    }
+  }
+  if (!res.ok) {
+    const msg =
+      (data && (data.error || data.message)) ||
+      `${label} failed: ${res.status}`;
+    throw new Error(typeof msg === 'string' ? msg : `${label} failed: ${res.status}`);
+  }
+  return data;
+}
+
+function asArray<T>(data: unknown): T[] {
+  if (Array.isArray(data)) return data as T[];
+  if (data && typeof data === 'object') {
+    const obj = data as Record<string, unknown>;
+    if (Array.isArray(obj.rules)) return obj.rules as T[];
+    if (Array.isArray(obj.history)) return obj.history as T[];
+    if (Array.isArray(obj.entries)) return obj.entries as T[];
+  }
+  return [];
+}
+
 export async function listNotificationRules(): Promise<NotificationRule[]> {
-  return get('/api/notifications/rules');
+  const res = await apiFetch(`${getApiBase()}/api/notifications/rules`);
+  const data = await parseJsonOrThrow(res, 'GET /api/notifications/rules');
+  return asArray<NotificationRule>(data);
 }
 
 export async function createNotificationRule(
   rule: Omit<NotificationRule, 'id'>,
 ): Promise<NotificationRule> {
-  return post('/api/notifications/rules', rule);
+  const res = await apiFetch(`${getApiBase()}/api/notifications/rules`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(rule),
+  });
+  return parseJsonOrThrow(res, 'POST /api/notifications/rules');
 }
 
 export async function deleteNotificationRule(id: string): Promise<void> {
-  return del(`/api/notifications/rules/${encodeURIComponent(id)}`);
+  const res = await apiFetch(
+    `${getApiBase()}/api/notifications/rules/${encodeURIComponent(id)}`,
+    { method: 'DELETE' },
+  );
+  await parseJsonOrThrow(res, 'DELETE /api/notifications/rules');
 }
 
 export async function getNotificationHistory(): Promise<NotificationEntry[]> {
-  return get('/api/notifications/history');
+  const res = await apiFetch(`${getApiBase()}/api/notifications/history`);
+  const data = await parseJsonOrThrow(res, 'GET /api/notifications/history');
+  return asArray<NotificationEntry>(data);
 }
 
 export async function sendTestNotification(): Promise<void> {
-  return post('/api/notifications/test', {});
+  const res = await apiFetch(`${getApiBase()}/api/notifications/test`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({}),
+  });
+  await parseJsonOrThrow(res, 'POST /api/notifications/test');
 }

package/frontend/src/api/update.ts

@@ -11,7 +11,18 @@ export interface UpdateCheckResult {
 export async function checkUpdate(): Promise<UpdateCheckResult> {
   const res = await apiFetch(`${API_BASE}/api/update/check`)
   if (!res.ok) throw new Error(`Check update API error: ${res.status}`)
-  return res.json()
+  const data = await res.json()
+  // Normalize snake_case API fields for the Settings UI
+  const currentVersion = data.currentVersion ?? data.current ?? ''
+  const latestVersion = data.latestVersion ?? data.latest ?? ''
+  // Prefer host package comparison; fall back to API flag (includes consumers behind).
+  const hostBehind =
+    Boolean(latestVersion && currentVersion && latestVersion !== currentVersion)
+  return {
+    currentVersion,
+    latestVersion,
+    updateAvailable: hostBehind || Boolean(data.updateAvailable ?? data.update_available),
+  }
 }
 
 export async function runUpdate(): Promise<{ success: boolean; message: string }> {

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

@@ -1,73 +1,97 @@
-// @ts-nocheck
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { render, screen, waitFor, fireEvent } from '@testing-library/react';
 import BrainSelector from './BrainSelector';
-import * as api from '../api';
 
-vi.mock('../api');
+vi.mock('../api', () => ({
+  apiFetch: vi.fn(),
+  getApiBase: vi.fn(() => ''),
+}));
+
+import { apiFetch } from '../api';
 
 describe('BrainSelector', () => {
   beforeEach(() => {
-    vi.resetAllMocks();
-    (global as any).fetch = vi.fn();
-  });
-
-  it('renders loading state initially', () => {
-    vi.mocked(api.getApiBase).mockReturnValue('http://localhost:3000');
-    // Promise that never resolves for testing loading state
-    (global.fetch as any).mockReturnValue(new Promise(() => {}));
-
-    render(<BrainSelector activeBrainId="default" onBrainChange={() => {}} />);
-    expect(screen.getByText(/Brains…/i)).toBeInTheDocument();
+    vi.clearAllMocks();
   });
 
-  it('renders brains after fetch', async () => {
-    vi.mocked(api.getApiBase).mockReturnValue('http://localhost:3000');
-    (global.fetch as any).mockResolvedValue({
-      json: () => Promise.resolve({
+  it('shows loading then brains from API', async () => {
+    vi.mocked(apiFetch).mockResolvedValue({
+      ok: true,
+      json: async () => ({
         brains: [
-          { id: 'default', name: 'Global Brain', layer: 'global', exists: true, node_count: 10 }
-        ]
-      })
-    });
+          { id: 'global', name: 'Global Brain', layer: 'global', exists: true, node_count: 10 },
+          {
+            id: 'project:demo',
+            name: 'demo',
+            layer: 'project',
+            exists: true,
+            node_count: 5,
+            project_root: '/tmp/demo',
+          },
+        ],
+      }),
+    } as any);
 
-    render(<BrainSelector activeBrainId="default" onBrainChange={() => {}} />);
+    const onBrainChange = vi.fn();
+    render(<BrainSelector activeBrainId="global" onBrainChange={onBrainChange} />);
 
+    expect(screen.getByTestId('brain-selector-loading')).toBeInTheDocument();
     await waitFor(() => {
-      expect(screen.getByText(/Global Brain/i)).toBeInTheDocument();
+      expect(screen.getByTestId('brain-selector')).toBeInTheDocument();
     });
+    expect(screen.getByText(/Global Brain/i)).toBeInTheDocument();
   });
 
-  it('toggles brain selection', async () => {
-    vi.mocked(api.getApiBase).mockReturnValue('http://localhost:3000');
-    (global.fetch as any).mockResolvedValue({
-      json: () => Promise.resolve({
+  it('selects a single brain on row click', async () => {
+    vi.mocked(apiFetch).mockResolvedValue({
+      ok: true,
+      json: async () => ({
         brains: [
-          { id: 'default', name: 'Global Brain', layer: 'global', exists: true, node_count: 10 },
-          { id: 'proj', name: 'Project Brain', layer: 'project', exists: true, node_count: 5 }
-        ]
-      })
-    });
+          { id: 'global', name: 'Global Brain', layer: 'global', exists: true, node_count: 10 },
+          { id: 'project:demo', name: 'demo', layer: 'project', exists: true, node_count: 5 },
+        ],
+      }),
+    } as any);
 
     const onBrainChange = vi.fn();
-    render(<BrainSelector activeBrainId="default" onBrainChange={onBrainChange} />);
+    render(<BrainSelector activeBrainId="global" onBrainChange={onBrainChange} />);
 
-    // Wait for load
-    await waitFor(() => {
-      expect(screen.getByText(/Global Brain/i)).toBeInTheDocument();
-    });
+    await waitFor(() => expect(screen.getByTestId('brain-selector-trigger')).toBeInTheDocument());
+    fireEvent.click(screen.getByTestId('brain-selector-trigger'));
+    fireEvent.click(screen.getByTestId('brain-option-project:demo'));
+    expect(onBrainChange).toHaveBeenCalledWith('project:demo');
+  });
 
-    // Expand dropdown
-    const trigger = screen.getByTitle('Select brain layers');
-    fireEvent.click(trigger);
+  it('multi-select via checkbox', async () => {
+    vi.mocked(apiFetch).mockResolvedValue({
+      ok: true,
+      json: async () => ({
+        brains: [
+          { id: 'global', name: 'Global Brain', layer: 'global', exists: true, node_count: 10 },
+          { id: 'project:demo', name: 'demo', layer: 'project', exists: true, node_count: 5 },
+        ],
+      }),
+    } as any);
 
-    // Click checkbox
-    const checkboxes = screen.getAllByRole('checkbox');
-    expect(checkboxes.length).toBe(2);
+    const onBrainChange = vi.fn();
+    render(<BrainSelector activeBrainId="global" onBrainChange={onBrainChange} />);
+    await waitFor(() => expect(screen.getByTestId('brain-selector-trigger')).toBeInTheDocument());
+    fireEvent.click(screen.getByTestId('brain-selector-trigger'));
+    const checkbox = screen.getByLabelText('Include demo');
+    fireEvent.click(checkbox);
+    expect(onBrainChange).toHaveBeenCalledWith('global,project:demo');
+  });
 
-    // Toggle the second one
-    fireEvent.click(checkboxes[1]);
+  it('shows error with retry when API fails', async () => {
+    vi.mocked(apiFetch).mockResolvedValue({
+      ok: false,
+      status: 401,
+      json: async () => ({ error: 'Authentication required' }),
+    } as any);
 
-    expect(onBrainChange).toHaveBeenCalledWith('default,proj');
+    render(<BrainSelector activeBrainId="global" onBrainChange={vi.fn()} />);
+    await waitFor(() => {
+      expect(screen.getByTestId('brain-selector-error')).toBeInTheDocument();
+    });
   });
 });