/** * Team routes for the local server. * * These routes handle team server connection from the desktop app: * - POST /api/team/connect — connect to team server (validate token, store config) * - POST /api/team/disconnect — disconnect from team server * - GET /api/team/status — get current team connection status */ import path from 'node:path'; import crypto from 'node:crypto'; import type { FastifyInstance } from 'fastify'; import Database from 'better-sqlite3'; import { WaggleConfig } from '@waggle/core'; import { allowLocalFromEnv, safeFetch } from '@waggle/agent'; import { emitNotification } from './notifications.js'; import { emitAuditEvent } from './events.js'; // ── Local team DB ──────────────────────────────────────────────────── type TeamRole = 'owner' | 'admin' | 'member' | 'viewer'; interface TeamRow { id: string; name: string; description: string; owner_id: string; created: string; updated: string; } interface MemberRow { team_id: string; user_id: string; role: TeamRole; display_name: string; email: string | null; joined: string; } let teamsDb: Database.Database | null = null; function getTeamsDb(dataDir: string): Database.Database { if (teamsDb) return teamsDb; const dbPath = path.join(dataDir, 'teams.db'); teamsDb = new Database(dbPath); teamsDb.pragma('journal_mode = WAL'); teamsDb.pragma('synchronous = NORMAL'); teamsDb.exec(` CREATE TABLE IF NOT EXISTS teams ( id TEXT PRIMARY KEY, name TEXT NOT NULL, description TEXT NOT NULL DEFAULT '', owner_id TEXT NOT NULL, created TEXT NOT NULL DEFAULT (datetime('now')), updated TEXT NOT NULL DEFAULT (datetime('now')) ); CREATE TABLE IF NOT EXISTS team_members ( team_id TEXT NOT NULL, user_id TEXT NOT NULL, role TEXT NOT NULL DEFAULT 'member' CHECK (role IN ('owner', 'admin', 'member', 'viewer')), display_name TEXT NOT NULL DEFAULT '', email TEXT, joined TEXT NOT NULL DEFAULT (datetime('now')), PRIMARY KEY (team_id, user_id), FOREIGN KEY (team_id) REFERENCES teams(id) ON DELETE CASCADE ); CREATE INDEX IF NOT EXISTS idx_team_members_user ON team_members (user_id); `); return teamsDb; } export function closeTeamsDb(): void { if (teamsDb) { try { teamsDb.close(); } catch { /* ignore */ } teamsDb = null; } } function getLocalUserId(dataDir: string): string { try { const waggleConfig = new WaggleConfig(dataDir); const teamServer = waggleConfig.getTeamServer(); if (teamServer?.userId && teamServer.userId !== 'unknown') return teamServer.userId; } catch { /* ignore */ } return 'local-user'; } function getLocalDisplayName(dataDir: string): string { try { const waggleConfig = new WaggleConfig(dataDir); const teamServer = waggleConfig.getTeamServer(); if (teamServer?.displayName) return teamServer.displayName; } catch { /* ignore */ } return 'You'; } function hasAllowedTeamServerProtocol(url: URL, allowLocal: boolean): boolean { const hostname = url.hostname.toLowerCase().replace(/^\[|\]$/g, ''); const isExplicitLoopback = hostname === 'localhost' || hostname.endsWith('.localhost') || hostname === '::1' || /^127(?:\.\d{1,3}){3}$/.test(hostname); return url.protocol === 'https:' || (url.protocol === 'http:' && allowLocal && isExplicitLoopback); } function normalizeTeamServerBaseUrl(value: string, allowLocal: boolean): string | null { try { const url = new URL(value); if (url.username || url.password || url.search || url.hash) return null; if (!hasAllowedTeamServerProtocol(url, allowLocal)) return null; return `${url.origin}${url.pathname.replace(/\/+$/, '')}`; } catch { return null; } } function fetchTeamServer(url: string, init: RequestInit = {}): Promise { const parsed = new URL(url); if (parsed.username || parsed.password || parsed.hash || !hasAllowedTeamServerProtocol(parsed, allowLocalFromEnv())) { return Promise.reject(new Error('Blocked insecure Team server URL')); } return safeFetch(url, init, { allowLocal: allowLocalFromEnv(), maxRedirects: 0, }); } export async function teamRoutes(fastify: FastifyInstance) { const dataDir = fastify.localConfig.dataDir; /** * POST /api/team/connect * Connect to a team server by validating the token against the server's health endpoint. */ fastify.post('/api/team/connect', async (request, reply) => { const { serverUrl, token } = request.body as { serverUrl: string; token: string }; if (!serverUrl || !token) { return reply.code(400).send({ error: 'serverUrl and token are required' }); } const normalizedServerUrl = normalizeTeamServerBaseUrl(serverUrl, allowLocalFromEnv()); if (!normalizedServerUrl) { return reply.code(400).send({ error: 'Team server URL must use HTTPS; HTTP is allowed only for explicitly enabled loopback servers', }); } // Validate by calling the team server health endpoint try { const healthUrl = `${normalizedServerUrl}/health`; const healthRes = await fetchTeamServer(healthUrl, { headers: { 'Authorization': `Bearer ${token}` }, signal: AbortSignal.timeout(5000), }); if (!healthRes.ok) { return reply.code(502).send({ error: `Team server returned ${healthRes.status}` }); } } catch (err: unknown) { const name = err instanceof Error ? err.name : ''; if (name === 'TimeoutError' || name === 'AbortError') { return reply.code(504).send({ error: 'Team server connection timed out' }); } const message = err instanceof Error ? err.message : String(err); return reply.code(502).send({ error: `Cannot reach team server: ${message}` }); } // Try to get user info from the team server let userId = 'unknown'; let displayName = 'Unknown User'; try { const teamsRes = await fetchTeamServer(`${normalizedServerUrl}/api/teams`, { headers: { 'Authorization': `Bearer ${token}` }, signal: AbortSignal.timeout(5000), }); if (teamsRes.ok) { // Token is valid and user has access — extract from response is not possible without user endpoint // For now, we know the connection works userId = 'authenticated'; displayName = 'Team User'; } } catch { // Non-critical — connection itself was validated by health check } // Store team server config const waggleConfig = new WaggleConfig(dataDir); waggleConfig.setTeamServer({ url: normalizedServerUrl, token, userId, displayName, }); waggleConfig.save(); const connection = { serverUrl: normalizedServerUrl, token: '***', // Don't send token back userId, displayName, }; return reply.code(200).send(connection); }); /** * POST /api/team/disconnect * Disconnect from the team server. */ fastify.post('/api/team/disconnect', async (_request, reply) => { const waggleConfig = new WaggleConfig(dataDir); waggleConfig.clearTeamServer(); waggleConfig.save(); return reply.code(200).send({ disconnected: true }); }); /** * GET /api/team/teams * List teams the connected user belongs to (proxied from team server). */ fastify.get('/api/team/teams', async (_request, reply) => { const waggleConfig = new WaggleConfig(dataDir); const teamServer = waggleConfig.getTeamServer(); if (!teamServer || !teamServer.token) { return reply.code(401).send({ error: 'Not connected to a team server' }); } try { const teamsUrl = `${teamServer.url}/api/teams`; const res = await fetchTeamServer(teamsUrl, { headers: { 'Authorization': `Bearer ${teamServer.token}` }, signal: AbortSignal.timeout(5000), }); if (!res.ok) { return reply.code(res.status).send({ error: `Team server returned ${res.status}` }); } const teams = await res.json(); return reply.code(200).send(teams); } catch (err: unknown) { const name = err instanceof Error ? err.name : ''; if (name === 'TimeoutError' || name === 'AbortError') { return reply.code(504).send({ error: 'Team server request timed out' }); } const message = err instanceof Error ? err.message : String(err); return reply.code(502).send({ error: `Cannot reach team server: ${message}` }); } }); /** * GET /api/team/presence?workspaceId=X * Get team presence data for a workspace (proxied from team server, or mock if unavailable). */ fastify.get<{ Querystring: { workspaceId?: string }; }>('/api/team/presence', async (request, reply) => { const waggleConfig = new WaggleConfig(dataDir); const teamServer = waggleConfig.getTeamServer(); if (!teamServer || !teamServer.token) { return reply.code(200).send({ members: [] }); } // Try to fetch real presence from team server try { const presenceUrl = `${teamServer.url}/api/presence`; const res = await fetchTeamServer(presenceUrl, { headers: { 'Authorization': `Bearer ${teamServer.token}` }, signal: AbortSignal.timeout(3000), }); if (res.ok) { const data = await res.json(); // Emit presence update for WebSocket subscribers fastify.eventBus.emit('presence_update', data); return reply.code(200).send(data); } } catch { // Team server unavailable — return self as online (local-only fallback) } // Fallback: return current user as online const fallbackData = { members: [{ userId: teamServer.userId ?? 'self', displayName: teamServer.displayName ?? 'You', status: 'online', lastActivity: new Date().toISOString(), }], }; // Emit presence update for WebSocket subscribers fastify.eventBus.emit('presence_update', fallbackData); return reply.code(200).send(fallbackData); }); /** * GET /api/team/status * Get current team connection status. */ fastify.get('/api/team/status', async (_request, reply) => { const waggleConfig = new WaggleConfig(dataDir); const teamServer = waggleConfig.getTeamServer(); if (!teamServer) { return reply.code(200).send({ connected: false }); } return reply.code(200).send({ connected: true, serverUrl: teamServer.url, userId: teamServer.userId ?? 'unknown', displayName: teamServer.displayName ?? 'Team User', }); }); /** * GET /api/team/members * List team members. Proxies to team server or returns local user when disconnected. */ fastify.get('/api/team/members', async () => { const waggleConfig = new WaggleConfig(dataDir); const teamServer = waggleConfig.getTeamServer(); if (teamServer) { try { const res = await fetchTeamServer(`${teamServer.url}/api/team/members`, { headers: { Authorization: `Bearer ${teamServer.token}` }, signal: AbortSignal.timeout(3000), }); if (res.ok) return res.json(); } catch { /* fall through */ } } return { members: [{ id: 'local', name: 'You', status: 'online' }] }; }); /** * GET /api/team/activity?workspaceId=X&limit=N * Get recent team activity for a workspace. * Proxies to team server or returns empty when disconnected. */ fastify.get<{ Querystring: { workspaceId?: string; limit?: string }; }>('/api/team/activity', async (request, reply) => { const waggleConfig = new WaggleConfig(dataDir); const teamServer = waggleConfig.getTeamServer(); const limit = Math.min(parseInt(request.query.limit ?? '20', 10) || 20, 50); if (!teamServer || !teamServer.token) { return reply.code(200).send({ items: [] }); } // Try to fetch activity from team server's entities API // (synced frames = memory additions, which are our primary activity source) try { const workspaceId = request.query.workspaceId; const entitiesUrl = `${teamServer.url}/api/entities?type=memory_frame&limit=${limit}`; const res = await fetchTeamServer(entitiesUrl, { headers: { 'Authorization': `Bearer ${teamServer.token}` }, signal: AbortSignal.timeout(5000), }); if (res.ok) { const data = await res.json() as { entities?: Array<{ id: string; metadata?: { authorName?: string; authorId?: string; frameType?: string; content?: string }; createdAt?: string; }> }; const items = (data.entities ?? []).map((e) => ({ id: e.id, type: 'memory' as const, authorName: e.metadata?.authorName ?? 'Unknown', authorId: e.metadata?.authorId, summary: e.metadata?.content ? (e.metadata.content.length > 120 ? e.metadata.content.slice(0, 120) + '...' : e.metadata.content) : `Added ${e.metadata?.frameType ?? 'frame'}`, timestamp: e.createdAt ?? new Date().toISOString(), })); return reply.code(200).send({ items }); } } catch { // Team server unavailable — return empty } return reply.code(200).send({ items: [] }); }); /** * GET /api/team/messages?workspaceId=X&limit=N * Get recent Waggle Dance messages for a workspace. * Proxies to team server or returns empty when disconnected. */ fastify.get<{ Querystring: { workspaceId?: string; limit?: string }; }>('/api/team/messages', async (request, reply) => { const waggleConfig = new WaggleConfig(dataDir); const teamServer = waggleConfig.getTeamServer(); const limit = Math.min(parseInt(request.query.limit ?? '20', 10) || 20, 50); if (!teamServer || !teamServer.token) { return reply.code(200).send({ messages: [] }); } try { const teamSlug = (teamServer as { teamSlug?: string }).teamSlug ?? 'default'; const messagesUrl = `${teamServer.url}/api/teams/${teamSlug}/messages?limit=${limit}`; const res = await fetchTeamServer(messagesUrl, { headers: { 'Authorization': `Bearer ${teamServer.token}` }, signal: AbortSignal.timeout(5000), }); if (res.ok) { const data = await res.json() as { messages?: unknown[] } | unknown[]; const messages = (Array.isArray(data) ? data : data?.messages) ?? []; if (Array.isArray(messages) && messages.length > 0) { emitNotification(fastify, { title: 'Team message', body: 'New message from team', category: 'message', }); } return reply.code(200).send({ messages }); } } catch { // Team server unavailable — return empty } return reply.code(200).send({ messages: [] }); }); // --- Capability Governance Proxy --- // In-memory policy cache: teamId → { permissions, fetchedAt } const policyCache = new Map(); const CACHE_TTL_MS = 5 * 60 * 1000; // 5 minutes // Listen for policy update events to invalidate cache if (fastify.eventBus) { fastify.eventBus.on('capability_policy_update', (data: { teamId?: string } | undefined) => { if (data?.teamId) policyCache.delete(data.teamId); else policyCache.clear(); // Clear all if no specific teamId }); } // GET /api/team/governance/permissions — get effective permissions for current user fastify.get('/api/team/governance/permissions', async (request, reply) => { const { workspaceId } = request.query as { workspaceId?: string }; const waggleConfig = new WaggleConfig(dataDir); const teamServer = waggleConfig.getTeamServer(); if (!teamServer?.url || !teamServer?.token) { return { connected: false, permissions: null }; } // Check cache const cacheKey = workspaceId ?? 'default'; const cached = policyCache.get(cacheKey); if (cached && Date.now() - cached.fetchedAt < CACHE_TTL_MS) { return { connected: true, permissions: cached.permissions }; } try { const teamSlug = (teamServer as { teamSlug?: string }).teamSlug ?? 'default'; const url = `${teamServer.url.replace(/\/$/, '')}/api/teams/${teamSlug}/capability-policies`; const res = await fetchTeamServer(url, { headers: { 'Authorization': `Bearer ${teamServer.token}` }, signal: AbortSignal.timeout(5000), }); if (!res.ok) throw new Error(`${res.status}`); const policies = await res.json(); policyCache.set(cacheKey, { permissions: policies, fetchedAt: Date.now() }); return { connected: true, permissions: policies }; } catch { // Return cached if available, otherwise null if (cached) return { connected: true, permissions: cached.permissions, stale: true }; return { connected: true, permissions: null }; } }); // ═══════════════════════════════════════════════════════════════════ // F3: Local team entity CRUD — works in solo mode with local userId // ═══════════════════════════════════════════════════════════════════ const db = getTeamsDb(dataDir); const userId = getLocalUserId(dataDir); // POST /api/teams — create a team fastify.post<{ Body: { name: string; description?: string }; }>('/api/teams', async (request, reply) => { const { name, description } = request.body ?? {}; if (!name || typeof name !== 'string' || name.trim().length === 0) { return reply.code(400).send({ error: 'name is required' }); } const id = `team-${crypto.randomUUID().slice(0, 8)}`; const uid = getLocalUserId(dataDir); const displayName = getLocalDisplayName(dataDir); const now = new Date().toISOString(); db.prepare(` INSERT INTO teams (id, name, description, owner_id, created, updated) VALUES (?, ?, ?, ?, ?, ?) `).run(id, name.trim(), description?.trim() ?? '', uid, now, now); // Auto-add creator as owner member db.prepare(` INSERT INTO team_members (team_id, user_id, role, display_name, joined) VALUES (?, ?, 'owner', ?, ?) `).run(id, uid, displayName, now); emitAuditEvent(fastify, { workspaceId: 'global', eventType: 'workspace_create', input: JSON.stringify({ teamId: id, name }) }); const team = db.prepare('SELECT * FROM teams WHERE id = ?').get(id) as TeamRow; const members = db.prepare('SELECT * FROM team_members WHERE team_id = ?').all(id) as MemberRow[]; return reply.code(201).send({ ...normalizeTeam(team), members: members.map(normalizeMember) }); }); // GET /api/teams — list teams for current user fastify.get('/api/teams', async () => { const uid = getLocalUserId(dataDir); const rows = db.prepare(` SELECT t.* FROM teams t JOIN team_members m ON t.id = m.team_id WHERE m.user_id = ? ORDER BY t.created DESC `).all(uid) as TeamRow[]; return { teams: rows.map(normalizeTeam) }; }); // GET /api/teams/:id — team detail with members fastify.get<{ Params: { id: string } }>('/api/teams/:id', async (request, reply) => { const team = db.prepare('SELECT * FROM teams WHERE id = ?').get(request.params.id) as TeamRow | undefined; if (!team) return reply.code(404).send({ error: 'Team not found' }); const members = db.prepare('SELECT * FROM team_members WHERE team_id = ?').all(team.id) as MemberRow[]; // Team workspaces const allWorkspaces = fastify.workspaceManager.list(); const teamWorkspaces = allWorkspaces.filter((ws) => ws.teamId === team.id || ws.team === team.id); return { ...normalizeTeam(team), members: members.map(normalizeMember), workspaces: teamWorkspaces, }; }); // PUT /api/teams/:id — update team fastify.put<{ Params: { id: string }; Body: { name?: string; description?: string }; }>('/api/teams/:id', async (request, reply) => { const team = db.prepare('SELECT * FROM teams WHERE id = ?').get(request.params.id) as TeamRow | undefined; if (!team) return reply.code(404).send({ error: 'Team not found' }); const uid = getLocalUserId(dataDir); const member = db.prepare('SELECT * FROM team_members WHERE team_id = ? AND user_id = ?').get(team.id, uid) as MemberRow | undefined; if (!member || (member.role !== 'owner' && member.role !== 'admin')) { return reply.code(403).send({ error: 'Only owner or admin can update team' }); } const { name, description } = request.body ?? {}; const updates: string[] = []; const params: unknown[] = []; if (name !== undefined) { updates.push('name = ?'); params.push(name.trim()); } if (description !== undefined) { updates.push('description = ?'); params.push(description.trim()); } if (updates.length > 0) { updates.push("updated = datetime('now')"); params.push(team.id); db.prepare(`UPDATE teams SET ${updates.join(', ')} WHERE id = ?`).run(...params); } return db.prepare('SELECT * FROM teams WHERE id = ?').get(team.id); }); // DELETE /api/teams/:id — delete team (owner only) fastify.delete<{ Params: { id: string } }>('/api/teams/:id', async (request, reply) => { const team = db.prepare('SELECT * FROM teams WHERE id = ?').get(request.params.id) as TeamRow | undefined; if (!team) return reply.code(404).send({ error: 'Team not found' }); const uid = getLocalUserId(dataDir); if (team.owner_id !== uid) { return reply.code(403).send({ error: 'Only the team owner can delete the team' }); } // Remove all members first (CASCADE should handle this but be explicit) db.prepare('DELETE FROM team_members WHERE team_id = ?').run(team.id); db.prepare('DELETE FROM teams WHERE id = ?').run(team.id); // Unlink workspaces from this team const allWorkspaces = fastify.workspaceManager.list(); for (const ws of allWorkspaces) { if (ws.teamId === team.id || ws.team === team.id) { fastify.workspaceManager.update(ws.id, { teamId: undefined, team: null }); } } emitAuditEvent(fastify, { workspaceId: 'global', eventType: 'workspace_delete', input: JSON.stringify({ teamId: team.id }) }); return reply.code(204).send(); }); // ── Member management ──────────────────────────────────────────── // POST /api/teams/:id/members — invite/add member fastify.post<{ Params: { id: string }; Body: { userId?: string; email?: string; displayName?: string; role?: TeamRole }; }>('/api/teams/:id/members', async (request, reply) => { const team = db.prepare('SELECT * FROM teams WHERE id = ?').get(request.params.id) as TeamRow | undefined; if (!team) return reply.code(404).send({ error: 'Team not found' }); // Check permission: owner or admin can add members const uid = getLocalUserId(dataDir); const self = db.prepare('SELECT * FROM team_members WHERE team_id = ? AND user_id = ?').get(team.id, uid) as MemberRow | undefined; if (!self || (self.role !== 'owner' && self.role !== 'admin')) { return reply.code(403).send({ error: 'Only owner or admin can add members' }); } const { userId: newUserId, email, displayName, role } = request.body ?? {}; const memberUserId = newUserId ?? email ?? `user-${crypto.randomUUID().slice(0, 8)}`; const memberRole: TeamRole = role && ['owner', 'admin', 'member', 'viewer'].includes(role) ? role : 'member'; // Check if already a member const existing = db.prepare('SELECT * FROM team_members WHERE team_id = ? AND user_id = ?').get(team.id, memberUserId); if (existing) { return reply.code(409).send({ error: 'User is already a team member' }); } db.prepare(` INSERT INTO team_members (team_id, user_id, role, display_name, email, joined) VALUES (?, ?, ?, ?, ?, datetime('now')) `).run(team.id, memberUserId, memberRole, displayName ?? memberUserId, email ?? null); const member = db.prepare('SELECT * FROM team_members WHERE team_id = ? AND user_id = ?').get(team.id, memberUserId) as MemberRow; return reply.code(201).send(normalizeMember(member)); }); // PUT /api/teams/:id/members/:userId — change member role fastify.put<{ Params: { id: string; userId: string }; Body: { role: TeamRole }; }>('/api/teams/:id/members/:userId', async (request, reply) => { const team = db.prepare('SELECT * FROM teams WHERE id = ?').get(request.params.id) as TeamRow | undefined; if (!team) return reply.code(404).send({ error: 'Team not found' }); const uid = getLocalUserId(dataDir); const self = db.prepare('SELECT * FROM team_members WHERE team_id = ? AND user_id = ?').get(team.id, uid) as MemberRow | undefined; if (!self || self.role !== 'owner') { return reply.code(403).send({ error: 'Only the team owner can change roles' }); } const { role } = request.body ?? {}; if (!role || !['owner', 'admin', 'member', 'viewer'].includes(role)) { return reply.code(400).send({ error: 'Invalid role. Must be: owner, admin, member, or viewer' }); } const target = db.prepare('SELECT * FROM team_members WHERE team_id = ? AND user_id = ?').get(team.id, request.params.userId) as MemberRow | undefined; if (!target) return reply.code(404).send({ error: 'Member not found' }); db.prepare('UPDATE team_members SET role = ? WHERE team_id = ? AND user_id = ?').run(role, team.id, request.params.userId); const updated = db.prepare('SELECT * FROM team_members WHERE team_id = ? AND user_id = ?').get(team.id, request.params.userId) as MemberRow; return normalizeMember(updated); }); // PATCH /api/teams/:id/members/:userId — alias for PUT (common API convention) fastify.patch<{ Params: { id: string; userId: string }; Body: { role: TeamRole }; }>('/api/teams/:id/members/:userId', async (request, reply) => { const team = db.prepare('SELECT * FROM teams WHERE id = ?').get(request.params.id) as TeamRow | undefined; if (!team) return reply.code(404).send({ error: 'Team not found' }); const uid = getLocalUserId(dataDir); const self = db.prepare('SELECT * FROM team_members WHERE team_id = ? AND user_id = ?').get(team.id, uid) as MemberRow | undefined; if (!self || (self.role !== 'owner' && self.role !== 'admin')) { return reply.code(403).send({ error: 'Only owner or admin can change roles' }); } const { role } = request.body ?? {}; if (!role || !['owner', 'admin', 'member', 'viewer'].includes(role)) { return reply.code(400).send({ error: 'Invalid role. Must be: owner, admin, member, or viewer' }); } const target = db.prepare('SELECT * FROM team_members WHERE team_id = ? AND user_id = ?').get(team.id, request.params.userId) as MemberRow | undefined; if (!target) return reply.code(404).send({ error: 'Member not found' }); db.prepare('UPDATE team_members SET role = ? WHERE team_id = ? AND user_id = ?').run(role, team.id, request.params.userId); const updated = db.prepare('SELECT * FROM team_members WHERE team_id = ? AND user_id = ?').get(team.id, request.params.userId) as MemberRow; return normalizeMember(updated); }); // DELETE /api/teams/:id/members/:userId — remove member fastify.delete<{ Params: { id: string; userId: string }; }>('/api/teams/:id/members/:userId', async (request, reply) => { const team = db.prepare('SELECT * FROM teams WHERE id = ?').get(request.params.id) as TeamRow | undefined; if (!team) return reply.code(404).send({ error: 'Team not found' }); const uid = getLocalUserId(dataDir); const self = db.prepare('SELECT * FROM team_members WHERE team_id = ? AND user_id = ?').get(team.id, uid) as MemberRow | undefined; // Can remove: owner/admin can remove anyone, members can remove themselves const targetUserId = request.params.userId; const isSelf = targetUserId === uid; if (!isSelf && (!self || (self.role !== 'owner' && self.role !== 'admin'))) { return reply.code(403).send({ error: 'Insufficient permissions' }); } // Can't remove the owner if (team.owner_id === targetUserId) { return reply.code(400).send({ error: 'Cannot remove the team owner. Transfer ownership first.' }); } db.prepare('DELETE FROM team_members WHERE team_id = ? AND user_id = ?').run(team.id, targetUserId); return { deleted: true, userId: targetUserId, teamId: team.id }; }); // GET /api/teams/:id/activity — aggregated events from team workspaces (uses F2 audit trail) fastify.get<{ Params: { id: string }; Querystring: { limit?: string; from?: string }; }>('/api/teams/:id/activity', async (request, reply) => { const team = db.prepare('SELECT * FROM teams WHERE id = ?').get(request.params.id) as TeamRow | undefined; if (!team) return reply.code(404).send({ error: 'Team not found' }); const limit = Math.min(parseInt(request.query.limit ?? '50', 10) || 50, 200); const from = request.query.from ?? new Date(Date.now() - 7 * 86400000).toISOString(); // Find all workspaces linked to this team const allWorkspaces = fastify.workspaceManager.list(); const teamWsIds = allWorkspaces .filter((ws) => ws.teamId === team.id || ws.team === team.id) .map((ws) => ws.id); if (teamWsIds.length === 0) { return { items: [], teamId: team.id }; } // Query audit events for all team workspaces try { const { getAuditDb } = await import('./events.js'); const auditDb = getAuditDb(dataDir); const placeholders = teamWsIds.map(() => '?').join(','); const events = auditDb.prepare(` SELECT * FROM audit_events WHERE workspace_id IN (${placeholders}) AND timestamp >= ? ORDER BY id DESC LIMIT ? `).all(...teamWsIds, from, limit) as Array>; const items = events.map(e => ({ id: e.id, timestamp: e.timestamp, workspaceId: e.workspace_id, eventType: e.event_type, toolName: e.tool_name, sessionId: e.session_id, })); return { items, teamId: team.id }; } catch { return { items: [], teamId: team.id }; } }); // GET /api/team/memory/search?q=query — search team memory frames fastify.get<{ Querystring: { q?: string; limit?: string } }>( '/api/team/memory/search', async (request, reply) => { const config = new WaggleConfig(fastify.localConfig.dataDir); const teamServer = config.getTeamServer(); if (!teamServer?.url || !teamServer?.token) { return reply.code(400).send({ error: 'Not connected to team server' }); } const { q, limit: limitStr } = request.query; if (!q) return reply.code(400).send({ error: 'q parameter required' }); const limit = Math.min(parseInt(limitStr ?? '20', 10), 50); try { const url = `${teamServer.url}/api/entities?type=memory_frame&limit=${limit}`; const res = await fetchTeamServer(url, { headers: { 'Authorization': `Bearer ${teamServer.token}` }, }); if (!res.ok) return { results: [], count: 0 }; const entities = await res.json() as Array<{ id: string; name: string; properties: Record; sharedBy?: string; createdAt: string; }>; // Client-side keyword filter (team server doesn't have FTS yet) const terms = q.toLowerCase().split(/\s+/).filter(t => t.length > 1); const matched = entities.filter(e => { const content = ((e.properties?.content as string) ?? '').toLowerCase(); return terms.some(t => content.includes(t)); }); const results = matched.slice(0, limit).map(e => ({ id: e.id, content: (e.properties?.content as string) ?? '', authorId: (e.properties?.authorId as string) ?? e.sharedBy ?? '', authorName: (e.properties?.authorName as string) ?? 'Team member', importance: (e.properties?.importance as string) ?? 'normal', timestamp: e.createdAt, source: 'team', })); return { results, count: results.length }; } catch { return { results: [], count: 0 }; } }, ); } // ── Helpers ───────────────────────────────────────────────────────── function normalizeTeam(row: TeamRow) { return { id: row.id, name: row.name, description: row.description, ownerId: row.owner_id, created: row.created, updated: row.updated, }; } function normalizeMember(row: MemberRow) { return { userId: row.user_id, role: row.role, displayName: row.display_name, email: row.email, joined: row.joined, }; }