cohvu 1.0.21 → 1.0.23

package/dist/tui/dashboard.js

@@ -24,6 +24,29 @@ async function launchDashboard() {
     let feedDisconnect = null;
     let copiedTimer = null;
     let inlineErrorTimer = null;
+    let toastTimer = null;
+    let lastSyncErrorAt = 0;
+    // Toast feedback
+    function showToast(message, type, durationMs = 3000) {
+        if (toastTimer)
+            clearTimeout(toastTimer);
+        dispatch({ type: 'SET_TOAST', toast: { message, type, expiresAt: Date.now() + durationMs } });
+        toastTimer = setTimeout(() => {
+            dispatch({ type: 'SET_TOAST', toast: null });
+        }, durationMs);
+    }
+    // Loading indicator for async operations
+    async function withOperation(description, fn) {
+        dispatch({ type: 'SET_OPERATION', operation: description });
+        doRender();
+        try {
+            return await fn();
+        }
+        finally {
+            dispatch({ type: 'SET_OPERATION', operation: null });
+            doRender();
+        }
+    }
     // Load first-login state
     const savedState = loadState();
     state.firstLogin = !savedState.hasOpenedDashboard;
@@ -84,13 +107,16 @@ async function launchDashboard() {
         // Load knowledge, members, billing, invite links, notifications in parallel
         const projectId = state.activeProjectId;
         if (projectId) {
+            let loadError = false;
             const [memResult, members, billing, inviteLinks, notifications] = await Promise.all([
-                api.listMemories(projectId, { limit: PAGE_SIZE, offset: 0 }).catch(() => null),
-                api.listMembers(projectId).catch(() => []),
-                api.getBilling(projectId).catch(() => null),
+                api.listMemories(projectId, { limit: PAGE_SIZE, offset: 0 }).catch(() => { loadError = true; return null; }),
+                api.listMembers(projectId).catch(() => { loadError = true; return []; }),
+                api.getBilling(projectId).catch(() => { loadError = true; return null; }),
                 api.listInviteLinks(projectId).catch(() => []),
                 api.listNotifications().catch(() => []),
             ]);
+            if (loadError)
+                showToast('Some data failed to load', 'error');
             if (memResult) {
                 dispatch({ type: 'SET_MEMORIES', memories: memResult.memories, total: memResult.total });
             }
@@ -157,19 +183,25 @@ async function launchDashboard() {
                 const sub = state.billing?.subscription;
                 if (!sub || sub.status !== 'active') {
                     try {
+                        showToast('Opening checkout...', 'info');
                         const checkout = await api.createCheckout(project.project_id);
                         if (checkout.checkout_url)
                             openBrowser(checkout.checkout_url);
                     }
-                    catch { }
+                    catch {
+                        showToast('Failed to open checkout', 'error');
+                    }
                 }
                 else {
                     try {
+                        showToast('Opening billing portal...', 'info');
                         const portal = await api.getPortalUrl(project.project_id);
                         if (portal.url)
                             openBrowser(portal.url);
                     }
-                    catch { }
+                    catch {
+                        showToast('Failed to open billing portal', 'error');
+                    }
                 }
             }
             return;
@@ -238,14 +270,24 @@ async function launchDashboard() {
                 // Confirmed — delete
                 const projectId = state.activeProjectId;
                 if (projectId) {
+                    let failures = 0;
+                    dispatch({ type: 'SET_OPERATION', operation: 'Removing memories' });
+                    doRender();
                     await Promise.all([...state.forgetSelected].map(async (id) => {
                         try {
                             await api.deleteMemory(projectId, id);
                             dispatch({ type: 'REMOVE_MEMORY', id });
                         }
-                        catch { }
+                        catch {
+                            failures++;
+                        }
                     }));
+                    dispatch({ type: 'SET_OPERATION', operation: null });
                     dispatch({ type: 'EXIT_FORGET' });
+                    if (failures > 0)
+                        showToast(`${failures} failed to remove`, 'error');
+                    else
+                        showToast('Removed', 'success');
                 }
             }
             else if (state.forgetConfirming && (key.name === 'escape' || (key.name === 'char' && key.char === 'n'))) {
@@ -399,8 +441,11 @@ async function launchDashboard() {
                         await api.cancelApproval(projectId, demoteApproval.id);
                         const approvals = await api.listApprovals(projectId);
                         dispatch({ type: 'SET_PENDING_APPROVALS', approvals });
+                        showToast('Approval cancelled', 'success');
+                    }
+                    catch {
+                        showToast('Failed to cancel approval', 'error');
                     }
-                    catch { }
                 }
                 return;
             }
@@ -439,22 +484,28 @@ async function launchDashboard() {
             const projectId = state.activeProjectId;
             if (projectId) {
                 try {
+                    showToast('Opening checkout...', 'info');
                     const checkout = await api.createCheckout(projectId);
                     if (checkout.checkout_url)
                         openBrowser(checkout.checkout_url);
                 }
-                catch { }
+                catch {
+                    showToast('Failed to open checkout', 'error');
+                }
             }
         }
         else if (key.name === 'char' && key.char === 'p') {
             const projectId = state.activeProjectId;
             if (projectId) {
                 try {
+                    showToast('Opening billing portal...', 'info');
                     const portal = await api.getPortalUrl(projectId);
                     if (portal.url)
                         openBrowser(portal.url);
                 }
-                catch { }
+                catch {
+                    showToast('Failed to open billing portal', 'error');
+                }
             }
         }
     }
@@ -484,8 +535,11 @@ async function launchDashboard() {
                         await api.cancelApproval(projectId, projectApproval.id);
                         const approvals = await api.listApprovals(projectId);
                         dispatch({ type: 'SET_PENDING_APPROVALS', approvals });
+                        showToast('Approval cancelled', 'success');
+                    }
+                    catch {
+                        showToast('Failed to cancel approval', 'error');
                     }
-                    catch { }
                 }
                 return;
             }
@@ -679,8 +733,11 @@ async function launchDashboard() {
                             await api.changeRole(projectId, modal.targetUserId, newRole);
                             const members = await api.listMembers(projectId);
                             dispatch({ type: 'SET_MEMBERS', members });
+                            showToast('Role updated', 'success');
+                        }
+                        catch {
+                            showToast('Failed to update role', 'error');
                         }
-                        catch { }
                     }
                 }
                 dispatch({ type: 'CLOSE_MODAL' });
@@ -694,20 +751,32 @@ async function launchDashboard() {
         switch (modal.kind) {
             case 'confirm-forget':
                 try {
-                    await api.deleteMemory(projectId, modal.memoryId);
-                    dispatch({ type: 'REMOVE_MEMORY', id: modal.memoryId });
+                    await withOperation('Removing memory', async () => {
+                        await api.deleteMemory(projectId, modal.memoryId);
+                        dispatch({ type: 'REMOVE_MEMORY', id: modal.memoryId });
+                    });
+                    showToast('Memory removed', 'success');
+                }
+                catch {
+                    showToast('Failed to remove memory', 'error');
+                    return;
                 }
-                catch { }
                 break;
             case 'confirm-forget-all':
             case 'confirm-clear': {
                 const project = (0, state_1.getActiveProject)(state);
                 if (project && modal.input === project.slug) {
                     try {
-                        await api.clearMemories(projectId);
-                        dispatch({ type: 'SET_MEMORIES', memories: [], total: 0 });
+                        await withOperation('Clearing memories', async () => {
+                            await api.clearMemories(projectId);
+                            dispatch({ type: 'SET_MEMORIES', memories: [], total: 0 });
+                        });
+                        showToast('All memories cleared', 'success');
+                    }
+                    catch {
+                        showToast('Failed to clear memories', 'error');
+                        return;
                     }
-                    catch { }
                 }
                 break;
             }
@@ -715,59 +784,72 @@ async function launchDashboard() {
                 const project = (0, state_1.getActiveProject)(state);
                 if (project && modal.input === project.slug) {
                     try {
-                        await api.deleteProject(projectId);
-                        const me = await api.me();
-                        dispatch({ type: 'SET_USER_DATA', me });
-                        dispatch({ type: 'SWITCH_TAB', tab: 'knowledge' });
-                        if (state.activeProjectId) {
-                            connectFeed(state.activeProjectId);
-                            await loadTabData();
-                        }
-                        else {
-                            dispatch({ type: 'SET_MEMORIES', memories: [], total: 0 });
-                            dispatch({ type: 'SET_MEMBERS', members: [] });
-                        }
+                        await withOperation('Deleting project', async () => {
+                            await api.deleteProject(projectId);
+                            const me = await api.me();
+                            dispatch({ type: 'SET_USER_DATA', me });
+                            dispatch({ type: 'SWITCH_TAB', tab: 'knowledge' });
+                            if (state.activeProjectId) {
+                                connectFeed(state.activeProjectId);
+                                await loadTabData();
+                            }
+                            else {
+                                dispatch({ type: 'SET_MEMORIES', memories: [], total: 0 });
+                                dispatch({ type: 'SET_MEMBERS', members: [] });
+                            }
+                        });
+                        showToast('Project deleted', 'success');
+                    }
+                    catch {
+                        showToast('Failed to delete project', 'error');
+                        return;
                     }
-                    catch { }
                 }
                 break;
             }
             case 'confirm-remove-member':
                 try {
-                    await api.removeMember(projectId, modal.userId);
-                    const members = await api.listMembers(projectId);
-                    dispatch({ type: 'SET_MEMBERS', members });
+                    await withOperation('Removing member', async () => {
+                        await api.removeMember(projectId, modal.userId);
+                        const members = await api.listMembers(projectId);
+                        dispatch({ type: 'SET_MEMBERS', members });
+                    });
+                    showToast('Member removed', 'success');
+                }
+                catch {
+                    showToast('Failed to remove member', 'error');
+                    return;
                 }
-                catch { }
                 break;
             case 'confirm-leave':
                 try {
-                    // If admin who initiated a pending approval is leaving, cancel it
-                    const leavingUserId = state.user.id;
-                    for (const approval of state.pendingApprovals) {
-                        // Check if this user initiated the approval (email match)
-                        const leavingEmail = state.user.email;
-                        if (approval.initiator_email === leavingEmail) {
-                            try {
-                                await api.cancelApproval(projectId, approval.id);
+                    await withOperation('Leaving project', async () => {
+                        const leavingUserId = state.user.id;
+                        for (const approval of state.pendingApprovals) {
+                            const leavingEmail = state.user.email;
+                            if (approval.initiator_email === leavingEmail) {
+                                await api.cancelApproval(projectId, approval.id).catch(() => { });
                             }
-                            catch { }
                         }
-                    }
-                    await api.removeMember(projectId, leavingUserId);
-                    const me = await api.me();
-                    dispatch({ type: 'SET_USER_DATA', me });
-                    dispatch({ type: 'SWITCH_TAB', tab: 'knowledge' });
-                    if (state.activeProjectId) {
-                        connectFeed(state.activeProjectId);
-                        await loadTabData();
-                    }
-                    else {
-                        dispatch({ type: 'SET_MEMORIES', memories: [], total: 0 });
-                        dispatch({ type: 'SET_MEMBERS', members: [] });
-                    }
+                        await api.removeMember(projectId, leavingUserId);
+                        const me = await api.me();
+                        dispatch({ type: 'SET_USER_DATA', me });
+                        dispatch({ type: 'SWITCH_TAB', tab: 'knowledge' });
+                        if (state.activeProjectId) {
+                            connectFeed(state.activeProjectId);
+                            await loadTabData();
+                        }
+                        else {
+                            dispatch({ type: 'SET_MEMORIES', memories: [], total: 0 });
+                            dispatch({ type: 'SET_MEMBERS', members: [] });
+                        }
+                    });
+                    showToast('Left project', 'success');
+                }
+                catch {
+                    showToast('Failed to leave project', 'error');
+                    return;
                 }
-                catch { }
                 break;
             case 'confirm-logout':
                 try {
@@ -778,6 +860,8 @@ async function launchDashboard() {
                     }
                 }
                 catch { }
+                // Brief delay for in-flight proxy requests
+                await new Promise((r) => setTimeout(r, 500));
                 cleanExit();
                 break;
             case 'rename': {
@@ -785,11 +869,17 @@ async function launchDashboard() {
                     break;
                 const slug = modal.input.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
                 try {
-                    await api.renameProject(projectId, modal.input, slug);
-                    const me = await api.me();
-                    dispatch({ type: 'SET_USER_DATA', me });
+                    await withOperation('Renaming', async () => {
+                        await api.renameProject(projectId, modal.input, slug);
+                        const me = await api.me();
+                        dispatch({ type: 'SET_USER_DATA', me });
+                    });
+                    showToast('Project renamed', 'success');
+                }
+                catch {
+                    showToast('Failed to rename', 'error');
+                    return;
                 }
-                catch { }
                 break;
             }
             case 'create-project': {
@@ -797,40 +887,64 @@ async function launchDashboard() {
                     break;
                 const slug = modal.input.toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '');
                 try {
-                    const project = await api.createProject(modal.input, slug);
-                    await api.switchProject(project.id);
-                    const me = await api.me();
-                    dispatch({ type: 'SET_USER_DATA', me });
-                    await loadTabData();
+                    await withOperation('Creating project', async () => {
+                        const project = await api.createProject(modal.input, slug);
+                        await api.switchProject(project.id);
+                        const me = await api.me();
+                        dispatch({ type: 'SET_USER_DATA', me });
+                        await loadTabData();
+                    });
+                    showToast('Project created', 'success');
+                }
+                catch {
+                    showToast('Failed to create project', 'error');
+                    return;
                 }
-                catch { }
                 break;
             }
             case 'initiate-consensus': {
                 try {
-                    await api.initiateApproval(projectId, modal.action, modal.targetUserId);
-                    const approvals = await api.listApprovals(projectId);
-                    dispatch({ type: 'SET_PENDING_APPROVALS', approvals });
+                    await withOperation('Initiating approval', async () => {
+                        await api.initiateApproval(projectId, modal.action, modal.targetUserId);
+                        const approvals = await api.listApprovals(projectId);
+                        dispatch({ type: 'SET_PENDING_APPROVALS', approvals });
+                    });
+                    showToast('Approval initiated', 'success');
+                }
+                catch {
+                    showToast('Failed to initiate approval', 'error');
+                    return;
                 }
-                catch { }
                 break;
             }
             case 'approve-action': {
                 try {
-                    await api.approveAction(projectId, modal.approvalId);
-                    const approvals = await api.listApprovals(projectId);
-                    dispatch({ type: 'SET_PENDING_APPROVALS', approvals });
+                    await withOperation('Approving', async () => {
+                        await api.approveAction(projectId, modal.approvalId);
+                        const approvals = await api.listApprovals(projectId);
+                        dispatch({ type: 'SET_PENDING_APPROVALS', approvals });
+                    });
+                    showToast('Approved', 'success');
+                }
+                catch {
+                    showToast('Failed to approve', 'error');
+                    return;
                 }
-                catch { }
                 break;
             }
             case 'confirm-regen-link': {
                 try {
-                    await api.regenerateInviteLink(projectId, modal.role);
-                    const links = await api.listInviteLinks(projectId);
-                    dispatch({ type: 'SET_INVITE_LINKS', links });
+                    await withOperation('Regenerating link', async () => {
+                        await api.regenerateInviteLink(projectId, modal.role);
+                        const links = await api.listInviteLinks(projectId);
+                        dispatch({ type: 'SET_INVITE_LINKS', links });
+                    });
+                    showToast('Link regenerated', 'success');
+                }
+                catch {
+                    showToast('Failed to regenerate link', 'error');
+                    return;
                 }
-                catch { }
                 break;
             }
         }
@@ -869,7 +983,9 @@ async function launchDashboard() {
                 }
             }
         }
-        catch { }
+        catch {
+            showToast('Failed to load data', 'error');
+        }
     }
     async function loadMoreMemories() {
         const projectId = state.activeProjectId;
@@ -880,7 +996,10 @@ async function launchDashboard() {
             const result = await api.listMemories(projectId, { limit: PAGE_SIZE, offset: state.memories.length });
             dispatch({ type: 'SET_MEMORIES', memories: result.memories, total: result.total, append: true });
         }
-        catch { }
+        catch {
+            showToast('Failed to load more', 'error');
+            dispatch({ type: 'SET_LOADING', loading: false });
+        }
     }
     async function executeSearch() {
         const projectId = state.activeProjectId;
@@ -891,63 +1010,88 @@ async function launchDashboard() {
             const result = await api.searchMemories(projectId, state.searchQuery);
             dispatch({ type: 'SET_SEARCH_RESULTS', results: result.memories });
         }
-        catch { }
+        catch {
+            showToast('Search failed', 'error');
+        }
         dispatch({ type: 'SET_SEARCHING', searching: false });
     }
     // ------ SSE feed ------
     function connectFeed(projectId) {
         if (feedDisconnect)
             feedDisconnect();
-        const conn = api.connectFeed(projectId, (eventType, data) => {
-            if (eventType === 'memory') {
-                const event = data;
-                if (event.operation === 'create') {
-                    dispatch({ type: 'ADD_MEMORY', memory: { id: event.id, body: event.body, updated_at: event.updated_at } });
-                    dispatch({ type: 'SET_LIVE_DOT', memoryId: event.id });
-                    if (liveDotTimer)
-                        clearTimeout(liveDotTimer);
-                    liveDotTimer = setTimeout(() => {
-                        dispatch({ type: 'CLEAR_LIVE_DOT' });
-                    }, 10000);
+        const conn = api.connectFeed(projectId, {
+            onEvent: (eventType, data) => {
+                if (eventType === 'memory') {
+                    const event = data;
+                    if (event.operation === 'create') {
+                        dispatch({ type: 'ADD_MEMORY', memory: { id: event.id, body: event.body, updated_at: event.updated_at } });
+                        dispatch({ type: 'SET_LIVE_DOT', memoryId: event.id });
+                        if (liveDotTimer)
+                            clearTimeout(liveDotTimer);
+                        liveDotTimer = setTimeout(() => {
+                            dispatch({ type: 'CLEAR_LIVE_DOT' });
+                        }, 10000);
+                    }
+                    else if (event.operation === 'update') {
+                        const updated = { id: event.id, body: event.body, updated_at: event.updated_at };
+                        state = {
+                            ...state,
+                            memories: state.memories.map(m => m.id === event.id ? updated : m),
+                            searchResults: state.searchResults?.map(m => m.id === event.id ? updated : m) ?? null,
+                        };
+                        dispatch({ type: 'SET_LIVE_DOT', memoryId: event.id });
+                        if (liveDotTimer)
+                            clearTimeout(liveDotTimer);
+                        liveDotTimer = setTimeout(() => {
+                            dispatch({ type: 'CLEAR_LIVE_DOT' });
+                        }, 10000);
+                    }
                 }
-                else if (event.operation === 'update') {
-                    // Update the memory in place
-                    const updated = { id: event.id, body: event.body, updated_at: event.updated_at };
-                    state = {
-                        ...state,
-                        memories: state.memories.map(m => m.id === event.id ? updated : m),
-                        searchResults: state.searchResults?.map(m => m.id === event.id ? updated : m) ?? null,
-                    };
-                    dispatch({ type: 'SET_LIVE_DOT', memoryId: event.id });
-                    if (liveDotTimer)
-                        clearTimeout(liveDotTimer);
-                    liveDotTimer = setTimeout(() => {
-                        dispatch({ type: 'CLEAR_LIVE_DOT' });
-                    }, 10000);
+                else if (eventType === 'role_change') {
+                    api.me().then(me => {
+                        dispatch({ type: 'SET_USER_DATA', me });
+                    }).catch(() => {
+                        if (Date.now() - lastSyncErrorAt > 30000) {
+                            lastSyncErrorAt = Date.now();
+                            showToast('Sync error', 'error');
+                        }
+                    });
                 }
-            }
-            else if (eventType === 'role_change') {
-                // Role changed for the current user — refresh user data
-                api.me().then(me => {
-                    dispatch({ type: 'SET_USER_DATA', me });
-                }).catch(() => { });
-            }
-            else if (eventType === 'approval') {
-                // Approval state changed — refresh approvals
-                api.listApprovals(projectId).then(approvals => {
-                    dispatch({ type: 'SET_PENDING_APPROVALS', approvals });
-                }).catch(() => { });
-            }
-            else if (eventType === 'notification') {
-                // New notification — refresh notifications
-                api.listNotifications().then(notifications => {
-                    dispatch({ type: 'SET_NOTIFICATIONS', notifications });
-                    api.markNotificationsSeen().catch(() => { });
+                else if (eventType === 'approval') {
+                    api.listApprovals(projectId).then(approvals => {
+                        dispatch({ type: 'SET_PENDING_APPROVALS', approvals });
+                    }).catch(() => {
+                        if (Date.now() - lastSyncErrorAt > 30000) {
+                            lastSyncErrorAt = Date.now();
+                            showToast('Sync error', 'error');
+                        }
+                    });
+                }
+                else if (eventType === 'notification') {
+                    api.listNotifications().then(notifications => {
+                        dispatch({ type: 'SET_NOTIFICATIONS', notifications });
+                        api.markNotificationsSeen().catch(() => { });
+                    }).catch(() => {
+                        if (Date.now() - lastSyncErrorAt > 30000) {
+                            lastSyncErrorAt = Date.now();
+                            showToast('Sync error', 'error');
+                        }
+                    });
+                }
+            },
+            onConnected: () => {
+                dispatch({ type: 'SET_SSE_CONNECTED', connected: true });
+                // Refresh memories on reconnect to catch anything missed
+                api.listMemories(projectId, { limit: PAGE_SIZE, offset: 0 }).then(result => {
+                    if (result)
+                        dispatch({ type: 'SET_MEMORIES', memories: result.memories, total: result.total });
                 }).catch(() => { });
-            }
+            },
+            onDisconnected: () => {
+                dispatch({ type: 'SET_SSE_CONNECTED', connected: false });
+            },
         });
         feedDisconnect = conn.disconnect;
-        dispatch({ type: 'SET_SSE_CONNECTED', connected: true });
     }
     // ------ File watchers for MCP config changes ------
     function setupFileWatchers() {