Skip to content

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

fix: refresh bounded inbox pages after sync without broadcasting bodies

Adam Eivy38ea10b8a316
diff --git a/client/src/components/messages/InboxTab.jsx b/client/src/components/messages/InboxTab.jsx
index 9dffa419da..9122ca3f69 100644
--- a/client/src/components/messages/InboxTab.jsx
+++ b/client/src/components/messages/InboxTab.jsx
@@ -4,14 +4,13 @@ import { useNavigate, useSearchParams } from 'react-router';
import toast from '../ui/Toast';
import TabPills from '../ui/TabPills';
import * as api from '../../services/api';
-import socket from '../../services/socket';
import { timeAgo, formatDateNumeric } from '../../utils/formatters';
import { pluralize } from '../../lib/textUtils';
import MessageDetail from './MessageDetail';
import AddToThreadButton from '../threads/AddToThreadButton';
import { messageReadState, partitionAccountsBySyncMode } from '../../lib/messageSyncModes';
import LoadFailedState from '../ui/LoadFailedState';
-import useLatestRequest from '../../hooks/useLatestRequest';
+import { useSocketResource } from '../../hooks/useSocketResource';
const ACTION_CONFIG = {
reply: { icon: Reply, color: 'text-port-accent', bg: 'bg-port-accent/10', hoverBg: 'hover:bg-port-accent/20', label: 'Reply' },
@@ -21,6 +20,8 @@ const ACTION_CONFIG = {
};
const ACTION_ORDER = ['reply', 'review', 'archive', 'delete'];
+const INBOX_EVENTS = ['messages:sync:completed'];
+const EMPTY_MESSAGES = [];
// Email sources that support archive/delete actions
const ACTIONABLE_SOURCES = ['outlook', 'gmail'];
@@ -179,9 +180,6 @@ export default function InboxTab({ accounts }) {
// Everything below iterates the list; the `null` load-failed sentinel is only
// meaningful to the empty state, which reads `accounts` directly.
const accountList = useMemo(() => accounts || [], [accounts]);
- const [messages, setMessages] = useState([]);
- const [loading, setLoading] = useState(true);
- const [loadFailed, setLoadFailed] = useState(false);
const [search, setSearch] = useState('');
const [debouncedSearch, setDebouncedSearch] = useState('');
const [selectedAccount, setSelectedAccount] = useState('');
@@ -230,25 +228,25 @@ export default function InboxTab({ accounts }) {
return () => clearTimeout(debounceRef.current);
}, [search]);
- // A fast typist fires overlapping searches; an older, slower response must not
- // replace the list for the query now in the box.
- const beginRequest = useLatestRequest();
- const fetchMessages = useCallback(async () => {
- const isCurrent = beginRequest();
- setLoading(true);
+ // Sync providers report progress without broadcasting message bodies. Read
+ // the bounded, filtered summary page only after the cache has been saved.
+ // The resource also reconciles missed completions on reconnect/tab show.
+ const readMessages = useCallback(async ({ signal }) => {
const params = { summary: true };
if (selectedAccount) params.accountId = selectedAccount;
if (debouncedSearch) params.search = debouncedSearch;
- const result = await api.getMessageInbox(params, { silent: true }).catch(() => null);
- if (!isCurrent()) return;
- setLoadFailed(result === null);
- if (result) setMessages(result.messages || []);
- setLoading(false);
- }, [selectedAccount, debouncedSearch, beginRequest]);
-
- useEffect(() => {
- fetchMessages();
- }, [fetchMessages]);
+ const result = await api.getMessageInbox(params, { silent: true, signal });
+ return result.messages || [];
+ }, [selectedAccount, debouncedSearch]);
+ const { data, loading, error, refetch: fetchMessages, updateData } = useSocketResource(readMessages, {
+ events: INBOX_EVENTS,
+ resourceKey: JSON.stringify([selectedAccount, debouncedSearch]),
+ // A locally requested multi-account sync owns one final refresh below.
+ matchesEvent: payload => !syncing && (!selectedAccount || payload?.accountId === selectedAccount),
+ });
+ const messages = data || EMPTY_MESSAGES;
+ const loadFailed = Boolean(error);
+ const setMessages = useCallback(updater => updateData(previous => updater(previous || EMPTY_MESSAGES)), [updateData]);
// List rows are summaries. The selection URL is the only trigger for a full
// body read, including when the selected message is already on this page.
@@ -279,33 +277,6 @@ export default function InboxTab({ accounts }) {
if (messageId && !resolvedMessageAccount && !loading) closeMessage();
}, [messageId, resolvedMessageAccount, loading, closeMessage]);
- // Stream messages into the list as they arrive during sync
- useEffect(() => {
- const onSyncMessage = ({ messages: incoming }) => {
- if (!incoming?.length) return;
- setMessages(prev => {
- const byExtId = new Map(prev.map(m => [m.externalId, m]));
- let changed = false;
- for (const msg of incoming) {
- if (msg.externalId && byExtId.has(msg.externalId)) {
- const existing = byExtId.get(msg.externalId);
- byExtId.set(msg.externalId, { ...existing, ...msg, id: existing.id });
- changed = true;
- } else {
- byExtId.set(msg.externalId || msg.id, msg);
- changed = true;
- }
- }
- if (!changed) return prev;
- return Array.from(byExtId.values()).sort((a, b) =>
- new Date(b.date || 0) - new Date(a.date || 0)
- );
- });
- };
- socket.on('messages:sync:message', onSyncMessage);
- return () => socket.off('messages:sync:message', onSyncMessage);
- }, []);
-
const handleSync = async (mode) => {
if (syncTargets.length === 0) return toast.error('No enabled accounts to sync');
// Aggregate unread sync only runs on accounts that can measure read state; say
@@ -329,6 +300,9 @@ export default function InboxTab({ accounts }) {
if (result.pruned) totalPruned += result.pruned;
}
setSyncing(false);
+ // Reconcile any completion skipped during this local batch, even if an
+ // HTTP response was lost after another account's cache was saved.
+ fetchMessages();
// Every account failing is not a completed sync — stay quiet, and leave the
// "never synced" state intact so the empty state keeps offering the retry.
if (Object.keys(syncedNow).length === 0) return;
@@ -336,7 +310,6 @@ export default function InboxTab({ accounts }) {
const parts = [`${totalNew} new`];
if (totalPruned > 0) parts.push(`${totalPruned} removed`);
toast.success(`Sync complete — ${parts.join(', ')}`);
- fetchMessages();
};
const handleEvaluate = async () => {
diff --git a/client/src/components/messages/InboxTab.test.jsx b/client/src/components/messages/InboxTab.test.jsx
index f7188b271c..690ac15adf 100644
--- a/client/src/components/messages/InboxTab.test.jsx
+++ b/client/src/components/messages/InboxTab.test.jsx
@@ -75,6 +75,50 @@ beforeEach(() => {
api.syncMessageAccount.mockResolvedValue({ newMessages: 0, pruned: 0 });
});
+describe('InboxTab sync reconciliation', () => {
+ const rows = Array.from({ length: 50 }, (_, i) => ({
+ id: `synthetic-${i}`, externalId: `external-${i}`, accountId: syncedAccount.id,
+ subject: `Synthetic summary ${i}`, from: { name: 'Example Sender' }, date: HOUR_AGO, preview: 'Compact preview',
+ }));
+
+ it('coalesces completed syncs into one bounded summary read without hydrating bodies', async () => {
+ api.getMessageInbox.mockResolvedValue({ messages: rows, total: 5000 });
+ renderInbox([syncedAccount]);
+ await waitFor(() => expect(screen.getAllByText(/^Synthetic summary /)).toHaveLength(50));
+ const completed = socket.on.mock.calls.find(([event]) => event === 'messages:sync:completed')[1];
+ expect(socket.on.mock.calls.some(([event]) => event === 'messages:sync:message')).toBe(false);
+ api.getMessageInbox.mockResolvedValue({ messages: rows.map(row => ({ ...row, subject: row.subject.replace('summary', 'updated') })), total: 5500 });
+ act(() => {
+ completed({ accountId: syncedAccount.id, newMessages: 500, status: 'success' });
+ completed({ accountId: syncedAccount.id, newMessages: 0, status: 'partial' });
+ });
+ await waitFor(() => expect(screen.getAllByText(/^Synthetic updated /)).toHaveLength(50));
+ expect(api.getMessageInbox).toHaveBeenCalledTimes(2);
+ expect(api.getMessageInbox).toHaveBeenLastCalledWith({ summary: true }, expect.objectContaining({ silent: true }));
+ expect(api.getMessageDetail).not.toHaveBeenCalled();
+ });
+
+ it('ignores another account completion and reconciles the selected account on reconnect', async () => {
+ api.getMessageInbox.mockResolvedValue({ messages: rows, total: 5000 });
+ const view = renderInbox([syncedAccount]);
+ await waitFor(() => expect(screen.getAllByText(/^Synthetic summary /)).toHaveLength(50));
+ fireEvent.change(screen.getByRole('combobox'), { target: { value: syncedAccount.id } });
+ await waitFor(() => expect(api.getMessageInbox).toHaveBeenCalledTimes(2));
+ await waitFor(() => expect(screen.getAllByText(/^Synthetic summary /)).toHaveLength(50));
+ const completed = socket.on.mock.calls.filter(([event]) => event === 'messages:sync:completed').at(-1)[1];
+ await act(async () => { completed({ accountId: 'other-account', status: 'success' }); });
+ expect(api.getMessageInbox).toHaveBeenCalledTimes(2);
+ const reconnect = socket.on.mock.calls.filter(([event]) => event === 'connect').at(-1)[1];
+ await act(async () => { reconnect(); });
+ expect(api.getMessageInbox).toHaveBeenCalledTimes(3);
+ expect(api.getMessageInbox).toHaveBeenLastCalledWith({ summary: true, accountId: syncedAccount.id }, expect.objectContaining({ silent: true }));
+ view.unmount();
+ expect(socket.off).toHaveBeenCalledWith('messages:sync:completed', completed);
+ await act(async () => { completed({ accountId: syncedAccount.id, status: 'success' }); });
+ expect(api.getMessageInbox).toHaveBeenCalledTimes(3);
+ });
+});
+
describe('latestSyncAt', () => {
it('returns null when no account has ever synced', () => {
expect(latestSyncAt([neverSyncedAccount, { ...neverSyncedAccount, id: 'b' }])).toBeNull();
@@ -143,6 +187,7 @@ describe('InboxTab empty state', () => {
fireEvent.click(screen.getAllByRole('button', { name: /sync unread/i }).at(-1));
await waitFor(() => expect(toast.error).toHaveBeenCalled());
+ await waitFor(() => expect(api.getMessageInbox).toHaveBeenCalledTimes(2));
expect(toast.success).not.toHaveBeenCalled();
expect(screen.getByText('Nothing synced yet')).toBeInTheDocument();
});
@@ -299,7 +344,7 @@ describe('InboxTab message selection URL', () => {
api.getMessageDetail.mockResolvedValue(message);
renderInboxWithLocation([neverSyncedAccount], { route: '/messages/inbox?triage=reply' });
expect(await screen.findByText('Short preview')).toBeInTheDocument();
- expect(api.getMessageInbox).toHaveBeenCalledWith({ summary: true }, { silent: true });
+ expect(api.getMessageInbox).toHaveBeenCalledWith({ summary: true }, expect.objectContaining({ silent: true, signal: expect.any(AbortSignal) }));
expect(api.getMessageDetail).not.toHaveBeenCalled();
fireEvent.click(await screen.findByRole('button', { name: /a message to inspect/i }));
diff --git a/server/lib/socketEventContracts.js b/server/lib/socketEventContracts.js
index 027ffe1a73..5326b09dc6 100644
--- a/server/lib/socketEventContracts.js
+++ b/server/lib/socketEventContracts.js
@@ -44,6 +44,17 @@ const loomRunSnapshot = (production) => Object.freeze({
});
export const SOCKET_EVENT_CONTRACTS = Object.freeze({
+ 'messages:sync:completed': {
+ direction: 'server-to-client',
+ summary: 'Account cache persisted after sync; visible inbox consumers reconcile a bounded summary page. No message bodies.',
+ payloadSchema: {
+ type: 'object', required: ['accountId', 'newMessages', 'pruned', 'status'], additionalProperties: false,
+ properties: {
+ accountId: { type: 'string' }, newMessages: { type: 'integer', minimum: 0 },
+ pruned: { type: 'integer', minimum: 0 }, status: { type: 'string' }, reason: { type: 'string' },
+ },
+ },
+ },
'cos:agent:feedback': {
direction: 'server-to-client',
summary: 'Persisted agent feedback after the pending-feedback index has been updated; CoS subscribers only.',
diff --git a/server/services/messageApiSync.js b/server/services/messageApiSync.js
index 6070fc4b4a..178debd3c6 100644
--- a/server/services/messageApiSync.js
+++ b/server/services/messageApiSync.js
@@ -130,11 +130,6 @@ export async function syncOutlookApi(account, cache, io, options = {}) {
if (messages.length >= maxMessages) break;
}
- // Emit messages in real-time
- if (io && messages.length > 0) {
- io.emit('messages:sync:message', { accountId: account.id, messages });
- }
-
console.log(`📧 API sync complete: ${messages.length} messages fetched in ${page} page(s)`);
return { messages, inboxComplete: mode === 'full' && !url && validMembership, status: 'success', syncMethod: 'api' };
}
diff --git a/server/services/messageApiSync.test.js b/server/services/messageApiSync.test.js
index 874fcb2c4f..449d0e5251 100644
--- a/server/services/messageApiSync.test.js
+++ b/server/services/messageApiSync.test.js
@@ -66,12 +66,17 @@ describe('syncOutlookApi — malformed-body masquerade guard', () => {
});
it('certifies a full snapshot only after its last page', async () => {
+ const body = 'Synthetic body '.repeat(1000);
+ const io = { emit: vi.fn() };
fetchWithTimeout.mockResolvedValueOnce(mockJsonResponse({
- value: [{ Id: 'a' }], '@odata.nextLink': 'https://outlook.office.com/next',
+ value: [{ Id: 'a', Body: { Content: body } }], '@odata.nextLink': 'https://outlook.office.com/next',
})).mockResolvedValueOnce(mockJsonResponse({ value: [{ Id: 'b' }] }));
- const result = await syncOutlookApi(ACCOUNT, {}, null, { mode: 'full' });
+ const result = await syncOutlookApi(ACCOUNT, {}, io, { mode: 'full' });
expect(result.messages).toHaveLength(2);
expect(result.inboxComplete).toBe(true);
+ expect(result.messages[0].bodyText).toBe(body);
+ expect(io.emit.mock.calls.map(([event]) => event)).toEqual(['messages:sync:progress', 'messages:sync:progress']);
+ expect(JSON.stringify(io.emit.mock.calls)).not.toContain(body);
});
it('merges valid rows without certifying malformed membership', async () => {
diff --git a/server/services/messageGmailSync.js b/server/services/messageGmailSync.js
index 6f0a3fa590..72e18ec862 100644
--- a/server/services/messageGmailSync.js
+++ b/server/services/messageGmailSync.js
@@ -362,10 +362,6 @@ export async function syncGmail(account, cache, io, options = {}) {
else inboxMessages.push(m);
}
- if (io && inboxMessages.length > 0) {
- io.emit('messages:sync:message', { accountId: account.id, messages: inboxMessages });
- }
-
// Sent-coverage fail-closed also covers a dropped detail fetch (#2820): a
// `users.messages.get` that failed above was skipped, but `sentTruncated` only
// reflects LIST pagination — so a dropped message (possibly the user's reply)
diff --git a/server/services/messagePlaywrightSync.js b/server/services/messagePlaywrightSync.js
index 07999d19d0..6b24e23536 100644
--- a/server/services/messagePlaywrightSync.js
+++ b/server/services/messagePlaywrightSync.js
@@ -167,12 +167,6 @@ export async function syncPlaywright(account, cache, io, options = {}) {
...overrides
});
- // Helper: emit a batch of messages to the client in real-time
- const emitMessages = (msgs) => {
- if (!io || msgs.length === 0) return;
- io.emit('messages:sync:message', { accountId: account.id, messages: msgs });
- };
-
for (let i = 0; i < extracted.length; i++) {
const msg = extracted[i];
const extId = browserSummaryId(msg.date || '', msg.from || '', msg.subject || '');
@@ -189,7 +183,6 @@ export async function syncPlaywright(account, cache, io, options = {}) {
isUnread: msg.isUnread === null ? null : (msg.isUnread ?? false),
isPinned: msg.isPinned, isFlagged: msg.isFlagged, isReplied: msg.isReplied }));
messages.push(...batch);
- emitMessages(batch);
continue;
}
@@ -214,16 +207,13 @@ export async function syncPlaywright(account, cache, io, options = {}) {
browserSummaryExternalId: extId
}));
messages.push(...batch);
- emitMessages(batch);
} else {
const m = buildMessage(msg, extId);
messages.push(m);
- emitMessages([m]);
}
} else {
const m = buildMessage(msg, extId);
messages.push(m);
- emitMessages([m]);
}
}
diff --git a/server/services/messagePlaywrightSync.test.js b/server/services/messagePlaywrightSync.test.js
index 7f6216c561..f20e9c8547 100644
--- a/server/services/messagePlaywrightSync.test.js
+++ b/server/services/messagePlaywrightSync.test.js
@@ -467,6 +467,9 @@ it('preserves unknown Teams read state when replaying a cached full body', async
const row = { from: 'Example Sender', subject: '', date: '2026-01-01T12:00:00Z', isUnread: null };
evaluateOnPage.mockResolvedValue([row]);
const cached = { id: 'cached', externalId: browserSummaryId(row.date, row.from, row.subject), bodyFull: true, bodyText: 'Cached body' };
- const result = await syncPlaywright({ id: 'example-account', type: 'teams' }, { messages: [cached] });
+ const io = { emit: vi.fn() };
+ const result = await syncPlaywright({ id: 'example-account', type: 'teams' }, { messages: [cached] }, io);
expect(result.messages).toEqual([expect.objectContaining({ id: cached.id, bodyText: 'Cached body', isRead: null, isUnread: null })]);
+ expect(io.emit.mock.calls.map(([event]) => event)).toEqual(['messages:sync:progress']);
+ expect(JSON.stringify(io.emit.mock.calls)).not.toContain(cached.bodyText);
});
diff --git a/server/services/messageSync.test.js b/server/services/messageSync.test.js
index 8a6b880bc7..b6ca7ae732 100644
--- a/server/services/messageSync.test.js
+++ b/server/services/messageSync.test.js
@@ -1081,6 +1081,32 @@ describe('full inbox coverage contract', () => {
}));
});
+ it('keeps full Gmail bodies in the cache and broadcasts only progress until the saved completion', async () => {
+ const count = 200; // Gmail's full-sync transport ceiling.
+ const body = 'x'.repeat(8192);
+ const io = { emit: vi.fn((event) => {
+ if (event === 'messages:sync:completed') {
+ expect(saved.messages.filter(message => message.bodyText === body)).toHaveLength(count);
+ }
+ }) };
+ gmailApi.list.mockImplementation(async ({ q, pageToken, maxResults }) => {
+ const start = Number(pageToken || 0);
+ const end = Math.min(start + maxResults, count);
+ return { data: q === 'in:inbox' ? {
+ messages: Array.from({ length: end - start }, (_, i) => ({ id: `synthetic-${start + i}` })),
+ ...(end < count ? { nextPageToken: String(end) } : {}),
+ } : {} };
+ });
+ gmailApi.get.mockImplementation(async ({ id }) => ({ data: {
+ id, labelIds: ['INBOX'], payload: { headers: [], mimeType: 'text/plain', body: { data: Buffer.from(body).toString('base64url') } },
+ } }));
+
+ expect(await syncAccount(VALID_UUID, io, { mode: 'full' })).toMatchObject({ newMessages: count });
+ expect(io.emit).toHaveBeenCalledWith('messages:sync:completed', expect.objectContaining({ newMessages: count }));
+ expect(io.emit.mock.calls.some(([, payload]) => payload.messages)).toBe(false);
+ expect(Buffer.byteLength(JSON.stringify(io.emit.mock.calls))).toBeLessThan(100_000);
+ });
+
it('preserves identity and evaluation through failure and retry, then reconciles complete snapshots', async () => {
gmailApi.get.mockImplementationOnce(async () => ({
data: { id: 'a', labelIds: ['INBOX', 'UNREAD'], payload: { headers: [] } },