@swarmroom/server 0.1.0

package/dist/db/schema.js

@@ -0,0 +1,61 @@
+import { sqliteTable, text, integer, primaryKey } from "drizzle-orm/sqlite-core";
+import { sql } from "drizzle-orm";
+// ─── Agents ─────────────────────────────────────────────────────────────────
+export const agents = sqliteTable("agents", {
+    id: text("id").primaryKey(),
+    name: text("name").unique().notNull(),
+    displayName: text("display_name"),
+    url: text("url").notNull(),
+    status: text("status").default("online"),
+    agentCard: text("agent_card"), // JSON blob
+    lastHeartbeat: integer("last_heartbeat"),
+    createdAt: integer("created_at").default(sql `(unixepoch() * 1000)`),
+    updatedAt: integer("updated_at"),
+});
+// ─── Messages ───────────────────────────────────────────────────────────────
+export const messages = sqliteTable("messages", {
+    id: text("id").primaryKey(),
+    fromAgentId: text("from_agent_id").notNull(),
+    toAgentId: text("to_agent_id").notNull(),
+    senderType: text("sender_type").default("agent"),
+    content: text("content").notNull(),
+    type: text("type").default("notification"),
+    replyTo: text("reply_to"),
+    metadata: text("metadata"), // JSON blob
+    read: integer("read").default(0),
+    createdAt: integer("created_at").default(sql `(unixepoch() * 1000)`),
+});
+// ─── Teams ──────────────────────────────────────────────────────────────────
+export const teams = sqliteTable("teams", {
+    id: text("id").primaryKey(),
+    name: text("name").unique().notNull(),
+    description: text("description"),
+    color: text("color").default("#6366f1"),
+    createdAt: integer("created_at").default(sql `(unixepoch() * 1000)`),
+});
+// ─── Project Groups ─────────────────────────────────────────────────────────
+export const projectGroups = sqliteTable("project_groups", {
+    id: text("id").primaryKey(),
+    name: text("name").unique().notNull(),
+    description: text("description"),
+    repository: text("repository"),
+    createdAt: integer("created_at").default(sql `(unixepoch() * 1000)`),
+});
+// ─── Agent ↔ Team (Junction) ───────────────────────────────────────────────
+export const agentTeams = sqliteTable("agent_teams", {
+    agentId: text("agent_id")
+        .notNull()
+        .references(() => agents.id),
+    teamId: text("team_id")
+        .notNull()
+        .references(() => teams.id),
+}, (table) => [primaryKey({ columns: [table.agentId, table.teamId] })]);
+// ─── Agent ↔ Project (Junction) ────────────────────────────────────────────
+export const agentProjects = sqliteTable("agent_projects", {
+    agentId: text("agent_id")
+        .notNull()
+        .references(() => agents.id),
+    projectId: text("project_id")
+        .notNull()
+        .references(() => projectGroups.id),
+}, (table) => [primaryKey({ columns: [table.agentId, table.projectId] })]);

package/dist/db/seed.d.ts

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

package/dist/db/seed.js

@@ -0,0 +1,15 @@
+import { randomUUID } from "node:crypto";
+import { db, teams } from "./index.js";
+const seedTeams = [
+    { id: randomUUID(), name: "Frontend", description: "Frontend development team", color: "#3b82f6" },
+    { id: randomUUID(), name: "Backend", description: "Backend development team", color: "#10b981" },
+    { id: randomUUID(), name: "QA", description: "Quality assurance team", color: "#f59e0b" },
+    { id: randomUUID(), name: "DevOps", description: "DevOps and infrastructure team", color: "#8b5cf6" },
+];
+for (const team of seedTeams) {
+    db.insert(teams)
+        .values(team)
+        .onConflictDoNothing()
+        .run();
+}
+console.log(`Seeded ${seedTeams.length} teams`);

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,30 @@
+import { serve } from '@hono/node-server';
+import { createNodeWebSocket } from '@hono/node-ws';
+import { DEFAULT_PORT } from '@swarmroom/shared';
+import { app } from './app.js';
+import { registerWsRoute } from './routes/ws.js';
+import { startHeartbeatChecker, stopHeartbeatChecker, } from './services/heartbeat-service.js';
+import { startMdns, stopMdns } from './services/mdns-service.js';
+import { startBrowsing, stopBrowsing } from './services/mdns-browser.js';
+const { injectWebSocket, upgradeWebSocket } = createNodeWebSocket({ app });
+registerWsRoute(app, upgradeWebSocket);
+const port = Number(process.env.PORT) || DEFAULT_PORT;
+console.log(`Starting SwarmRoom Hub on port ${port}...`);
+const server = serve({
+    fetch: app.fetch,
+    port,
+}, (info) => {
+    console.log(`SwarmRoom Hub listening on http://localhost:${info.port}`);
+    startHeartbeatChecker();
+    startMdns(info.port);
+    startBrowsing();
+});
+injectWebSocket(server);
+async function shutdown() {
+    stopBrowsing();
+    await stopMdns();
+    stopHeartbeatChecker();
+    process.exit(0);
+}
+process.on('SIGTERM', () => { shutdown(); });
+process.on('SIGINT', () => { shutdown(); });

package/dist/lib/names.d.ts

@@ -0,0 +1 @@
+export declare function generateDisplayName(): string;

package/dist/lib/names.js

@@ -0,0 +1,32 @@
+const ADJECTIVES = [
+    'Swift', 'Bright', 'Silent', 'Cosmic', 'Emerald',
+    'Golden', 'Crimson', 'Azure', 'Lunar', 'Solar',
+    'Iron', 'Crystal', 'Shadow', 'Amber', 'Silver',
+    'Frost', 'Thunder', 'Velvet', 'Obsidian', 'Sapphire',
+    'Neon', 'Scarlet', 'Cobalt', 'Jade', 'Onyx',
+    'Radiant', 'Vivid', 'Blazing', 'Mystic', 'Nimble',
+    'Rapid', 'Keen', 'Bold', 'Calm', 'Fierce',
+    'Noble', 'Phantom', 'Primal', 'Quiet', 'Royal',
+    'Stark', 'Turbo', 'Ultra', 'Warp', 'Zenith',
+    'Dusk', 'Dawn', 'Storm', 'Coral', 'Rune',
+    'Polar', 'Titan', 'Echo', 'Nova', 'Apex',
+];
+const NOUNS = [
+    'Falcon', 'Phoenix', 'Cascade', 'Nebula', 'Prism',
+    'Vortex', 'Cipher', 'Beacon', 'Spark', 'Pulse',
+    'Quasar', 'Raven', 'Lynx', 'Panda', 'Otter',
+    'Hawk', 'Wolf', 'Tiger', 'Cobra', 'Eagle',
+    'Arrow', 'Blade', 'Forge', 'Nexus', 'Orbit',
+    'Shard', 'Flux', 'Drift', 'Comet', 'Flare',
+    'Bolt', 'Surge', 'Wave', 'Reef', 'Peak',
+    'Ridge', 'Mesa', 'Dune', 'Grove', 'Crest',
+    'Arc', 'Gate', 'Lens', 'Core', 'Node',
+    'Link', 'Atlas', 'Helix', 'Opal', 'Pixel',
+    'Vertex', 'Lotus', 'Sonic', 'Rogue', 'Sage',
+];
+function pickRandom(arr) {
+    return arr[Math.floor(Math.random() * arr.length)];
+}
+export function generateDisplayName() {
+    return `${pickRandom(ADJECTIVES)}${pickRandom(NOUNS)}`;
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare const mcpServer: McpServer;

package/dist/mcp/server.js

@@ -0,0 +1,154 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { z } from 'zod/v4';
+import { MCP_TOOL_NAMES } from '@swarmroom/shared';
+import { listAgents, getAgentById, } from '../services/agent-service.js';
+import { createMessage, getMessagesForAgent, } from '../services/message-service.js';
+import { listTeams } from '../services/team-service.js';
+import { listProjects } from '../services/project-service.js';
+function textResult(data) {
+    return { content: [{ type: 'text', text: JSON.stringify(data) }] };
+}
+export const mcpServer = new McpServer({
+    name: 'swarmroom',
+    version: '0.1.0',
+});
+// ─── list_agents ─────────────────────────────────────────────────────────────
+mcpServer.tool(MCP_TOOL_NAMES.LIST_AGENTS, 'List all agents registered in SwarmRoom. Optionally filter by status or team.', {
+    status: z.string().optional().describe('Filter by agent status (online, offline)'),
+    team_id: z.string().optional().describe('Filter by team ID'),
+    project_id: z.string().optional().describe('Filter by project ID'),
+}, async ({ status, team_id, project_id }) => {
+    const agents = listAgents({
+        status: status ?? undefined,
+        teamId: team_id ?? undefined,
+        projectId: project_id ?? undefined,
+    });
+    return textResult(agents);
+});
+// ─── get_agent_info ──────────────────────────────────────────────────────────
+mcpServer.tool(MCP_TOOL_NAMES.GET_AGENT_INFO, 'Get detailed information about a specific agent by ID or name.', {
+    id: z.string().optional().describe('Agent UUID'),
+    name: z.string().optional().describe('Agent name (exact match)'),
+}, async ({ id, name }) => {
+    if (!id && !name) {
+        return textResult({ error: 'Provide either id or name' });
+    }
+    if (id) {
+        const agent = getAgentById(id);
+        if (!agent) {
+            return textResult({ error: `Agent not found: ${id}` });
+        }
+        return textResult(agent);
+    }
+    const agents = listAgents();
+    const match = agents.find((a) => a.name === name);
+    if (!match) {
+        return textResult({ error: `Agent not found with name: ${name}` });
+    }
+    const agent = getAgentById(match.id);
+    return textResult(agent);
+});
+// ─── send_message ────────────────────────────────────────────────────────────
+mcpServer.tool(MCP_TOOL_NAMES.SEND_MESSAGE, 'Send a message from one agent to another.', {
+    from: z.string().describe('Sender agent ID'),
+    to: z.string().describe('Recipient agent ID or "broadcast"'),
+    content: z.string().describe('Message content'),
+    type: z
+        .enum(['notification', 'query', 'response', 'broadcast'])
+        .optional()
+        .describe('Message type (default: notification)'),
+    reply_to: z.string().optional().describe('ID of message being replied to'),
+    metadata: z
+        .record(z.string(), z.unknown())
+        .optional()
+        .describe('Optional metadata object'),
+}, async ({ from, to, content, type, reply_to, metadata }) => {
+    try {
+        const result = createMessage({
+            from,
+            to,
+            senderType: 'agent',
+            content,
+            type: type ?? 'notification',
+            replyTo: reply_to ?? undefined,
+            metadata: metadata ?? undefined,
+        });
+        return textResult(result);
+    }
+    catch (err) {
+        return textResult({ error: err.message });
+    }
+});
+// ─── get_messages ────────────────────────────────────────────────────────────
+mcpServer.tool(MCP_TOOL_NAMES.GET_MESSAGES, 'Get messages for a specific agent.', {
+    agent_id: z.string().describe('Agent ID to get messages for'),
+    since: z
+        .string()
+        .optional()
+        .describe('Timestamp (ms since epoch) — only return messages after this time'),
+    limit: z.number().optional().describe('Max number of messages to return (default 50)'),
+    type: z
+        .enum(['notification', 'query', 'response', 'broadcast'])
+        .optional()
+        .describe('Filter by message type'),
+}, async ({ agent_id, since, limit, type }) => {
+    const messages = getMessagesForAgent(agent_id, {
+        since: since ?? undefined,
+        limit: limit ?? undefined,
+        type: type ?? undefined,
+    });
+    return textResult(messages);
+});
+// ─── query_agent ─────────────────────────────────────────────────────────────
+mcpServer.tool(MCP_TOOL_NAMES.QUERY_AGENT, 'Send a query message to an agent and poll for a response. Returns the reply or times out.', {
+    from: z.string().describe('Sender agent ID'),
+    to: z.string().describe('Target agent ID to query'),
+    content: z.string().describe('Query content'),
+    timeout_seconds: z
+        .number()
+        .optional()
+        .describe('How long to wait for a reply in seconds (default 30)'),
+}, async ({ from, to, content, timeout_seconds }) => {
+    try {
+        const queryMsg = createMessage({
+            from,
+            to,
+            senderType: 'agent',
+            content,
+            type: 'query',
+        });
+        const sentMsg = Array.isArray(queryMsg) ? queryMsg[0] : queryMsg;
+        if (!sentMsg) {
+            return textResult({ error: 'Failed to send query message' });
+        }
+        const timeout = (timeout_seconds ?? 30) * 1000;
+        const pollInterval = 500;
+        const deadline = Date.now() + timeout;
+        while (Date.now() < deadline) {
+            const replies = getMessagesForAgent(from, { type: 'response' });
+            const reply = replies.find((m) => m.replyTo === sentMsg.id);
+            if (reply) {
+                return textResult({ query: sentMsg, reply });
+            }
+            await new Promise((resolve) => setTimeout(resolve, pollInterval));
+        }
+        return textResult({
+            query: sentMsg,
+            reply: null,
+            error: `No response received within ${timeout_seconds ?? 30} seconds`,
+        });
+    }
+    catch (err) {
+        return textResult({ error: err.message });
+    }
+});
+// ─── list_teams ──────────────────────────────────────────────────────────────
+mcpServer.tool(MCP_TOOL_NAMES.LIST_TEAMS, 'List all teams with member counts.', {}, async () => {
+    const teams = listTeams();
+    return textResult(teams);
+});
+// ─── list_projects ───────────────────────────────────────────────────────────
+mcpServer.tool(MCP_TOOL_NAMES.LIST_PROJECTS, 'List all project groups with member counts.', {}, async () => {
+    const projects = listProjects();
+    return textResult(projects);
+});

package/dist/mcp/transport.d.ts

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

package/dist/mcp/transport.js

@@ -0,0 +1,27 @@
+import { Hono } from 'hono';
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { mcpServer } from './server.js';
+const transports = new Map();
+function createSessionTransport() {
+    const transport = new WebStandardStreamableHTTPServerTransport({
+        sessionIdGenerator: () => crypto.randomUUID(),
+        onsessioninitialized: (sessionId) => {
+            transports.set(sessionId, transport);
+        },
+        onsessionclosed: (sessionId) => {
+            transports.delete(sessionId);
+        },
+    });
+    return transport;
+}
+export const mcpRoute = new Hono();
+mcpRoute.all('/', async (c) => {
+    const sessionId = c.req.header('mcp-session-id');
+    if (sessionId && transports.has(sessionId)) {
+        const transport = transports.get(sessionId);
+        return transport.handleRequest(c.req.raw);
+    }
+    const transport = createSessionTransport();
+    await mcpServer.connect(transport);
+    return transport.handleRequest(c.req.raw);
+});

package/dist/middleware/cors.d.ts

@@ -0,0 +1 @@
+export declare const corsMiddleware: import("hono").MiddlewareHandler;

package/dist/middleware/cors.js

@@ -0,0 +1,8 @@
+import { cors } from 'hono/cors';
+export const corsMiddleware = cors({
+    origin: '*',
+    allowMethods: ['GET', 'HEAD', 'PUT', 'POST', 'DELETE', 'PATCH'],
+    allowHeaders: ['Content-Type', 'Authorization'],
+    exposeHeaders: ['Content-Length'],
+    maxAge: 600,
+});

package/dist/middleware/error-handler.d.ts

@@ -0,0 +1,2 @@
+import type { ErrorHandler } from 'hono';
+export declare const errorHandler: ErrorHandler;

package/dist/middleware/error-handler.js

@@ -0,0 +1,10 @@
+export const errorHandler = (err, c) => {
+    console.error(`[ERROR] ${err.message}`, err.stack);
+    const status = 'status' in err && typeof err.status === 'number' ? err.status : 500;
+    return c.json({
+        success: false,
+        error: {
+            message: status === 500 ? 'Internal Server Error' : err.message,
+        },
+    }, status);
+};

package/dist/routes/__tests__/agents.test.d.ts

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

package/dist/routes/__tests__/agents.test.js

@@ -0,0 +1,80 @@
+import { describe, it, expect } from 'vitest';
+import { Hono } from 'hono';
+import { errorHandler } from '../../middleware/error-handler.js';
+import { agentsRoute } from '../../routes/agents.js';
+function createTestApp() {
+    const app = new Hono();
+    app.onError(errorHandler);
+    app.route('/api/agents', agentsRoute);
+    return app;
+}
+describe('Agents Route', () => {
+    it('POST /api/agents → 201 with agent data', async () => {
+        const app = createTestApp();
+        const res = await app.request('/api/agents', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: 'route-agent', url: 'http://localhost:8000' }),
+        });
+        expect(res.status).toBe(201);
+        const json = await res.json();
+        expect(json.success).toBe(true);
+        expect(json.data.name).toBe('route-agent');
+        expect(json.data.id).toBeDefined();
+        expect(json.data.displayName).toBeTruthy();
+        expect(json.data.status).toBe('online');
+    });
+    it('GET /api/agents → 200 with list', async () => {
+        const app = createTestApp();
+        await app.request('/api/agents', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: 'list-agent-1', url: 'http://a' }),
+        });
+        await app.request('/api/agents', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: 'list-agent-2', url: 'http://b' }),
+        });
+        const res = await app.request('/api/agents');
+        expect(res.status).toBe(200);
+        const json = await res.json();
+        expect(json.success).toBe(true);
+        expect(json.data).toHaveLength(2);
+    });
+    it('GET /api/agents/:id → 200 with agent detail', async () => {
+        const app = createTestApp();
+        const createRes = await app.request('/api/agents', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ name: 'detail-agent', url: 'http://detail' }),
+        });
+        const created = await createRes.json();
+        const id = created.data.id;
+        const res = await app.request(`/api/agents/${id}`);
+        expect(res.status).toBe(200);
+        const json = await res.json();
+        expect(json.success).toBe(true);
+        expect(json.data.id).toBe(id);
+        expect(json.data.name).toBe('detail-agent');
+        expect(json.data.teamIds).toEqual([]);
+    });
+    it('GET /api/agents/:id → 404 for nonexistent agent', async () => {
+        const app = createTestApp();
+        const res = await app.request('/api/agents/nonexistent-id');
+        expect(res.status).toBe(404);
+        const json = await res.json();
+        expect(json.success).toBe(false);
+    });
+    it('POST /api/agents → 400 for invalid body', async () => {
+        const app = createTestApp();
+        const res = await app.request('/api/agents', {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({ invalid: true }),
+        });
+        expect(res.status).toBe(400);
+        const json = await res.json();
+        expect(json.success).toBe(false);
+    });
+});

package/dist/routes/agents.d.ts

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

package/dist/routes/agents.js

@@ -0,0 +1,100 @@
+import { Hono } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import { eq } from 'drizzle-orm';
+import { RegisterAgentRequestSchema, HeartbeatRequestSchema, HEARTBEAT_INTERVAL_MS, } from '@swarmroom/shared';
+import { db, agents } from '../db/index.js';
+import { createAgent, listAgents, getAgentById, updateAgent, deregisterAgent, } from '../services/agent-service.js';
+import { broadcastAgentOnline, broadcastAgentOffline } from '../services/ws-manager.js';
+const agentsRoute = new Hono();
+agentsRoute.post('/', async (c) => {
+    const body = await c.req.json();
+    const parsed = RegisterAgentRequestSchema.safeParse(body);
+    if (!parsed.success) {
+        throw new HTTPException(400, {
+            message: `Invalid request body: ${parsed.error.issues.map((i) => i.message).join(', ')}`,
+        });
+    }
+    try {
+        const agent = createAgent(parsed.data);
+        if (agent) {
+            broadcastAgentOnline({ id: agent.id, name: agent.name });
+        }
+        return c.json({ success: true, data: agent }, 201);
+    }
+    catch (err) {
+        if (err instanceof Error && err.message.includes('UNIQUE constraint failed')) {
+            throw new HTTPException(409, {
+                message: `Agent with name "${parsed.data.name}" already exists`,
+            });
+        }
+        throw err;
+    }
+});
+agentsRoute.get('/', (c) => {
+    const status = c.req.query('status');
+    const teamId = c.req.query('teamId');
+    const projectId = c.req.query('projectId');
+    const result = listAgents({ status, teamId, projectId });
+    return c.json({ success: true, data: result });
+});
+agentsRoute.get('/:id', (c) => {
+    const id = c.req.param('id');
+    const agent = getAgentById(id);
+    if (!agent) {
+        throw new HTTPException(404, { message: `Agent "${id}" not found` });
+    }
+    return c.json({ success: true, data: agent });
+});
+agentsRoute.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.url !== undefined)
+        updates.url = body.url;
+    if (body.status !== undefined)
+        updates.status = body.status;
+    if (body.agentCard !== undefined) {
+        updates.agentCard = JSON.stringify(body.agentCard);
+    }
+    const agent = updateAgent(id, updates);
+    if (!agent) {
+        throw new HTTPException(404, { message: `Agent "${id}" not found` });
+    }
+    return c.json({ success: true, data: agent });
+});
+agentsRoute.delete('/:id', (c) => {
+    const id = c.req.param('id');
+    const agent = deregisterAgent(id);
+    if (!agent) {
+        throw new HTTPException(404, { message: `Agent "${id}" not found` });
+    }
+    broadcastAgentOffline({ id: agent.id, name: agent.name });
+    return c.json({ success: true, data: agent });
+});
+agentsRoute.post('/:id/heartbeat', async (c) => {
+    const id = c.req.param('id');
+    const body = await c.req.json();
+    const parsed = HeartbeatRequestSchema.safeParse(body);
+    if (!parsed.success) {
+        throw new HTTPException(400, {
+            message: `Invalid request body: ${parsed.error.issues.map((i) => i.message).join(', ')}`,
+        });
+    }
+    const existing = db.select({ id: agents.id }).from(agents).where(eq(agents.id, id)).get();
+    if (!existing) {
+        throw new HTTPException(404, { message: `Agent "${id}" not found` });
+    }
+    const now = Date.now();
+    const updates = {
+        lastHeartbeat: now,
+        updatedAt: now,
+    };
+    if (parsed.data.status) {
+        updates.status = parsed.data.status;
+    }
+    db.update(agents).set(updates).where(eq(agents.id, id)).run();
+    return c.json({ status: 'ok', interval: HEARTBEAT_INTERVAL_MS });
+});
+export { agentsRoute };

package/dist/routes/health.d.ts

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

package/dist/routes/health.js

@@ -0,0 +1,14 @@
+import { Hono } from 'hono';
+import { getAgentCount } from '../services/agent-service.js';
+const health = new Hono();
+const startTime = Date.now();
+health.get('/health', (c) => {
+    const uptimeSeconds = Math.floor((Date.now() - startTime) / 1000);
+    return c.json({
+        status: 'ok',
+        version: '0.1.0',
+        uptime: uptimeSeconds,
+        agentCount: getAgentCount(),
+    });
+});
+export { health };

package/dist/routes/messages.d.ts

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

package/dist/routes/messages.js

@@ -0,0 +1,65 @@
+import { Hono } from 'hono';
+import { HTTPException } from 'hono/http-exception';
+import { SendMessageRequestSchema } from '@swarmroom/shared';
+import { createMessage, getMessagesForAgent, getMessageById, markMessageAsRead, getConversation, MessageSizeError, InvalidReplyError, } from '../services/message-service.js';
+const messagesRoute = new Hono();
+messagesRoute.post('/', async (c) => {
+    const body = await c.req.json();
+    const parsed = SendMessageRequestSchema.safeParse(body);
+    if (!parsed.success) {
+        throw new HTTPException(400, {
+            message: `Invalid request body: ${parsed.error.issues.map((i) => i.message).join(', ')}`,
+        });
+    }
+    try {
+        const result = createMessage(parsed.data);
+        return c.json({ success: true, data: result }, 201);
+    }
+    catch (err) {
+        if (err instanceof MessageSizeError) {
+            throw new HTTPException(400, { message: err.message });
+        }
+        if (err instanceof InvalidReplyError) {
+            throw new HTTPException(400, { message: err.message });
+        }
+        throw err;
+    }
+});
+messagesRoute.get('/', (c) => {
+    const agentId = c.req.query('agentId');
+    if (!agentId) {
+        throw new HTTPException(400, { message: 'Query parameter "agentId" is required' });
+    }
+    const since = c.req.query('since');
+    const limitParam = c.req.query('limit');
+    const type = c.req.query('type');
+    const limit = limitParam ? Number(limitParam) : 50;
+    if (Number.isNaN(limit) || limit < 1) {
+        throw new HTTPException(400, { message: 'Query parameter "limit" must be a positive integer' });
+    }
+    const result = getMessagesForAgent(agentId, { since: since ?? undefined, limit, type: type ?? undefined });
+    return c.json({ success: true, data: result });
+});
+messagesRoute.get('/conversation/:agentA/:agentB', (c) => {
+    const agentA = c.req.param('agentA');
+    const agentB = c.req.param('agentB');
+    const result = getConversation(agentA, agentB);
+    return c.json({ success: true, data: result });
+});
+messagesRoute.get('/:id', (c) => {
+    const id = c.req.param('id');
+    const message = getMessageById(id);
+    if (!message) {
+        throw new HTTPException(404, { message: `Message "${id}" not found` });
+    }
+    return c.json({ success: true, data: message });
+});
+messagesRoute.patch('/:id/read', (c) => {
+    const id = c.req.param('id');
+    const message = markMessageAsRead(id);
+    if (!message) {
+        throw new HTTPException(404, { message: `Message "${id}" not found` });
+    }
+    return c.json({ success: true, data: message });
+});
+export { messagesRoute };

package/dist/routes/projects.d.ts

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