@agent-relay/cloud 0.1.0

package/dist/api/coordinators.js

@@ -0,0 +1,750 @@
+/**
+ * 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