agent-relay 2.0.23 → 2.0.24

package/packages/cloud/dist/api/coordinators.js

@@ -1,750 +0,0 @@
-/**
- * Coordinator Agent API Routes
- *
- * Manage coordinator agents for project groups.
- * Coordinators oversee and orchestrate work across repositories in a group.
- */
-import { Router } from 'express';
-import { requireAuth } from './auth.js';
-import { checkCoordinatorAccess } from './middleware/planLimits.js';
-import { db } from '../db/index.js';
-import { getCoordinatorService, sendToWorkspace, broadcastToGroup, routeToCoordinator, getActiveCoordinators, } from '../services/coordinator.js';
-export const coordinatorsRouter = Router();
-// All routes require authentication
-coordinatorsRouter.use(requireAuth);
-// Coordinator modification routes require Pro plan or higher
-const coordinatorWriteRoutes = [
-    '/:groupId/coordinator/enable',
-    '/:groupId/coordinator/disable',
-];
-coordinatorWriteRoutes.forEach(route => {
-    coordinatorsRouter.use(route, checkCoordinatorAccess);
-});
-// ============================================================================
-// Project Group CRUD Routes
-// These must come BEFORE the /:groupId/coordinator routes
-// ============================================================================
-/**
- * GET /api/project-groups
- * List all project groups for the authenticated user
- */
-coordinatorsRouter.get('/', async (req, res) => {
-    const userId = req.session.userId;
-    try {
-        const result = await db.projectGroups.findAllWithRepositories(userId);
-        res.json({
-            groups: result.groups.map(group => ({
-                id: group.id,
-                name: group.name,
-                description: group.description,
-                color: group.color,
-                icon: group.icon,
-                coordinatorAgent: group.coordinatorAgent,
-                sortOrder: group.sortOrder,
-                repositoryCount: group.repositories.length,
-                repositories: group.repositories.map(repo => ({
-                    id: repo.id,
-                    githubFullName: repo.githubFullName,
-                    defaultBranch: repo.defaultBranch,
-                    isPrivate: repo.isPrivate,
-                })),
-                createdAt: group.createdAt,
-                updatedAt: group.updatedAt,
-            })),
-            ungroupedRepositories: result.ungroupedRepositories.map(repo => ({
-                id: repo.id,
-                githubFullName: repo.githubFullName,
-                defaultBranch: repo.defaultBranch,
-                isPrivate: repo.isPrivate,
-                workspaceId: repo.workspaceId,
-            })),
-        });
-    }
-    catch (error) {
-        console.error('Error listing project groups:', error);
-        res.status(500).json({ error: 'Failed to list project groups' });
-    }
-});
-/**
- * POST /api/project-groups
- * Create a new project group
- */
-coordinatorsRouter.post('/', async (req, res) => {
-    const userId = req.session.userId;
-    const { name, description, color, icon, repositoryIds } = req.body;
-    if (!name || typeof name !== 'string' || name.trim().length === 0) {
-        return res.status(400).json({ error: 'Name is required' });
-    }
-    if (name.length > 255) {
-        return res.status(400).json({ error: 'Name must be 255 characters or less' });
-    }
-    try {
-        // Check for duplicate name
-        const existing = await db.projectGroups.findByName(userId, name.trim());
-        if (existing) {
-            return res.status(409).json({ error: 'A project group with this name already exists' });
-        }
-        // Create the group
-        const group = await db.projectGroups.create({
-            userId,
-            name: name.trim(),
-            description: description?.trim() || null,
-            color: color || null,
-            icon: icon || null,
-            coordinatorAgent: { enabled: false },
-            sortOrder: 0,
-        });
-        // Assign repositories to the group if provided
-        if (repositoryIds && Array.isArray(repositoryIds) && repositoryIds.length > 0) {
-            // Verify all repositories belong to the user
-            const userRepos = await db.repositories.findByUserId(userId);
-            const userRepoIds = new Set(userRepos.map(r => r.id));
-            for (const repoId of repositoryIds) {
-                if (!userRepoIds.has(repoId)) {
-                    return res.status(400).json({
-                        error: `Repository ${repoId} not found or not owned by user`,
-                    });
-                }
-            }
-            // Assign repositories to the group
-            for (const repoId of repositoryIds) {
-                await db.repositories.assignToGroup(repoId, group.id);
-            }
-        }
-        // Fetch the group with repositories for response
-        const groupWithRepos = await db.projectGroups.findWithRepositories(group.id);
-        res.status(201).json({
-            success: true,
-            group: {
-                id: groupWithRepos.id,
-                name: groupWithRepos.name,
-                description: groupWithRepos.description,
-                color: groupWithRepos.color,
-                icon: groupWithRepos.icon,
-                coordinatorAgent: groupWithRepos.coordinatorAgent,
-                repositories: groupWithRepos.repositories.map(repo => ({
-                    id: repo.id,
-                    githubFullName: repo.githubFullName,
-                    defaultBranch: repo.defaultBranch,
-                    isPrivate: repo.isPrivate,
-                })),
-                createdAt: groupWithRepos.createdAt,
-                updatedAt: groupWithRepos.updatedAt,
-            },
-        });
-    }
-    catch (error) {
-        console.error('Error creating project group:', error);
-        res.status(500).json({ error: 'Failed to create project group' });
-    }
-});
-/**
- * GET /api/project-groups/:id
- * Get a specific project group with its repositories
- */
-coordinatorsRouter.get('/:id', async (req, res) => {
-    const userId = req.session.userId;
-    const id = req.params.id;
-    // Skip if this looks like a coordinator route
-    if (id === 'coordinators') {
-        return res.status(404).json({ error: 'Not found' });
-    }
-    try {
-        const group = await db.projectGroups.findWithRepositories(id);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        res.json({
-            id: group.id,
-            name: group.name,
-            description: group.description,
-            color: group.color,
-            icon: group.icon,
-            coordinatorAgent: group.coordinatorAgent,
-            sortOrder: group.sortOrder,
-            repositories: group.repositories.map(repo => ({
-                id: repo.id,
-                githubFullName: repo.githubFullName,
-                defaultBranch: repo.defaultBranch,
-                isPrivate: repo.isPrivate,
-                syncStatus: repo.syncStatus,
-                lastSyncedAt: repo.lastSyncedAt,
-                workspaceId: repo.workspaceId,
-            })),
-            createdAt: group.createdAt,
-            updatedAt: group.updatedAt,
-        });
-    }
-    catch (error) {
-        console.error('Error getting project group:', error);
-        res.status(500).json({ error: 'Failed to get project group' });
-    }
-});
-/**
- * PATCH /api/project-groups/:id
- * Update a project group's metadata
- */
-coordinatorsRouter.patch('/:id', async (req, res) => {
-    const userId = req.session.userId;
-    const id = req.params.id;
-    const { name, description, color, icon } = req.body;
-    try {
-        const group = await db.projectGroups.findById(id);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        // Build update object with only provided fields
-        const updates = {};
-        if (name !== undefined) {
-            if (typeof name !== 'string' || name.trim().length === 0) {
-                return res.status(400).json({ error: 'Name cannot be empty' });
-            }
-            if (name.length > 255) {
-                return res.status(400).json({ error: 'Name must be 255 characters or less' });
-            }
-            // Check for duplicate name (excluding current group)
-            const existing = await db.projectGroups.findByName(userId, name.trim());
-            if (existing && existing.id !== id) {
-                return res.status(409).json({ error: 'A project group with this name already exists' });
-            }
-            updates.name = name.trim();
-        }
-        if (description !== undefined) {
-            updates.description = description?.trim() || null;
-        }
-        if (color !== undefined) {
-            // Validate hex color format if provided
-            if (color && !/^#[0-9A-Fa-f]{6}$/.test(color)) {
-                return res.status(400).json({ error: 'Color must be a valid hex color (e.g., #3B82F6)' });
-            }
-            updates.color = color || null;
-        }
-        if (icon !== undefined) {
-            updates.icon = icon || null;
-        }
-        if (Object.keys(updates).length === 0) {
-            return res.status(400).json({ error: 'No valid fields to update' });
-        }
-        await db.projectGroups.update(id, updates);
-        // Fetch updated group
-        const updatedGroup = await db.projectGroups.findWithRepositories(id);
-        res.json({
-            success: true,
-            group: {
-                id: updatedGroup.id,
-                name: updatedGroup.name,
-                description: updatedGroup.description,
-                color: updatedGroup.color,
-                icon: updatedGroup.icon,
-                coordinatorAgent: updatedGroup.coordinatorAgent,
-                repositories: updatedGroup.repositories.map(repo => ({
-                    id: repo.id,
-                    githubFullName: repo.githubFullName,
-                    defaultBranch: repo.defaultBranch,
-                    isPrivate: repo.isPrivate,
-                })),
-                updatedAt: updatedGroup.updatedAt,
-            },
-        });
-    }
-    catch (error) {
-        console.error('Error updating project group:', error);
-        res.status(500).json({ error: 'Failed to update project group' });
-    }
-});
-/**
- * DELETE /api/project-groups/:id
- * Delete a project group (repositories are unassigned, not deleted)
- */
-coordinatorsRouter.delete('/:id', async (req, res) => {
-    const userId = req.session.userId;
-    const id = req.params.id;
-    try {
-        const group = await db.projectGroups.findById(id);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        // Stop coordinator if running
-        if (group.coordinatorAgent?.enabled) {
-            try {
-                const coordinatorService = getCoordinatorService();
-                await coordinatorService.stop(id);
-            }
-            catch (err) {
-                console.warn('Error stopping coordinator during group deletion:', err);
-            }
-        }
-        // Delete the group (repositories will have projectGroupId set to null due to ON DELETE SET NULL)
-        await db.projectGroups.delete(id);
-        res.json({
-            success: true,
-            message: 'Project group deleted',
-        });
-    }
-    catch (error) {
-        console.error('Error deleting project group:', error);
-        res.status(500).json({ error: 'Failed to delete project group' });
-    }
-});
-/**
- * POST /api/project-groups/:id/repositories
- * Add repositories to a project group
- */
-coordinatorsRouter.post('/:id/repositories', async (req, res) => {
-    const userId = req.session.userId;
-    const id = req.params.id;
-    const { repositoryIds } = req.body;
-    if (!repositoryIds || !Array.isArray(repositoryIds) || repositoryIds.length === 0) {
-        return res.status(400).json({ error: 'repositoryIds array is required' });
-    }
-    try {
-        const group = await db.projectGroups.findById(id);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        // Verify all repositories belong to the user
-        const userRepos = await db.repositories.findByUserId(userId);
-        const userRepoIds = new Set(userRepos.map(r => r.id));
-        for (const repoId of repositoryIds) {
-            if (!userRepoIds.has(repoId)) {
-                return res.status(400).json({
-                    error: `Repository ${repoId} not found or not owned by user`,
-                });
-            }
-        }
-        // Assign repositories to the group
-        for (const repoId of repositoryIds) {
-            await db.repositories.assignToGroup(repoId, id);
-        }
-        // Fetch updated group
-        const updatedGroup = await db.projectGroups.findWithRepositories(id);
-        res.json({
-            success: true,
-            group: {
-                id: updatedGroup.id,
-                name: updatedGroup.name,
-                repositories: updatedGroup.repositories.map(repo => ({
-                    id: repo.id,
-                    githubFullName: repo.githubFullName,
-                    defaultBranch: repo.defaultBranch,
-                    isPrivate: repo.isPrivate,
-                })),
-            },
-        });
-    }
-    catch (error) {
-        console.error('Error adding repositories to group:', error);
-        res.status(500).json({ error: 'Failed to add repositories to group' });
-    }
-});
-/**
- * DELETE /api/project-groups/:id/repositories/:repoId
- * Remove a repository from a project group
- */
-coordinatorsRouter.delete('/:id/repositories/:repoId', async (req, res) => {
-    const userId = req.session.userId;
-    const id = req.params.id;
-    const repoId = req.params.repoId;
-    try {
-        const group = await db.projectGroups.findById(id);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        // Verify repository exists and belongs to this group
-        const repo = await db.repositories.findById(repoId);
-        if (!repo) {
-            return res.status(404).json({ error: 'Repository not found' });
-        }
-        if (repo.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        if (repo.projectGroupId !== id) {
-            return res.status(400).json({ error: 'Repository is not in this group' });
-        }
-        // Remove repository from group (set projectGroupId to null)
-        await db.repositories.assignToGroup(repoId, null);
-        res.json({
-            success: true,
-            message: 'Repository removed from group',
-        });
-    }
-    catch (error) {
-        console.error('Error removing repository from group:', error);
-        res.status(500).json({ error: 'Failed to remove repository from group' });
-    }
-});
-/**
- * PUT /api/project-groups/reorder
- * Reorder project groups
- */
-coordinatorsRouter.put('/reorder', async (req, res) => {
-    const userId = req.session.userId;
-    const { orderedIds } = req.body;
-    if (!orderedIds || !Array.isArray(orderedIds)) {
-        return res.status(400).json({ error: 'orderedIds array is required' });
-    }
-    try {
-        // Verify all groups belong to user
-        const userGroups = await db.projectGroups.findByUserId(userId);
-        const userGroupIds = new Set(userGroups.map(g => g.id));
-        for (const groupId of orderedIds) {
-            if (!userGroupIds.has(groupId)) {
-                return res.status(400).json({
-                    error: `Group ${groupId} not found or not owned by user`,
-                });
-            }
-        }
-        await db.projectGroups.reorder(userId, orderedIds);
-        res.json({
-            success: true,
-            message: 'Groups reordered',
-        });
-    }
-    catch (error) {
-        console.error('Error reordering project groups:', error);
-        res.status(500).json({ error: 'Failed to reorder project groups' });
-    }
-});
-// ============================================================================
-// Coordinator Agent Routes
-// ============================================================================
-/**
- * GET /api/project-groups/:groupId/coordinator
- * Get coordinator agent configuration
- */
-coordinatorsRouter.get('/:groupId/coordinator', async (req, res) => {
-    const userId = req.session.userId;
-    const groupId = req.params.groupId;
-    try {
-        const group = await db.projectGroups.findById(groupId);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        res.json({
-            groupId: group.id,
-            groupName: group.name,
-            coordinator: group.coordinatorAgent || { enabled: false },
-        });
-    }
-    catch (error) {
-        console.error('Error getting coordinator config:', error);
-        res.status(500).json({ error: 'Failed to get coordinator configuration' });
-    }
-});
-/**
- * PUT /api/project-groups/:groupId/coordinator
- * Update coordinator agent configuration
- */
-coordinatorsRouter.put('/:groupId/coordinator', async (req, res) => {
-    const userId = req.session.userId;
-    const groupId = req.params.groupId;
-    const { name, model, systemPrompt, capabilities } = req.body;
-    try {
-        const group = await db.projectGroups.findById(groupId);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        // Build updated config, preserving enabled state
-        const currentConfig = group.coordinatorAgent || { enabled: false };
-        const updatedConfig = {
-            enabled: currentConfig.enabled,
-            name: name !== undefined ? name : currentConfig.name,
-            model: model !== undefined ? model : currentConfig.model,
-            systemPrompt: systemPrompt !== undefined ? systemPrompt : currentConfig.systemPrompt,
-            capabilities: capabilities !== undefined ? capabilities : currentConfig.capabilities,
-        };
-        await db.projectGroups.updateCoordinatorAgent(groupId, updatedConfig);
-        // If coordinator is currently enabled, restart it with new config
-        if (updatedConfig.enabled) {
-            const coordinatorService = getCoordinatorService();
-            await coordinatorService.restart(groupId);
-        }
-        res.json({
-            success: true,
-            coordinator: updatedConfig,
-        });
-    }
-    catch (error) {
-        console.error('Error updating coordinator config:', error);
-        res.status(500).json({ error: 'Failed to update coordinator configuration' });
-    }
-});
-/**
- * POST /api/project-groups/:groupId/coordinator/enable
- * Enable coordinator agent for a project group
- */
-coordinatorsRouter.post('/:groupId/coordinator/enable', async (req, res) => {
-    const userId = req.session.userId;
-    const groupId = req.params.groupId;
-    try {
-        const group = await db.projectGroups.findById(groupId);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        // Plan check is handled by checkCoordinatorAccess middleware
-        // Get repositories in the group
-        const repositories = await db.repositories.findByProjectGroupId(groupId);
-        if (repositories.length === 0) {
-            return res.status(400).json({
-                error: 'Cannot enable coordinator for empty group',
-                message: 'Add at least one repository to this group first',
-            });
-        }
-        // Enable coordinator
-        const currentConfig = group.coordinatorAgent || { enabled: false };
-        const updatedConfig = {
-            ...currentConfig,
-            enabled: true,
-            name: currentConfig.name || `${group.name} Coordinator`,
-        };
-        await db.projectGroups.updateCoordinatorAgent(groupId, updatedConfig);
-        // Start the coordinator agent
-        const coordinatorService = getCoordinatorService();
-        await coordinatorService.start(groupId);
-        res.json({
-            success: true,
-            message: 'Coordinator agent enabled',
-            coordinator: updatedConfig,
-        });
-    }
-    catch (error) {
-        console.error('Error enabling coordinator:', error);
-        res.status(500).json({ error: 'Failed to enable coordinator agent' });
-    }
-});
-/**
- * POST /api/project-groups/:groupId/coordinator/disable
- * Disable coordinator agent for a project group
- */
-coordinatorsRouter.post('/:groupId/coordinator/disable', async (req, res) => {
-    const userId = req.session.userId;
-    const groupId = req.params.groupId;
-    try {
-        const group = await db.projectGroups.findById(groupId);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        // Disable coordinator
-        const currentConfig = group.coordinatorAgent || { enabled: false };
-        const updatedConfig = {
-            ...currentConfig,
-            enabled: false,
-        };
-        await db.projectGroups.updateCoordinatorAgent(groupId, updatedConfig);
-        // Stop the coordinator agent
-        const coordinatorService = getCoordinatorService();
-        await coordinatorService.stop(groupId);
-        res.json({
-            success: true,
-            message: 'Coordinator agent disabled',
-            coordinator: updatedConfig,
-        });
-    }
-    catch (error) {
-        console.error('Error disabling coordinator:', error);
-        res.status(500).json({ error: 'Failed to disable coordinator agent' });
-    }
-});
-/**
- * GET /api/project-groups/coordinators/active
- * List all active coordinators for the user
- */
-coordinatorsRouter.get('/coordinators/active', async (req, res) => {
-    const userId = req.session.userId;
-    try {
-        // Get all coordinators
-        const activeCoordinators = await getActiveCoordinators();
-        // Filter to only user's project groups
-        const userGroups = await db.projectGroups.findByUserId(userId);
-        const userGroupIds = new Set(userGroups.map((g) => g.id));
-        const userCoordinators = activeCoordinators.filter((c) => userGroupIds.has(c.groupId));
-        res.json({
-            coordinators: userCoordinators,
-        });
-    }
-    catch (error) {
-        console.error('Error listing active coordinators:', error);
-        res.status(500).json({ error: 'Failed to list coordinators' });
-    }
-});
-/**
- * POST /api/project-groups/:groupId/coordinator/message
- * Send a message from coordinator to a specific workspace/agent
- */
-coordinatorsRouter.post('/:groupId/coordinator/message', async (req, res) => {
-    const userId = req.session.userId;
-    const groupId = req.params.groupId;
-    const { workspaceId, agentName, message, thread } = req.body;
-    if (!workspaceId || !agentName || !message) {
-        return res.status(400).json({
-            error: 'workspaceId, agentName, and message are required',
-        });
-    }
-    try {
-        const group = await db.projectGroups.findById(groupId);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        if (!group.coordinatorAgent?.enabled) {
-            return res.status(400).json({ error: 'Coordinator is not enabled' });
-        }
-        await sendToWorkspace(groupId, workspaceId, agentName, message, thread);
-        res.json({
-            success: true,
-            message: 'Message sent',
-        });
-    }
-    catch (error) {
-        console.error('Error sending coordinator message:', error);
-        res.status(500).json({ error: 'Failed to send message' });
-    }
-});
-/**
- * POST /api/project-groups/:groupId/coordinator/broadcast
- * Broadcast a message from coordinator to all workspaces in the group
- */
-coordinatorsRouter.post('/:groupId/coordinator/broadcast', async (req, res) => {
-    const userId = req.session.userId;
-    const groupId = req.params.groupId;
-    const { message, thread } = req.body;
-    if (!message) {
-        return res.status(400).json({ error: 'message is required' });
-    }
-    try {
-        const group = await db.projectGroups.findById(groupId);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        if (!group.coordinatorAgent?.enabled) {
-            return res.status(400).json({ error: 'Coordinator is not enabled' });
-        }
-        await broadcastToGroup(groupId, message, thread);
-        res.json({
-            success: true,
-            message: 'Broadcast sent',
-        });
-    }
-    catch (error) {
-        console.error('Error broadcasting coordinator message:', error);
-        res.status(500).json({ error: 'Failed to broadcast message' });
-    }
-});
-/**
- * POST /api/project-groups/coordinator/route
- * Route a message from a workspace to its coordinator
- * (Called by workspace daemons)
- */
-coordinatorsRouter.post('/coordinator/route', async (req, res) => {
-    const { workspaceId, agentName, message, thread } = req.body;
-    if (!workspaceId || !agentName || !message) {
-        return res.status(400).json({
-            error: 'workspaceId, agentName, and message are required',
-        });
-    }
-    try {
-        // Verify workspace exists and get its owner
-        const workspace = await db.workspaces.findById(workspaceId);
-        if (!workspace) {
-            return res.status(404).json({ error: 'Workspace not found' });
-        }
-        await routeToCoordinator(workspaceId, agentName, message, thread);
-        res.json({
-            success: true,
-            message: 'Message routed to coordinator',
-        });
-    }
-    catch (error) {
-        console.error('Error routing to coordinator:', error);
-        res.status(500).json({ error: 'Failed to route message' });
-    }
-});
-/**
- * GET /api/project-groups/:groupId/coordinator/status
- * Get detailed coordinator status including connected workspaces
- */
-coordinatorsRouter.get('/:groupId/coordinator/status', async (req, res) => {
-    const userId = req.session.userId;
-    const groupId = req.params.groupId;
-    try {
-        const group = await db.projectGroups.findById(groupId);
-        if (!group) {
-            return res.status(404).json({ error: 'Project group not found' });
-        }
-        if (group.userId !== userId) {
-            return res.status(403).json({ error: 'Unauthorized' });
-        }
-        const coordinatorService = getCoordinatorService();
-        const status = await coordinatorService.getStatus(groupId);
-        // Get connected workspaces info
-        const repositories = await db.repositories.findByProjectGroupId(groupId);
-        const workspaceIds = new Set();
-        for (const repo of repositories) {
-            if (repo.workspaceId) {
-                workspaceIds.add(repo.workspaceId);
-            }
-        }
-        const workspaces = await Promise.all(Array.from(workspaceIds).map(async (id) => {
-            const ws = await db.workspaces.findById(id);
-            return ws
-                ? {
-                    id: ws.id,
-                    name: ws.name,
-                    status: ws.status,
-                    publicUrl: ws.publicUrl,
-                }
-                : null;
-        }));
-        res.json({
-            groupId,
-            groupName: group.name,
-            coordinator: {
-                enabled: group.coordinatorAgent?.enabled || false,
-                name: group.coordinatorAgent?.name,
-                model: group.coordinatorAgent?.model,
-                status: status?.status || 'stopped',
-                startedAt: status?.startedAt,
-                error: status?.error,
-            },
-            workspaces: workspaces.filter(Boolean),
-            repositoryCount: repositories.length,
-        });
-    }
-    catch (error) {
-        console.error('Error getting coordinator status:', error);
-        res.status(500).json({ error: 'Failed to get coordinator status' });
-    }
-});
-//# sourceMappingURL=coordinators.js.map