@swarmroom/server 0.1.0

package/dist/routes/projects.js

@@ -0,0 +1,94 @@
+import { Hono } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import { CreateProjectRequestSchema } from '@swarmroom/shared';
+import { createProject, listProjects, getProjectById, updateProject, deleteProject, addAgentToProject, removeAgentFromProject, } from '../services/project-service.js';
+const projectsRoute = new Hono();
+projectsRoute.post('/', async (c) => {
+    const body = await c.req.json();
+    const parsed = CreateProjectRequestSchema.safeParse(body);
+    if (!parsed.success) {
+        throw new HTTPException(400, {
+            message: `Invalid request body: ${parsed.error.issues.map((i) => i.message).join(', ')}`,
+        });
+    }
+    try {
+        const project = createProject({ ...parsed.data, repository: body.repository });
+        return c.json({ success: true, data: project }, 201);
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.includes('UNIQUE constraint failed')) {
+            throw new HTTPException(409, {
+                message: `Project with name "${parsed.data.name}" already exists`,
+            });
+        }
+        throw err;
+    }
+});
+projectsRoute.get('/', (c) => {
+    const result = listProjects();
+    return c.json({ success: true, data: result });
+});
+projectsRoute.get('/:id', (c) => {
+    const id = c.req.param('id');
+    const project = getProjectById(id);
+    if (!project) {
+        throw new HTTPException(404, { message: `Project "${id}" not found` });
+    }
+    return c.json({ success: true, data: project });
+});
+projectsRoute.patch('/:id', async (c) => {
+    const id = c.req.param('id');
+    const body = await c.req.json();
+    const updates = {};
+    if (body.name !== undefined)
+        updates.name = body.name;
+    if (body.description !== undefined)
+        updates.description = body.description;
+    if (body.repository !== undefined)
+        updates.repository = body.repository;
+    const project = updateProject(id, updates);
+    if (!project) {
+        throw new HTTPException(404, { message: `Project "${id}" not found` });
+    }
+    return c.json({ success: true, data: project });
+});
+projectsRoute.delete('/:id', (c) => {
+    const id = c.req.param('id');
+    const project = deleteProject(id);
+    if (!project) {
+        throw new HTTPException(404, { message: `Project "${id}" not found` });
+    }
+    return c.json({ success: true, data: project });
+});
+projectsRoute.post('/:id/agents', async (c) => {
+    const projectId = c.req.param('id');
+    const body = await c.req.json();
+    if (!body.agentId || typeof body.agentId !== 'string') {
+        throw new HTTPException(400, { message: 'agentId is required' });
+    }
+    const result = addAgentToProject(projectId, body.agentId);
+    if ('error' in result) {
+        if (result.error === 'project_not_found') {
+            throw new HTTPException(404, { message: `Project "${projectId}" not found` });
+        }
+        if (result.error === 'agent_not_found') {
+            throw new HTTPException(404, { message: `Agent "${body.agentId}" not found` });
+        }
+    }
+    return c.json({ success: true, data: result.data }, 201);
+});
+projectsRoute.delete('/:id/agents/:agentId', (c) => {
+    const projectId = c.req.param('id');
+    const agentId = c.req.param('agentId');
+    const result = removeAgentFromProject(projectId, agentId);
+    if ('error' in result) {
+        if (result.error === 'project_not_found') {
+            throw new HTTPException(404, { message: `Project "${projectId}" not found` });
+        }
+        if (result.error === 'not_a_member') {
+            throw new HTTPException(404, { message: `Agent "${agentId}" is not a member of project "${projectId}"` });
+        }
+    }
+    return c.json({ success: true, data: result.data });
+});
+export { projectsRoute };

package/dist/routes/teams.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const teamsRoute: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { teamsRoute };

package/dist/routes/teams.js

@@ -0,0 +1,94 @@
+import { Hono } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import { CreateTeamRequestSchema } from '@swarmroom/shared';
+import { createTeam, listTeams, getTeamById, updateTeam, deleteTeam, addAgentToTeam, removeAgentFromTeam, } from '../services/team-service.js';
+const teamsRoute = new Hono();
+teamsRoute.post('/', async (c) => {
+    const body = await c.req.json();
+    const parsed = CreateTeamRequestSchema.safeParse(body);
+    if (!parsed.success) {
+        throw new HTTPException(400, {
+            message: `Invalid request body: ${parsed.error.issues.map((i) => i.message).join(', ')}`,
+        });
+    }
+    try {
+        const team = createTeam({ ...parsed.data, color: body.color });
+        return c.json({ success: true, data: team }, 201);
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.includes('UNIQUE constraint failed')) {
+            throw new HTTPException(409, {
+                message: `Team with name "${parsed.data.name}" already exists`,
+            });
+        }
+        throw err;
+    }
+});
+teamsRoute.get('/', (c) => {
+    const result = listTeams();
+    return c.json({ success: true, data: result });
+});
+teamsRoute.get('/:id', (c) => {
+    const id = c.req.param('id');
+    const team = getTeamById(id);
+    if (!team) {
+        throw new HTTPException(404, { message: `Team "${id}" not found` });
+    }
+    return c.json({ success: true, data: team });
+});
+teamsRoute.patch('/:id', async (c) => {
+    const id = c.req.param('id');
+    const body = await c.req.json();
+    const updates = {};
+    if (body.name !== undefined)
+        updates.name = body.name;
+    if (body.description !== undefined)
+        updates.description = body.description;
+    if (body.color !== undefined)
+        updates.color = body.color;
+    const team = updateTeam(id, updates);
+    if (!team) {
+        throw new HTTPException(404, { message: `Team "${id}" not found` });
+    }
+    return c.json({ success: true, data: team });
+});
+teamsRoute.delete('/:id', (c) => {
+    const id = c.req.param('id');
+    const team = deleteTeam(id);
+    if (!team) {
+        throw new HTTPException(404, { message: `Team "${id}" not found` });
+    }
+    return c.json({ success: true, data: team });
+});
+teamsRoute.post('/:id/agents', async (c) => {
+    const teamId = c.req.param('id');
+    const body = await c.req.json();
+    if (!body.agentId || typeof body.agentId !== 'string') {
+        throw new HTTPException(400, { message: 'agentId is required' });
+    }
+    const result = addAgentToTeam(teamId, body.agentId);
+    if ('error' in result) {
+        if (result.error === 'team_not_found') {
+            throw new HTTPException(404, { message: `Team "${teamId}" not found` });
+        }
+        if (result.error === 'agent_not_found') {
+            throw new HTTPException(404, { message: `Agent "${body.agentId}" not found` });
+        }
+    }
+    return c.json({ success: true, data: result.data }, 201);
+});
+teamsRoute.delete('/:id/agents/:agentId', (c) => {
+    const teamId = c.req.param('id');
+    const agentId = c.req.param('agentId');
+    const result = removeAgentFromTeam(teamId, agentId);
+    if ('error' in result) {
+        if (result.error === 'team_not_found') {
+            throw new HTTPException(404, { message: `Team "${teamId}" not found` });
+        }
+        if (result.error === 'not_a_member') {
+            throw new HTTPException(404, { message: `Agent "${agentId}" is not a member of team "${teamId}"` });
+        }
+    }
+    return c.json({ success: true, data: result.data });
+});
+export { teamsRoute };

package/dist/routes/well-known.d.ts

@@ -0,0 +1,3 @@
+import { Hono } from 'hono';
+declare const wellKnown: Hono<import("hono/types").BlankEnv, import("hono/types").BlankSchema, "/">;
+export { wellKnown };

package/dist/routes/well-known.js

@@ -0,0 +1,78 @@
+import { Hono } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import { inArray } from 'drizzle-orm';
+import { getAgentById } from '../services/agent-service.js';
+import { db, teams, projectGroups } from '../db/index.js';
+const wellKnown = new Hono();
+// ─── Hub Agent Card ──────────────────────────────────────────────────────────
+wellKnown.get('/.well-known/agent-card.json', (c) => {
+    const url = new URL(c.req.url);
+    const selfUrl = `${url.protocol}//${url.host}`;
+    const card = {
+        name: 'SwarmRoom Hub',
+        description: 'Multi-agent coordination hub for local AI agents',
+        version: '0.1.0',
+        url: selfUrl,
+        skills: [
+            {
+                id: 'agent-discovery',
+                name: 'Agent Discovery',
+                description: 'Discover and manage AI coding agents on the local network',
+                tags: ['discovery', 'mdns'],
+            },
+            {
+                id: 'message-routing',
+                name: 'Message Routing',
+                description: 'Route messages between agents in real-time',
+                tags: ['messaging', 'routing'],
+            },
+            {
+                id: 'team-management',
+                name: 'Team Management',
+                description: 'Organize agents into teams and project groups',
+                tags: ['teams', 'projects'],
+            },
+        ],
+        teams: [],
+        projectGroups: [],
+    };
+    return c.json(card);
+});
+// ─── Per-Agent Card ──────────────────────────────────────────────────────────
+wellKnown.get('/api/agents/:id/card', (c) => {
+    const id = c.req.param('id');
+    const agent = getAgentById(id);
+    if (!agent) {
+        throw new HTTPException(404, { message: `Agent "${id}" not found` });
+    }
+    if (agent.agentCard) {
+        return c.json({ success: true, data: agent.agentCard });
+    }
+    const teamNames = agent.teamIds.length > 0
+        ? db
+            .select({ name: teams.name })
+            .from(teams)
+            .where(inArray(teams.id, agent.teamIds))
+            .all()
+            .map((t) => t.name)
+        : [];
+    const projectNames = agent.projectIds.length > 0
+        ? db
+            .select({ name: projectGroups.name })
+            .from(projectGroups)
+            .where(inArray(projectGroups.id, agent.projectIds))
+            .all()
+            .map((p) => p.name)
+        : [];
+    const card = {
+        name: agent.displayName ?? agent.name,
+        description: 'Agent registered with SwarmRoom',
+        version: '1.0.0',
+        url: agent.url,
+        skills: [],
+        teams: teamNames,
+        projectGroups: projectNames,
+    };
+    return c.json({ success: true, data: card });
+});
+export { wellKnown };

package/dist/routes/ws.d.ts

@@ -0,0 +1,5 @@
+import type { Hono } from 'hono';
+import type { createNodeWebSocket } from '@hono/node-ws';
+type NodeWebSocket = ReturnType<typeof createNodeWebSocket>;
+export declare function registerWsRoute(app: Hono, upgradeWebSocket: NodeWebSocket['upgradeWebSocket']): void;
+export {};

package/dist/routes/ws.js

@@ -0,0 +1,19 @@
+import { handleIncomingMessage, unregisterClient, } from '../services/ws-manager.js';
+export function registerWsRoute(app, upgradeWebSocket) {
+    app.get('/ws', upgradeWebSocket(() => {
+        return {
+            onMessage(event, ws) {
+                const data = typeof event.data === 'string'
+                    ? event.data
+                    : String(event.data);
+                handleIncomingMessage(ws, data);
+            },
+            onClose(_event, ws) {
+                unregisterClient(ws);
+            },
+            onError(_event, ws) {
+                unregisterClient(ws);
+            },
+        };
+    }));
+}

package/dist/services/__tests__/agent-service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/__tests__/agent-service.test.js

@@ -0,0 +1,67 @@
+import { describe, it, expect, vi } from 'vitest';
+import { createAgent, listAgents, getAgentById, updateAgent, deregisterAgent, getAgentCount, } from '../../services/agent-service.js';
+describe('AgentService', () => {
+    const validInput = { name: 'test-agent', url: 'http://localhost:3000' };
+    it('createAgent returns agent with UUID and displayName', () => {
+        const agent = createAgent(validInput);
+        expect(agent).not.toBeNull();
+        expect(agent.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/);
+        expect(agent.name).toBe('test-agent');
+        expect(agent.displayName).toBeTruthy();
+        expect(agent.status).toBe('online');
+        expect(agent.teamIds).toEqual([]);
+        expect(agent.projectIds).toEqual([]);
+    });
+    it('listAgents filters by status', () => {
+        createAgent({ name: 'agent-a', url: 'http://a' });
+        const agentB = createAgent({ name: 'agent-b', url: 'http://b' });
+        deregisterAgent(agentB.id);
+        const onlineAgents = listAgents({ status: 'online' });
+        const offlineAgents = listAgents({ status: 'offline' });
+        expect(onlineAgents).toHaveLength(1);
+        expect(onlineAgents[0].name).toBe('agent-a');
+        expect(offlineAgents).toHaveLength(1);
+        expect(offlineAgents[0].name).toBe('agent-b');
+    });
+    it('resolves display name collision by appending suffix', () => {
+        const generateDisplayName = vi.fn().mockReturnValue('SwiftFalcon');
+        vi.doMock('../../lib/names.js', () => ({ generateDisplayName }));
+        const agent1 = createAgent({ name: 'agent-1', url: 'http://1' });
+        const agent2 = createAgent({ name: 'agent-2', url: 'http://2' });
+        const names = [agent1.displayName, agent2.displayName];
+        const unique = new Set(names);
+        expect(unique.size).toBe(2);
+    });
+    it('deregisterAgent sets status to offline (soft delete)', () => {
+        const agent = createAgent(validInput);
+        const result = deregisterAgent(agent.id);
+        expect(result).not.toBeNull();
+        expect(result.status).toBe('offline');
+        const fetched = getAgentById(agent.id);
+        expect(fetched.status).toBe('offline');
+    });
+    it('getAgentById returns full agent detail or null', () => {
+        const agent = createAgent(validInput);
+        const fetched = getAgentById(agent.id);
+        expect(fetched).not.toBeNull();
+        expect(fetched.name).toBe('test-agent');
+        expect(fetched.teamIds).toEqual([]);
+        expect(fetched.projectIds).toEqual([]);
+        const missing = getAgentById('nonexistent-id');
+        expect(missing).toBeNull();
+    });
+    it('getAgentCount returns correct count', () => {
+        expect(getAgentCount()).toBe(0);
+        createAgent({ name: 'a1', url: 'http://a' });
+        createAgent({ name: 'a2', url: 'http://b' });
+        expect(getAgentCount()).toBe(2);
+    });
+    it('updateAgent modifies fields and returns updated agent', () => {
+        const agent = createAgent(validInput);
+        const updated = updateAgent(agent.id, { name: 'renamed-agent' });
+        expect(updated).not.toBeNull();
+        expect(updated.name).toBe('renamed-agent');
+        const notFound = updateAgent('nonexistent', { name: 'x' });
+        expect(notFound).toBeNull();
+    });
+});

package/dist/services/__tests__/heartbeat-service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/__tests__/heartbeat-service.test.js

@@ -0,0 +1,76 @@
+import { describe, it, expect } from 'vitest';
+import { eq } from 'drizzle-orm';
+import { testDb } from '../../__tests__/setup.js';
+import { agents } from '../../db/schema.js';
+function seedAgent(id, name, heartbeatAge) {
+    const now = Date.now();
+    testDb
+        .insert(agents)
+        .values({
+        id,
+        name,
+        displayName: name,
+        url: `http://${name}`,
+        status: 'online',
+        lastHeartbeat: now - heartbeatAge,
+        createdAt: now,
+        updatedAt: now,
+    })
+        .run();
+}
+describe('HeartbeatService', () => {
+    it('heartbeat update changes lastHeartbeat timestamp', () => {
+        seedAgent('a1', 'agent-fresh', 0);
+        const before = testDb
+            .select({ lastHeartbeat: agents.lastHeartbeat })
+            .from(agents)
+            .where(eq(agents.id, 'a1'))
+            .get();
+        const newTs = Date.now() + 5000;
+        testDb
+            .update(agents)
+            .set({ lastHeartbeat: newTs, updatedAt: newTs })
+            .where(eq(agents.id, 'a1'))
+            .run();
+        const after = testDb
+            .select({ lastHeartbeat: agents.lastHeartbeat })
+            .from(agents)
+            .where(eq(agents.id, 'a1'))
+            .get();
+        expect(after.lastHeartbeat).toBe(newTs);
+        expect(after.lastHeartbeat).not.toBe(before.lastHeartbeat);
+    });
+    it('stale agents are marked offline when heartbeat exceeds timeout', async () => {
+        const STALE_TIMEOUT_MS = 90_000;
+        seedAgent('stale-1', 'stale-agent', STALE_TIMEOUT_MS + 10_000);
+        seedAgent('fresh-1', 'fresh-agent', 5_000);
+        const { lt, and, ne } = await import('drizzle-orm');
+        const cutoff = Date.now() - STALE_TIMEOUT_MS;
+        const staleAgents = testDb
+            .select({ id: agents.id, name: agents.name })
+            .from(agents)
+            .where(and(lt(agents.lastHeartbeat, cutoff), ne(agents.status, 'offline')))
+            .all();
+        expect(staleAgents).toHaveLength(1);
+        expect(staleAgents[0].name).toBe('stale-agent');
+        for (const agent of staleAgents) {
+            testDb
+                .update(agents)
+                .set({ status: 'offline', updatedAt: Date.now() })
+                .where(eq(agents.id, agent.id))
+                .run();
+        }
+        const staleRecord = testDb
+            .select({ status: agents.status })
+            .from(agents)
+            .where(eq(agents.id, 'stale-1'))
+            .get();
+        expect(staleRecord.status).toBe('offline');
+        const freshRecord = testDb
+            .select({ status: agents.status })
+            .from(agents)
+            .where(eq(agents.id, 'fresh-1'))
+            .get();
+        expect(freshRecord.status).toBe('online');
+    });
+});

package/dist/services/__tests__/message-service.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/services/__tests__/message-service.test.js

@@ -0,0 +1,85 @@
+import { describe, it, expect } from 'vitest';
+import { createMessage, getMessagesForAgent, getMessageById, getConversation, MessageSizeError, } from '../../services/message-service.js';
+import { testDb } from '../../__tests__/setup.js';
+import { agents } from '../../db/schema.js';
+function seedAgent(id, name) {
+    testDb
+        .insert(agents)
+        .values({
+        id,
+        name,
+        displayName: name,
+        url: `http://${name}`,
+        status: 'online',
+        lastHeartbeat: Date.now(),
+        createdAt: Date.now(),
+        updatedAt: Date.now(),
+    })
+        .run();
+}
+describe('MessageService', () => {
+    it('createMessage stores and returns a message', () => {
+        seedAgent('a1', 'alice');
+        seedAgent('a2', 'bob');
+        const msg = createMessage({
+            from: 'a1',
+            to: 'a2',
+            senderType: 'agent',
+            content: 'hello bob',
+            type: 'notification',
+        });
+        expect(msg).not.toBeInstanceOf(Array);
+        const single = msg;
+        expect(single.id).toBeDefined();
+        expect(single.from).toBe('a1');
+        expect(single.to).toBe('a2');
+        expect(single.content).toBe('hello bob');
+        expect(single.read).toBe(false);
+    });
+    it('getMessagesForAgent returns messages addressed to agent', () => {
+        seedAgent('a1', 'alice');
+        seedAgent('a2', 'bob');
+        createMessage({ from: 'a1', to: 'a2', senderType: 'agent', content: 'msg-1', type: 'notification' });
+        createMessage({ from: 'a1', to: 'a2', senderType: 'agent', content: 'msg-2', type: 'notification' });
+        const msgs = getMessagesForAgent('a2');
+        expect(msgs).toHaveLength(2);
+        expect(msgs.every((m) => m.to === 'a2')).toBe(true);
+    });
+    it('broadcast creates messages for all online agents except sender', () => {
+        seedAgent('a1', 'alice');
+        seedAgent('a2', 'bob');
+        seedAgent('a3', 'carol');
+        const result = createMessage({
+            from: 'a1',
+            to: 'broadcast',
+            senderType: 'agent',
+            content: 'hey everyone',
+            type: 'notification',
+        });
+        expect(Array.isArray(result)).toBe(true);
+        const msgs = result;
+        expect(msgs).toHaveLength(2);
+    });
+    it('rejects oversized message content', () => {
+        seedAgent('a1', 'alice');
+        seedAgent('a2', 'bob');
+        const bigContent = 'x'.repeat(1_048_577);
+        expect(() => createMessage({ from: 'a1', to: 'a2', senderType: 'agent', content: bigContent, type: 'notification' })).toThrow(MessageSizeError);
+    });
+    it('getConversation returns messages between two agents in order', () => {
+        seedAgent('a1', 'alice');
+        seedAgent('a2', 'bob');
+        createMessage({ from: 'a1', to: 'a2', senderType: 'agent', content: 'hi bob', type: 'notification' });
+        createMessage({ from: 'a2', to: 'a1', senderType: 'agent', content: 'hi alice', type: 'notification' });
+        createMessage({ from: 'a1', to: 'a2', senderType: 'agent', content: 'how are you?', type: 'notification' });
+        const convo = getConversation('a1', 'a2');
+        expect(convo).toHaveLength(3);
+        expect(convo[0].content).toBe('hi bob');
+        expect(convo[1].content).toBe('hi alice');
+        expect(convo[2].content).toBe('how are you?');
+    });
+    it('getMessageById returns null for nonexistent message', () => {
+        const result = getMessageById('nonexistent');
+        expect(result).toBeNull();
+    });
+});

package/dist/services/agent-service.d.ts

@@ -0,0 +1,74 @@
+import type { RegisterAgentRequest } from '@swarmroom/shared';
+export declare function createAgent(input: RegisterAgentRequest): {
+    agentCard: any;
+    teamIds: string[];
+    projectIds: string[];
+    id: string;
+    name: string;
+    displayName: string | null;
+    url: string;
+    status: string | null;
+    lastHeartbeat: number | null;
+    createdAt: number | null;
+    updatedAt: number | null;
+} | null;
+export declare function listAgents(filters?: {
+    status?: string;
+    teamId?: string;
+    projectId?: string;
+}): {
+    id: string;
+    name: string;
+    displayName: string | null;
+    url: string;
+    status: string | null;
+    agentCard: string | null;
+    lastHeartbeat: number | null;
+    createdAt: number | null;
+    updatedAt: number | null;
+}[];
+export declare function getAgentById(id: string): {
+    agentCard: any;
+    teamIds: string[];
+    projectIds: string[];
+    id: string;
+    name: string;
+    displayName: string | null;
+    url: string;
+    status: string | null;
+    lastHeartbeat: number | null;
+    createdAt: number | null;
+    updatedAt: number | null;
+} | null;
+export declare function updateAgent(id: string, updates: Partial<{
+    name: string;
+    url: string;
+    status: string;
+    agentCard: string;
+}>): {
+    agentCard: any;
+    teamIds: string[];
+    projectIds: string[];
+    id: string;
+    name: string;
+    displayName: string | null;
+    url: string;
+    status: string | null;
+    lastHeartbeat: number | null;
+    createdAt: number | null;
+    updatedAt: number | null;
+} | null;
+export declare function deregisterAgent(id: string): {
+    agentCard: any;
+    teamIds: string[];
+    projectIds: string[];
+    id: string;
+    name: string;
+    displayName: string | null;
+    url: string;
+    status: string | null;
+    lastHeartbeat: number | null;
+    createdAt: number | null;
+    updatedAt: number | null;
+} | null;
+export declare function getAgentCount(): number;