Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS
JavaScript ai-agentsdashboarddeveloper-toolsdigital-twinquantified-selfsecond-brainself-hostedtailscale
import { useState, useEffect, useCallback, useRef, useMemo, lazy, Suspense } from 'react';
import { useNavigate, useParams, useSearchParams } from 'react-router';
import {Trash2, X, Check, XCircle, Pencil, AlertTriangle, Brain, Bot} from 'lucide-react';
import toast from '../../ui/Toast';
import Banner from '../../ui/Banner';
import * as api from '../../../services/api';
import { useSocketResource } from '../../../hooks/useSocketResource';
import { MEMORY_TYPES, MEMORY_TYPE_COLORS } from '../constants';
import { getAppName, formatCount, formatDateNumeric, formatPercent } from '../../../utils/formatters';
import MemoryTimeline from './MemoryTimeline';
// Lazy: MemoryGraph pulls the three.js stack; load it only when rendered.
const MemoryGraph = lazy(() => import('./MemoryGraph'));
import MemoryEditModal from './MemoryEditModal';
import ProviderModelSelector from '../../ProviderModelSelector';
import useProviderModels from '../../../hooks/useProviderModels';
import BrailleSpinner from '../../BrailleSpinner';
import InlineConfirmRow from '../../ui/InlineConfirmRow';
import CopyableId from '../../ui/CopyableId';
import { useConfirmDelete } from '../../../hooks/useConfirmDelete';
const MEMORY_EVENTS = ['cos:memory:created', 'cos:memory:updated', 'cos:memory:deleted', 'cos:memory:extracted'];
const QUEUE_EVENTS = [...MEMORY_EVENTS, 'cos:memory:approval-needed'];
const STATUS_EVENTS = [];
export default function MemoryTab({ apps = [] }) {
const [searchParams, setSearchParams] = useSearchParams();
const [searchQuery, setSearchQuery] = useState('');
const [submittedSearch, setSubmittedSearch] = useState('');
const [filters, setFilters] = useState({ types: [] });
const [sourceFilter, setSourceFilter] = useState('all'); // 'all' | 'cos' | 'brain'
const view = searchParams.get('view') || 'list';
const setView = useCallback((v) => {
setSearchParams(prev => {
const next = new URLSearchParams(prev);
next.set('view', v);
return next;
}, { replace: true });
}, [setSearchParams]);
// /cos/memory/:id deep-links one memory (e.g. from an agent card's "Memories
// used"). The shared `cos/:tab/:agentId` route names that segment `agentId`.
const { agentId: linkedMemoryId } = useParams();
const navigate = useNavigate();
const linkedMemory = useMemo(() => (linkedMemoryId ? { id: linkedMemoryId } : null), [linkedMemoryId]);
const openMemory = linkedMemory;
const closeMemory = useCallback(() => {
if (linkedMemoryId) navigate('/cos/memory', { replace: true });
}, [linkedMemoryId, navigate]);
const { isConfirming, requestDelete, cancelDelete, confirmDelete } = useConfirmDelete();
// Embedding provider/model configuration
const { providers, availableModels, setSelectedProviderId: setProviderHook, setSelectedModel: setModelHook, selectedProviderId: hookProviderId, selectedModel: hookModel } = useProviderModels();
const [embeddingProviderId, setEmbeddingProviderId] = useState('');
const [embeddingModel, setEmbeddingModel] = useState('');
const [embeddingConfigLoaded, setEmbeddingConfigLoaded] = useState(false);
// Load current embedding config from CoS config
useEffect(() => {
if (embeddingConfigLoaded) return;
let active = true;
api.getCosConfig().then(cfg => {
if (!active) return;
if (cfg?.embeddingProviderId) {
setEmbeddingProviderId(cfg.embeddingProviderId);
setProviderHook(cfg.embeddingProviderId);
}
if (cfg?.embeddingModel) {
setEmbeddingModel(cfg.embeddingModel);
setModelHook(cfg.embeddingModel);
}
setEmbeddingConfigLoaded(true);
}).catch(() => { if (active) setEmbeddingConfigLoaded(true); });
return () => { active = false; };
}, [embeddingConfigLoaded, setProviderHook, setModelHook]);
const appId = sourceFilter === 'brain' ? 'brain' : sourceFilter === 'cos' ? '__not_brain' : undefined;
const queryKey = JSON.stringify([sourceFilter, filters, submittedSearch]);
const list = useSocketResource(async ({ signal }) => {
const result = submittedSearch
? await api.searchMemories(submittedSearch, { limit: 20, appId }, { signal, silent: true })
: await api.getMemories({ limit: 100, ...filters, appId }, { signal, silent: true });
if (!Array.isArray(result?.memories)) throw new Error('Invalid memory list response');
return result.memories;
}, { namespace: 'cos', events: MEMORY_EVENTS, resourceKey: queryKey, enabled: view !== 'graph' });
const queue = useSocketResource(async ({ signal }) => {
const pending = await api.getMemories({ status: 'pending_approval', limit: 50, appId }, { signal, silent: true });
if (!Array.isArray(pending?.memories)) throw new Error('Invalid pending memory response');
return pending.memories;
}, { namespace: 'cos', events: QUEUE_EVENTS, resourceKey: sourceFilter });
// Counts and pending approvals fail independently: a stats outage must never
// discard a usable approval queue (or vice versa).
const counts = useSocketResource(
async ({ signal }) => {
const result = await api.getMemoryStats({ signal, silent: true });
if (!Number.isFinite(result?.active)) throw new Error('Invalid memory counts response');
return result;
},
{ namespace: 'cos', events: QUEUE_EVENTS }
);
const status = useSocketResource(async () => {
const [embeddingStatus, backendStatus] = await Promise.all([
api.getEmbeddingStatus(), api.getMemoryBackendStatus()
]);
return { embeddingStatus, backendStatus };
}, { events: STATUS_EVENTS });
const memories = list.data || [];
const pendingMemories = queue.data || [];
const stats = counts.data;
const embeddingStatus = status.data?.embeddingStatus;
const backendStatus = status.data?.backendStatus;
const fetchData = useCallback(() => {
list.refetch();
queue.refetch();
counts.refetch();
status.refetch();
}, [list.refetch, queue.refetch, counts.refetch, status.refetch]);
const [actionInFlight, setActionInFlight] = useState(null);
const actionRef = useRef(false);
const handleMemoryAction = async (id, action, label, updateStats) => {
if (actionRef.current) return;
actionRef.current = true;
setActionInFlight(id);
const result = await action(id, { silent: true }).catch(err => {
toast.error(err?.message || `Failed to ${label.toLowerCase()} memory`);
return null;
});
actionRef.current = false;
setActionInFlight(null);
if (!result) return;
toast.success(`Memory ${label}`);
queue.updateData(prev => prev?.filter(m => m.id !== id));
counts.updateData(prev => prev ? {
...prev,
pendingApproval: Math.max(0, (prev.pendingApproval || 0) - 1),
...(updateStats ? updateStats(prev) : {})
} : prev);
list.refetch();
queue.refetch();
counts.refetch();
};
const handleApprove = (id) => handleMemoryAction(id, api.approveMemory, 'approved', (prev) => ({ active: (prev.active || 0) + 1 }));
const handleReject = (id) => handleMemoryAction(id, api.rejectMemory, 'rejected', () => ({}));
const handleSearch = () => {
const query = searchQuery.trim();
if (query === submittedSearch) list.refetch();
else setSubmittedSearch(query);
};
const handleDelete = async (id) => {
await api.deleteMemory(id);
toast.success('Memory archived');
list.updateData(prev => prev?.filter(memory => memory.id !== id));
list.refetch();
queue.refetch();
counts.refetch();
};
const displayMemories = memories;
return (
<div className="space-y-6">
{/* Backend status banner */}
{backendStatus?.backend === 'file' && (
<Banner
size="lg"
icon={AlertTriangle}
title="PostgreSQL unavailable — using file storage"
actions={
<button
onClick={fetchData}
className="px-3 py-1.5 text-sm bg-port-warning/20 text-port-warning hover:bg-port-warning/30 rounded-lg transition-colors"
>
Retry
</button>
}
>
{backendStatus.db?.error && (
<p className="text-sm text-gray-400 mt-1">{backendStatus.db.error}</p>
)}
<p className="text-sm text-gray-500 mt-1">Some PostgreSQL-only features like cross-instance sync and DB snapshots are unavailable.</p>
</Banner>
)}
{/* Header */}
<div className="flex flex-col sm:flex-row sm:items-center justify-between gap-3">
<div>
<h3 className="text-lg font-semibold text-white">Memory System</h3>
<p className="text-sm text-gray-500">
{formatCount(stats?.active)} active memories
{stats?.pendingApproval > 0 && <span className="text-yellow-400"> * {stats.pendingApproval} pending</span>}
{embeddingStatus?.available ? ' * Embeddings online' : ' * Embeddings offline'}
</p>
</div>
<div className="flex gap-2">
{['list', 'timeline', 'graph'].map(v => (
<button
key={v}
onClick={() => setView(v)}
className={`px-3 py-1.5 text-sm rounded-lg transition-colors ${
view === v ? 'bg-port-accent text-white' : 'bg-port-border text-gray-400 hover:text-white'
}`}
>
{v.charAt(0).toUpperCase() + v.slice(1)}
</button>
))}
</div>
</div>
{/* Search and type filters only apply to the list and timeline. */}
{view !== 'graph' && <div className="flex gap-2">
<input
type="text"
value={searchQuery}
onChange={(e) => setSearchQuery(e.target.value)}
onKeyDown={(e) => e.key === 'Enter' && handleSearch()}
placeholder="Search memories semantically..."
aria-label="Search memories"
className="flex-1 bg-port-card border border-port-border rounded-lg px-3 py-1.5 text-sm text-white placeholder-gray-500 focus:border-port-accent outline-hidden"
/>
<button
onClick={handleSearch}
className="px-3 py-1.5 text-sm bg-port-accent hover:bg-port-accent/80 text-white rounded-lg transition-colors"
>
Search
</button>
{submittedSearch && (
<button
onClick={() => { setSubmittedSearch(''); setSearchQuery(''); }}
aria-label="Close"
className="px-2 py-1.5 flex items-center justify-center bg-port-border text-gray-400 hover:text-white rounded-lg transition-colors min-h-[44px] min-w-[44px]"
>
<X size={18} />
</button>
)}
</div>}
{/* Source selection scopes pending approvals in every view. */}
<div className="flex flex-wrap items-center gap-2">
<span className="text-xs text-gray-500">{view === 'graph' ? 'Pending approval source:' : 'Source:'}</span>
{['all', 'cos', 'brain'].map(src => (
<button
key={src}
aria-pressed={sourceFilter === src}
onClick={() => setSourceFilter(src)}
className={`px-3 py-2 min-h-[36px] text-xs rounded-full border transition-colors flex items-center gap-1.5 ${
sourceFilter === src
? 'border-port-accent text-port-accent bg-port-accent/10'
: 'border-port-border text-gray-500 hover:text-gray-300'
}`}
>
{src === 'brain' && <Brain size={12} />}
{src === 'cos' && <Bot size={12} />}
{src === 'all' ? 'All Sources' : src === 'cos' ? 'CoS' : 'Brain'}
</button>
))}
{view !== 'graph' && <span className="w-px h-5 bg-port-border" />}
{view !== 'graph' && MEMORY_TYPES.map(type => (
<button
key={type}
aria-pressed={filters.types.includes(type)}
onClick={() => {
const newTypes = filters.types.includes(type)
? filters.types.filter(t => t !== type)
: [...filters.types, type];
setFilters({ ...filters, types: newTypes });
}}
className={`px-3 py-2 min-h-[36px] text-xs rounded-full border transition-colors ${
filters.types.includes(type) ? MEMORY_TYPE_COLORS[type] : 'border-port-border text-gray-500 hover:text-gray-300'
}`}
>
{type}
</button>
))}
</div>
{/* Stats Row */}
{stats && (
<div className="grid grid-cols-3 md:grid-cols-6 gap-2">
{Object.entries(stats.byType || {}).map(([type, count]) => (
<div key={type} className={`p-2 rounded-lg border text-center ${MEMORY_TYPE_COLORS[type] || 'border-port-border'}`}>
<div className="text-lg font-bold">{count}</div>
<div className="text-xs opacity-75">{type}</div>
</div>
))}
</div>
)}
{/* Pending Approvals */}
{pendingMemories.length > 0 && (
<div className="space-y-3">
<h3 className="text-lg font-semibold text-yellow-500">Pending Approval ({pendingMemories.length})</h3>
{pendingMemories.map(memory => (
<div key={memory.id} className="bg-port-card border border-yellow-500/50 rounded-lg p-4">
<div className="flex flex-col sm:flex-row sm:items-start justify-between gap-4">
<div className="flex-1 min-w-0">
<div className="flex flex-wrap items-center gap-2 mb-2">
<span className={`px-2 py-1 text-xs rounded-full border ${MEMORY_TYPE_COLORS[memory.type]}`}>
{memory.type}
</span>
<span className="text-xs text-gray-500">{memory.category}</span>
<span className="text-xs text-yellow-400">
{formatPercent((memory.confidence || 0) * 100, { decimals: 0 })} confidence
</span>
</div>
<p className="text-white text-sm whitespace-pre-wrap">{memory.summary || memory.content}</p>
{memory.tags?.length > 0 && (
<div className="flex flex-wrap gap-1 mt-2">
{memory.tags.map(tag => (
<span key={tag} className="px-2 py-1 text-xs bg-port-border rounded text-gray-400">
{tag}
</span>
))}
</div>
)}
<div className="text-xs text-gray-500 mt-2 flex flex-wrap gap-2">
<span>{formatDateNumeric(memory.createdAt)}</span>
{getAppName(memory.sourceAppId, apps) && (
<>
<span>*</span>
<span className="text-port-accent">{getAppName(memory.sourceAppId, apps)}</span>
</>
)}
</div>
</div>
<div className="flex gap-2 sm:flex-col md:flex-row">
<button
onClick={() => navigate(`/cos/memory/${encodeURIComponent(memory.id)}`)}
disabled={actionInFlight === memory.id}
className="flex-1 sm:flex-none p-3 min-h-[44px] min-w-[44px] flex items-center justify-center bg-port-accent/20 text-port-accent hover:bg-port-accent/30 active:bg-port-accent/40 rounded-lg transition-colors disabled:opacity-50"
title="Edit before approving"
aria-label="Edit before approving"
>
<Pencil size={20} />
</button>
<button
onClick={() => handleApprove(memory.id)}
disabled={!!actionInFlight}
className="flex-1 sm:flex-none p-3 min-h-[44px] min-w-[44px] flex items-center justify-center bg-port-success/20 text-port-success hover:bg-port-success/30 active:bg-port-success/40 rounded-lg transition-colors disabled:opacity-50"
title="Approve"
aria-label="Approve memory"
>
{actionInFlight === memory.id ? <BrailleSpinner /> : <Check size={20} />}
</button>
<button
onClick={() => handleReject(memory.id)}
disabled={!!actionInFlight}
className="flex-1 sm:flex-none p-3 min-h-[44px] min-w-[44px] flex items-center justify-center bg-red-500/20 text-red-400 hover:bg-red-500/30 active:bg-red-500/40 rounded-lg transition-colors disabled:opacity-50"
title="Reject"
aria-label="Reject memory"
>
{actionInFlight === memory.id ? <BrailleSpinner /> : <XCircle size={20} />}
</button>
</div>
</div>
</div>
))}
</div>
)}
{(list.error || queue.error || counts.error || status.error) && (
<Banner tone="warning" title="Unable to refresh memories" actions={<button onClick={fetchData}>Retry</button>}>
Existing rows are retained. Retry to reconcile the latest changes.
</Banner>
)}
{/* Content */}
{view !== 'graph' && list.loading ? (
<div className="flex items-center justify-center py-12">
<BrailleSpinner text="Loading" />
</div>
) : view !== 'graph' && list.error && list.data == null ? (
<p role="alert" className="text-port-text-muted">Memory list unavailable.</p>
) : view === 'list' ? (
<div className="space-y-3">
{displayMemories.length === 0 ? (
<div className="text-center py-12 text-gray-500">
{searchQuery ? (
'No memories found for this search'
) : (
<div className="space-y-4">
<p>No memories yet.</p>
{!embeddingStatus?.available && (
<Banner tone="warning" size="lg" title="Embedding Service Unavailable" className="text-left max-w-md mx-auto">
<p className="text-sm text-gray-400 mt-2">
Cannot connect to embedding service{embeddingStatus?.endpoint && (
<span>: <code className="text-port-accent">{embeddingStatus.endpoint}</code></span>
)}
</p>
{embeddingStatus?.error && (
<p className="text-sm text-gray-500 mt-1">Error: {embeddingStatus.error}</p>
)}
<div className="mt-3">
<ProviderModelSelector
providers={providers}
selectedProviderId={
providers?.some((p) => p.id === embeddingProviderId)
? embeddingProviderId
: providers?.some((p) => p.id === hookProviderId)
? hookProviderId
: ''
}
selectedModel={embeddingModel || hookModel}
availableModels={availableModels}
onProviderChange={(id) => { setEmbeddingProviderId(id); setProviderHook(id); setEmbeddingModel(''); }}
onModelChange={(m) => { setEmbeddingModel(m); setModelHook(m); }}
label="Embedding Provider"
/>
</div>
<button
onClick={async () => {
const pid = embeddingProviderId || hookProviderId;
const mid = embeddingModel || hookModel;
await api.updateCosConfig({ embeddingProviderId: pid, embeddingModel: mid });
toast.success('Embedding config saved');
fetchData();
}}
className="mt-3 px-4 py-2 min-h-[40px] text-sm bg-port-accent hover:bg-port-accent/80 text-white rounded-lg transition-colors"
>
Save & Retry
</button>
</Banner>
)}
{embeddingStatus?.available && (
<p className="text-sm">
Memories are automatically extracted when CoS agents complete tasks successfully.
</p>
)}
</div>
)}
</div>
) : (
displayMemories.map(memory => (
<div key={memory.id} className="bg-port-card border border-port-border rounded-lg p-4">
<div className="flex flex-col sm:flex-row sm:items-start justify-between gap-3">
<div className="flex-1 min-w-0">
<div className="flex flex-wrap items-center gap-2 mb-2">
<span className={`px-2 py-1 text-xs rounded-full border ${MEMORY_TYPE_COLORS[memory.type]}`}>
{memory.type}
</span>
<span className="text-xs text-gray-500">{memory.category}</span>
{memory.sourceAppId === 'brain' ? (
<span className="flex items-center gap-1 px-2 py-1 text-xs rounded-full bg-port-accent-2/10 text-port-accent-2 border border-port-accent-2/30">
<Brain size={10} /> Brain
</span>
) : (
<span className="flex items-center gap-1 px-2 py-1 text-xs rounded-full bg-port-accent/10 text-port-accent border border-port-accent/30">
<Bot size={10} /> CoS
</span>
)}
{memory.similarity && (
<span className="text-xs text-port-accent">{formatPercent(memory.similarity * 100, { decimals: 0 })} match</span>
)}
</div>
<p className="text-white text-sm whitespace-pre-wrap">{memory.summary || memory.content}</p>
{memory.tags?.length > 0 && (
<div className="flex flex-wrap gap-1 mt-2">
{memory.tags.map(tag => (
<span key={tag} className="px-2 py-1 text-xs bg-port-border rounded text-gray-400">
{tag}
</span>
))}
</div>
)}
<div className="text-xs text-gray-500 mt-2 flex flex-wrap items-center gap-2">
<span>{formatDateNumeric(memory.createdAt)}</span>
<span>*</span>
<span>importance: {formatPercent((memory.importance || 0.5) * 100, { decimals: 0 })}</span>
{getAppName(memory.sourceAppId, apps) && (
<>
<span>*</span>
<span className="text-port-accent">{getAppName(memory.sourceAppId, apps)}</span>
</>
)}
{memory.id && <span>*</span>}
<CopyableId id={memory.id} />
</div>
</div>
<div className="flex gap-2 sm:gap-1">
<button
onClick={() => navigate(`/cos/memory/${encodeURIComponent(memory.id)}`)}
className="p-3 min-h-[40px] min-w-[40px] flex items-center justify-center text-gray-500 hover:text-port-accent transition-colors"
title="Edit memory"
aria-label="Edit memory"
>
<Pencil size={18} />
</button>
<button
onClick={() => requestDelete(memory.id)}
className="p-3 min-h-[40px] min-w-[40px] flex items-center justify-center text-gray-500 hover:text-port-error transition-colors"
title="Archive memory"
aria-label="Archive memory"
>
<Trash2 size={18} />
</button>
</div>
</div>
{isConfirming(memory.id) && (
<InlineConfirmRow
className="mt-3"
question="Archive this memory? It will be hidden from active memory and search. Its contents remain stored."
confirmText="Archive"
confirmTitle="Confirm archive"
cancelTitle="Cancel archive"
onConfirm={() => confirmDelete(() => handleDelete(memory.id))}
onCancel={cancelDelete}
/>
)}
</div>
))
)}
</div>
) : view === 'timeline' ? (
<MemoryTimeline memories={memories} />
) : (
<Suspense fallback={<BrailleSpinner text="Loading graph" />}>
<MemoryGraph />
</Suspense>
)}
{/* Edit Modal */}
{openMemory && (
<MemoryEditModal
key={openMemory.id}
memory={openMemory}
apps={apps}
onSave={updated => {
list.updateData(prev => prev?.map(memory => memory.id === updated.id ? updated : memory));
queue.updateData(prev => prev?.map(memory => memory.id === updated.id ? updated : memory));
closeMemory();
fetchData();
}}
onClose={closeMemory}
/>
)}
</div>
);
}