cohvu 2.12.9 → 2.14.0

package/dist/tui/App.js

@@ -18,7 +18,9 @@ import { KnowledgeTab } from './tabs/KnowledgeTab.js';
 import { TeamTab } from './tabs/TeamTab.js';
 import { BillingTab } from './tabs/BillingTab.js';
 import { ProjectTab } from './tabs/ProjectTab.js';
+import { KeysTab } from './tabs/KeysTab.js';
 import { YouTab } from './tabs/YouTab.js';
+import { KNOWN_TOOL_NAMES } from './state.js';
 import { daysUntil, timeUntil } from './utils.js';
 import { exec, execFile } from 'child_process';
 import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync, watch } from 'fs';
@@ -219,6 +221,29 @@ export default function App() {
                     }
                     break;
                 }
+                case 'project': {
+                    // Linked siblings (explicit + same-team computed at query time)
+                    const links = await api.listProjectLinks(projectId).catch(() => []);
+                    if (stateRef.current.activeProjectId !== projectId)
+                        break;
+                    dispatch({ type: 'SET_PROJECT_LINKS', links });
+                    break;
+                }
+                case 'keys': {
+                    dispatch({ type: 'SET_API_KEYS_LOADING', loading: true });
+                    // Session keys are user-scoped (no project filter). Integration keys
+                    // require admin on the active project — skip the call if not, since
+                    // the API will 403 anyway and we'd rather not show a toast for that.
+                    const sessionPromise = api.listSessionKeys().catch(() => []);
+                    const integrationPromise = (s.userRole === 'admin')
+                        ? api.listIntegrationKeys(projectId).catch(() => [])
+                        : Promise.resolve([]);
+                    const [sessionKeys, integrationKeys] = await Promise.all([sessionPromise, integrationPromise]);
+                    if (stateRef.current.activeProjectId !== projectId)
+                        break;
+                    dispatch({ type: 'SET_API_KEYS', keys: [...sessionKeys, ...integrationKeys] });
+                    break;
+                }
             }
         }
         catch {
@@ -501,7 +526,7 @@ export default function App() {
         }
         // Number keys switch tabs (but not when typing in search mode)
         const tabIdx = parseInt(input, 10);
-        if (tabIdx >= 1 && tabIdx <= 5 && !key.ctrl && !key.meta && !(s.tab === 'knowledge' && s.knowledgeMode !== 'browse')) {
+        if (tabIdx >= 1 && tabIdx <= TABS.length && !key.ctrl && !key.meta && !(s.tab === 'knowledge' && s.knowledgeMode !== 'browse')) {
             dispatch({ type: 'SWITCH_TAB', tab: TABS[tabIdx - 1] });
             setTimeout(() => loadTabData(), 0);
             return;
@@ -525,11 +550,38 @@ export default function App() {
             case 'project':
                 await handleProjectKey(input, key);
                 break;
+            case 'keys':
+                await handleKeysKey(input, key);
+                break;
             case 'you':
                 await handleYouKey(input, key);
                 break;
         }
     }
+    // ---- Keys tab keys ----
+    async function handleKeysKey(input, key) {
+        const s = stateRef.current;
+        if (key.upArrow) {
+            dispatch({ type: 'SET_API_KEYS_SELECTED', index: Math.max(0, s.apiKeysSelected - 1) });
+            return;
+        }
+        if (key.downArrow) {
+            const max = Math.max(0, s.apiKeys.length - 1);
+            dispatch({ type: 'SET_API_KEYS_SELECTED', index: Math.min(max, s.apiKeysSelected + 1) });
+            return;
+        }
+        if (input === 'n') {
+            dispatch({ type: 'OPEN_MODAL', modal: { kind: 'select-key-kind', selected: 0 } });
+            return;
+        }
+        if (input === 'x' && s.apiKeys.length > 0) {
+            const target = s.apiKeys[s.apiKeysSelected];
+            if (target) {
+                dispatch({ type: 'OPEN_MODAL', modal: { kind: 'confirm-revoke-key', keyId: target.id, keyName: target.name } });
+            }
+            return;
+        }
+    }
     // ---- Knowledge keys ----
     async function handleKnowledgeKey(input, key) {
         const s = stateRef.current;
@@ -579,7 +631,7 @@ export default function App() {
                 const projectId = s.activeProjectId;
                 if (projectId) {
                     let failures = 0;
-                    dispatch({ type: 'SET_OPERATION', operation: 'Removing memories' });
+                    dispatch({ type: 'SET_OPERATION', operation: 'Removing contributions' });
                     await Promise.all([...s.forgetSelected].map(async (id) => {
                         try {
                             await api.deleteMemory(projectId, id);
@@ -838,7 +890,7 @@ export default function App() {
         }
     }
     // ---- Project keys ----
-    async function handleProjectKey(input, _key) {
+    async function handleProjectKey(input, key) {
         const s = stateRef.current;
         if (input === 't') {
             dispatch({ type: 'OPEN_MODAL', modal: { kind: 'create-team', input: '' } });
@@ -863,6 +915,30 @@ export default function App() {
             if (project)
                 dispatch({ type: 'OPEN_MODAL', modal: { kind: 'confirm-delete', slug: project.slug, memoryCount: s.memoryTotal, input: '' } });
         }
+        else if (input === 'L' && s.userRole === 'admin') {
+            // Open link picker — only meaningful if there are other admin projects
+            const candidates = adminScopableProjects(s).filter(p => p.project_id !== s.activeProjectId);
+            if (candidates.length === 0) {
+                showInlineError('no other projects you admin', 2000);
+                return;
+            }
+            dispatch({ type: 'OPEN_MODAL', modal: { kind: 'link-project', selected: 0 } });
+        }
+        else if (input === 'U' && s.userRole === 'admin') {
+            const link = s.projectLinks[s.projectLinkSelected];
+            if (link && link.source === 'explicit') {
+                dispatch({ type: 'OPEN_MODAL', modal: { kind: 'confirm-unlink-project', otherProjectId: link.project_id, otherSlug: link.slug } });
+            }
+            else if (link && link.source === 'team') {
+                showInlineError('team siblings are auto-linked — cannot unlink', 2000);
+            }
+        }
+        else if (key.upArrow && s.projectLinks.length > 0) {
+            dispatch({ type: 'SET_PROJECT_LINK_SELECTED', index: Math.max(0, s.projectLinkSelected - 1) });
+        }
+        else if (key.downArrow && s.projectLinks.length > 0) {
+            dispatch({ type: 'SET_PROJECT_LINK_SELECTED', index: Math.min(s.projectLinks.length - 1, s.projectLinkSelected + 1) });
+        }
     }
     // ---- You keys ----
     async function handleYouKey(input, _key) {
@@ -955,7 +1031,8 @@ export default function App() {
         if (modal.kind === 'confirm-forget' || modal.kind === 'confirm-remove-member' ||
             modal.kind === 'confirm-leave' || modal.kind === 'confirm-logout' ||
             modal.kind === 'confirm-regen-link' || modal.kind === 'initiate-consensus' ||
-            modal.kind === 'approve-action') {
+            modal.kind === 'approve-action' || modal.kind === 'confirm-revoke-key' ||
+            modal.kind === 'confirm-unlink-project') {
             if (input === 'y') {
                 const willExit = modal.kind === 'confirm-logout';
                 await confirmModal(modal);
@@ -967,6 +1044,179 @@ export default function App() {
             }
             return;
         }
+        // Select key kind (session vs integration)
+        if (modal.kind === 'select-key-kind') {
+            if (key.upArrow) {
+                dispatch({ type: 'OPEN_MODAL', modal: { ...modal, selected: Math.max(0, modal.selected - 1) } });
+            }
+            else if (key.downArrow) {
+                dispatch({ type: 'OPEN_MODAL', modal: { ...modal, selected: Math.min(1, modal.selected + 1) } });
+            }
+            else if (key.return) {
+                if (modal.selected === 0) {
+                    dispatch({ type: 'OPEN_MODAL', modal: { kind: 'create-session-key', input: '' } });
+                }
+                else {
+                    // Pre-select the active project for convenience
+                    const adminProjects = adminScopableProjects(s);
+                    const activeIdx = Math.max(0, adminProjects.findIndex(p => p.project_id === s.activeProjectId));
+                    const project = adminProjects[activeIdx];
+                    dispatch({ type: 'OPEN_MODAL', modal: {
+                            kind: 'create-integration-key',
+                            step: 'name',
+                            input: '',
+                            projectId: project?.project_id ?? null,
+                            projectSelectedIdx: activeIdx,
+                            role: 'member',
+                            roleSelectedIdx: 1,
+                            allowedTools: [],
+                            toolsSelectedIdx: 0,
+                            agentName: '',
+                        } });
+                }
+            }
+            return;
+        }
+        // Integration key creation wizard
+        if (modal.kind === 'create-integration-key') {
+            const adminProjects = adminScopableProjects(s);
+            if (modal.step === 'name') {
+                if (key.return && modal.input.trim().length > 0) {
+                    if (adminProjects.length === 0) {
+                        showInlineError('no projects you can scope an integration key to', 3000);
+                        return;
+                    }
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, step: 'project' } });
+                }
+                else if (key.backspace || key.delete) {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, input: modal.input.slice(0, -1) } });
+                }
+                else if (input === ' ') {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, input: modal.input + ' ' } });
+                }
+                else if (input.length === 1 && !key.ctrl && !key.meta) {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, input: modal.input + input } });
+                }
+                return;
+            }
+            if (modal.step === 'project') {
+                if (adminProjects.length === 0)
+                    return;
+                if (key.upArrow) {
+                    const i = Math.max(0, modal.projectSelectedIdx - 1);
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, projectSelectedIdx: i, projectId: adminProjects[i].project_id } });
+                }
+                else if (key.downArrow) {
+                    const i = Math.min(adminProjects.length - 1, modal.projectSelectedIdx + 1);
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, projectSelectedIdx: i, projectId: adminProjects[i].project_id } });
+                }
+                else if (key.return && modal.projectId) {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, step: 'role' } });
+                }
+                return;
+            }
+            if (modal.step === 'role') {
+                const roles = ['admin', 'member', 'viewer'];
+                if (key.upArrow) {
+                    const i = Math.max(0, modal.roleSelectedIdx - 1);
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, roleSelectedIdx: i, role: roles[i] } });
+                }
+                else if (key.downArrow) {
+                    const i = Math.min(2, modal.roleSelectedIdx + 1);
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, roleSelectedIdx: i, role: roles[i] } });
+                }
+                else if (key.return) {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, step: 'tools' } });
+                }
+                return;
+            }
+            if (modal.step === 'tools') {
+                if (key.upArrow) {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, toolsSelectedIdx: Math.max(0, modal.toolsSelectedIdx - 1) } });
+                }
+                else if (key.downArrow) {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, toolsSelectedIdx: Math.min(KNOWN_TOOL_NAMES.length - 1, modal.toolsSelectedIdx + 1) } });
+                }
+                else if (input === ' ') {
+                    const t = KNOWN_TOOL_NAMES[modal.toolsSelectedIdx];
+                    const next = modal.allowedTools.includes(t)
+                        ? modal.allowedTools.filter(x => x !== t)
+                        : [...modal.allowedTools, t];
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, allowedTools: next } });
+                }
+                else if (key.return) {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, step: 'agent' } });
+                }
+                return;
+            }
+            if (modal.step === 'agent') {
+                if (key.return) {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, step: 'confirm' } });
+                }
+                else if (key.backspace || key.delete) {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, agentName: modal.agentName.slice(0, -1) } });
+                }
+                else if (input === ' ') {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, agentName: modal.agentName + ' ' } });
+                }
+                else if (input.length === 1 && !key.ctrl && !key.meta) {
+                    dispatch({ type: 'OPEN_MODAL', modal: { ...modal, agentName: modal.agentName + input } });
+                }
+                return;
+            }
+            if (modal.step === 'confirm') {
+                if (input === 'y') {
+                    await confirmModal(modal);
+                    // confirmModal handles the modal transition (closes on error, opens key-created on success)
+                }
+                else if (input === 'n') {
+                    dispatch({ type: 'CLOSE_MODAL' });
+                }
+                return;
+            }
+            return;
+        }
+        // Link to another project — pick from candidates
+        if (modal.kind === 'link-project') {
+            const candidates = adminScopableProjects(s).filter(p => p.project_id !== s.activeProjectId);
+            if (key.upArrow) {
+                dispatch({ type: 'OPEN_MODAL', modal: { ...modal, selected: Math.max(0, modal.selected - 1) } });
+            }
+            else if (key.downArrow) {
+                dispatch({ type: 'OPEN_MODAL', modal: { ...modal, selected: Math.min(candidates.length - 1, modal.selected + 1) } });
+            }
+            else if (key.return) {
+                const target = candidates[modal.selected];
+                if (target && s.activeProjectId) {
+                    try {
+                        dispatch({ type: 'SET_OPERATION', operation: 'Linking project' });
+                        await api.linkProjects(s.activeProjectId, target.project_id);
+                        const links = await api.listProjectLinks(s.activeProjectId).catch(() => stateRef.current.projectLinks);
+                        dispatch({ type: 'SET_PROJECT_LINKS', links });
+                        dispatch({ type: 'SET_OPERATION', operation: null });
+                        dispatch({ type: 'CLOSE_MODAL' });
+                        showToast('Linked', 'success');
+                    }
+                    catch {
+                        dispatch({ type: 'SET_OPERATION', operation: null });
+                        dispatch({ type: 'CLOSE_MODAL' });
+                        showToast('Failed to link', 'error');
+                    }
+                }
+            }
+            return;
+        }
+        // Key created — copy or dismiss (esc handled at top)
+        if (modal.kind === 'key-created') {
+            if (input === 'c') {
+                copyToClipboard(modal.keyValue);
+                dispatch({ type: 'SET_COPIED_FEEDBACK', active: true });
+                if (copiedTimerRef.current)
+                    clearTimeout(copiedTimerRef.current);
+                copiedTimerRef.current = setTimeout(() => dispatch({ type: 'SET_COPIED_FEEDBACK', active: false }), 1500);
+            }
+            return;
+        }
         // Text input modals
         if ('input' in modal) {
             if (key.return) {
@@ -1338,6 +1588,101 @@ export default function App() {
             }
             return false;
         }
+        if (modal.kind === 'create-session-key') {
+            if (!modal.input.trim())
+                return false;
+            try {
+                dispatch({ type: 'SET_OPERATION', operation: 'Creating key' });
+                const result = await api.createApiKey({ kind: 'session', name: modal.input.trim() });
+                dispatch({ type: 'SET_OPERATION', operation: null });
+                // Refresh list, then transition modal so the secret is shown once.
+                const sessionKeys = await api.listSessionKeys().catch(() => []);
+                const integrationKeys = stateRef.current.userRole === 'admin' && stateRef.current.activeProjectId
+                    ? await api.listIntegrationKeys(stateRef.current.activeProjectId).catch(() => [])
+                    : [];
+                dispatch({ type: 'SET_API_KEYS', keys: [...sessionKeys, ...integrationKeys] });
+                dispatch({ type: 'OPEN_MODAL', modal: {
+                        kind: 'key-created',
+                        keyId: result.api_key.id,
+                        keyValue: result.key,
+                        keyName: result.api_key.name,
+                        kind2: 'session',
+                    } });
+                return true; // chained — caller must not CLOSE_MODAL
+            }
+            catch {
+                dispatch({ type: 'SET_OPERATION', operation: null });
+                showToast('Failed to create key', 'error');
+            }
+            return false;
+        }
+        if (modal.kind === 'create-integration-key') {
+            // Only the confirm step submits — earlier steps just advance via OPEN_MODAL.
+            if (modal.step !== 'confirm')
+                return false;
+            if (!modal.input.trim() || !modal.projectId)
+                return false;
+            try {
+                dispatch({ type: 'SET_OPERATION', operation: 'Creating key' });
+                const result = await api.createApiKey({
+                    kind: 'integration',
+                    name: modal.input.trim(),
+                    projects: [{ project_id: modal.projectId, role: modal.role }],
+                    ...(modal.allowedTools.length > 0 ? { allowed_tools: modal.allowedTools } : {}),
+                    ...(modal.agentName.trim() ? { default_agent_name: modal.agentName.trim() } : {}),
+                });
+                dispatch({ type: 'SET_OPERATION', operation: null });
+                const sessionKeys = await api.listSessionKeys().catch(() => []);
+                const integrationKeys = stateRef.current.userRole === 'admin' && stateRef.current.activeProjectId
+                    ? await api.listIntegrationKeys(stateRef.current.activeProjectId).catch(() => [])
+                    : [];
+                dispatch({ type: 'SET_API_KEYS', keys: [...sessionKeys, ...integrationKeys] });
+                dispatch({ type: 'OPEN_MODAL', modal: {
+                        kind: 'key-created',
+                        keyId: result.api_key.id,
+                        keyValue: result.key,
+                        keyName: result.api_key.name,
+                        kind2: 'integration',
+                    } });
+                return true;
+            }
+            catch {
+                dispatch({ type: 'SET_OPERATION', operation: null });
+                showToast('Failed to create key', 'error');
+            }
+            return false;
+        }
+        if (modal.kind === 'confirm-revoke-key') {
+            try {
+                dispatch({ type: 'SET_OPERATION', operation: 'Revoking key' });
+                await api.deleteApiKey(modal.keyId);
+                dispatch({ type: 'REMOVE_API_KEY', id: modal.keyId });
+                dispatch({ type: 'SET_OPERATION', operation: null });
+                showToast('Key revoked', 'success');
+            }
+            catch {
+                dispatch({ type: 'SET_OPERATION', operation: null });
+                showToast('Failed to revoke key', 'error');
+            }
+            return false;
+        }
+        if (modal.kind === 'confirm-unlink-project') {
+            const projectId = stateRef.current.activeProjectId;
+            if (!projectId)
+                return false;
+            try {
+                dispatch({ type: 'SET_OPERATION', operation: 'Unlinking' });
+                await api.unlinkProjects(projectId, modal.otherProjectId);
+                dispatch({ type: 'REMOVE_PROJECT_LINK', otherProjectId: modal.otherProjectId });
+                dispatch({ type: 'SET_OPERATION', operation: null });
+                showToast('Unlinked', 'success');
+            }
+            catch {
+                dispatch({ type: 'SET_OPERATION', operation: null });
+                showToast('Failed to unlink', 'error');
+            }
+            return false;
+        }
         const projectId = s.activeProjectId;
         if (!projectId)
             return false;
@@ -1365,15 +1710,15 @@ export default function App() {
             }
             case 'confirm-forget':
                 try {
-                    dispatch({ type: 'SET_OPERATION', operation: 'Removing memory' });
+                    dispatch({ type: 'SET_OPERATION', operation: 'Removing contribution' });
                     await api.deleteMemory(projectId, modal.memoryId);
                     dispatch({ type: 'REMOVE_MEMORY', id: modal.memoryId });
                     dispatch({ type: 'SET_OPERATION', operation: null });
-                    showToast('Memory removed', 'success');
+                    showToast('Contribution removed', 'success');
                 }
                 catch {
                     dispatch({ type: 'SET_OPERATION', operation: null });
-                    showToast('Failed to remove memory', 'error');
+                    showToast('Failed to remove contribution', 'error');
                 }
                 break;
             case 'confirm-forget-all':
@@ -1384,7 +1729,7 @@ export default function App() {
                         const team = getActiveTeam(s);
                         if (team) {
                             try {
-                                await api.initiateApproval(team.team_id, 'clear_memories', `clear all memories from "${project.slug}"`, projectId);
+                                await api.initiateApproval(team.team_id, 'clear_memories', `clear all contributions from "${project.slug}"`, projectId);
                                 const approvals = await api.listApprovals(team.team_id);
                                 dispatch({ type: 'SET_PENDING_APPROVALS', approvals });
                                 showToast('Approval requested', 'info');
@@ -1396,15 +1741,15 @@ export default function App() {
                         }
                     }
                     try {
-                        dispatch({ type: 'SET_OPERATION', operation: 'Clearing memories' });
+                        dispatch({ type: 'SET_OPERATION', operation: 'Clearing contributions' });
                         await api.clearMemories(projectId);
                         dispatch({ type: 'SET_MEMORIES', memories: [], total: 0 });
                         dispatch({ type: 'SET_OPERATION', operation: null });
-                        showToast('All memories cleared', 'success');
+                        showToast('All contributions cleared', 'success');
                     }
                     catch {
                         dispatch({ type: 'SET_OPERATION', operation: null });
-                        showToast('Failed to clear memories', 'error');
+                        showToast('Failed to clear contributions', 'error');
                     }
                 }
                 break;
@@ -1641,19 +1986,31 @@ function renderTab(state, height) {
         case 'team': return _jsx(TeamTab, { state: state, height: height });
         case 'billing': return _jsx(BillingTab, { state: state, height: height });
         case 'project': return _jsx(ProjectTab, { state: state, height: height });
+        case 'keys': return _jsx(KeysTab, { state: state, height: height });
         case 'you': return _jsx(YouTab, { state: state, height: height });
     }
 }
+// Projects the caller can scope an integration key to. Personal projects are
+// always scopable by their owner; team projects only by team admins.
+function adminScopableProjects(s) {
+    return s.projects.filter(p => {
+        if (p.owner.kind === 'personal')
+            return true; // user owns it
+        const teamId = p.owner.teamId;
+        const team = s.teams.find(t => t.team_id === teamId);
+        return team?.role === 'admin';
+    });
+}
 function HelpOverlay({ state }) {
     const lines = [
-        ['tab / 1-5', 'switch tabs'],
+        ['tab / 1-6', 'switch tabs'],
         ['?', 'toggle this help'],
         ['q', 'quit'],
         ['', ''],
     ];
     switch (state.tab) {
         case 'knowledge':
-            lines.push(['/', 'search'], ['enter', 'expand memory'], ['↑↓', 'navigate'], ['space', 'load more'], ['d', 'forget mode'], ['D', 'forget all (admin)']);
+            lines.push(['/', 'search'], ['enter', 'expand contribution'], ['↑↓', 'navigate'], ['space', 'load more'], ['d', 'forget mode'], ['D', 'forget all (admin)']);
             break;
         case 'team':
             lines.push(['↑↓', 'navigate'], ['i', 'invite'], ['e', 'edit role (admin)'], ['x', 'remove member'], ['c', 'copy invite link'], ['r', 'regenerate link']);
@@ -1662,7 +2019,10 @@ function HelpOverlay({ state }) {
             lines.push(['s', 'subscribe'], ['p', 'billing portal']);
             break;
         case 'project':
-            lines.push(['w', 'switch project'], ['n', 'new project'], ['t', 'new team'], ['r', 'rename'], ['c', 'clear knowledge'], ['d', 'delete project']);
+            lines.push(['↑↓', 'navigate links'], ['w', 'switch project'], ['n', 'new project'], ['t', 'new team'], ['r', 'rename'], ['L', 'link to another project (admin)'], ['U', 'unlink selected (admin, explicit only)'], ['c', 'clear knowledge'], ['d', 'delete project']);
+            break;
+        case 'keys':
+            lines.push(['↑↓', 'navigate'], ['n', 'new key'], ['x', 'revoke selected']);
             break;
         case 'you':
             lines.push(['p', 'pause / resume'], ['r', 're-run setup'], ['l', 'logout']);