@swarmroom/server 0.1.0

package/dist/services/project-service.js

@@ -0,0 +1,104 @@
+import { eq, and, count } from 'drizzle-orm';
+import { db, projectGroups, agentProjects, agents } from '../db/index.js';
+export function createProject(input) {
+    const id = crypto.randomUUID();
+    const now = Date.now();
+    db.insert(projectGroups)
+        .values({
+        id,
+        name: input.name,
+        description: input.description ?? null,
+        repository: input.repository ?? null,
+        createdAt: now,
+    })
+        .run();
+    if (input.agentIds && input.agentIds.length > 0) {
+        for (const agentId of input.agentIds) {
+            db.insert(agentProjects).values({ agentId, projectId: id }).run();
+        }
+    }
+    return getProjectById(id);
+}
+export function listProjects() {
+    const allProjects = db.select().from(projectGroups).all();
+    return allProjects.map((project) => {
+        const result = db
+            .select({ value: count() })
+            .from(agentProjects)
+            .where(eq(agentProjects.projectId, project.id))
+            .get();
+        return {
+            ...project,
+            agentCount: result?.value ?? 0,
+        };
+    });
+}
+export function getProjectById(id) {
+    const project = db.select().from(projectGroups).where(eq(projectGroups.id, id)).get();
+    if (!project)
+        return null;
+    const memberRows = db
+        .select()
+        .from(agents)
+        .innerJoin(agentProjects, eq(agents.id, agentProjects.agentId))
+        .where(eq(agentProjects.projectId, id))
+        .all();
+    return {
+        ...project,
+        agents: memberRows.map((r) => ({
+            ...r.agents,
+            agentCard: r.agents.agentCard ? JSON.parse(r.agents.agentCard) : null,
+        })),
+    };
+}
+export function updateProject(id, updates) {
+    const existing = db.select().from(projectGroups).where(eq(projectGroups.id, id)).get();
+    if (!existing)
+        return null;
+    const values = {};
+    if (updates.name !== undefined)
+        values.name = updates.name;
+    if (updates.description !== undefined)
+        values.description = updates.description;
+    if (updates.repository !== undefined)
+        values.repository = updates.repository;
+    if (Object.keys(values).length > 0) {
+        db.update(projectGroups).set(values).where(eq(projectGroups.id, id)).run();
+    }
+    return getProjectById(id);
+}
+export function deleteProject(id) {
+    const existing = db.select().from(projectGroups).where(eq(projectGroups.id, id)).get();
+    if (!existing)
+        return null;
+    db.delete(agentProjects).where(eq(agentProjects.projectId, id)).run();
+    db.delete(projectGroups).where(eq(projectGroups.id, id)).run();
+    return existing;
+}
+export function addAgentToProject(projectId, agentId) {
+    const project = db.select().from(projectGroups).where(eq(projectGroups.id, projectId)).get();
+    if (!project)
+        return { error: 'project_not_found' };
+    const agent = db.select().from(agents).where(eq(agents.id, agentId)).get();
+    if (!agent)
+        return { error: 'agent_not_found' };
+    db.insert(agentProjects).values({ agentId, projectId }).run();
+    return { data: getProjectById(projectId) };
+}
+export function removeAgentFromProject(projectId, agentId) {
+    const project = db.select().from(projectGroups).where(eq(projectGroups.id, projectId)).get();
+    if (!project)
+        return { error: 'project_not_found' };
+    const membership = db
+        .select()
+        .from(agentProjects)
+        .where(eq(agentProjects.projectId, projectId))
+        .all()
+        .find((r) => r.agentId === agentId);
+    if (!membership)
+        return { error: 'not_a_member' };
+    db.delete(agentProjects)
+        .where(and(eq(agentProjects.projectId, projectId), eq(agentProjects.agentId, agentId)))
+        .run();
+    return { data: getProjectById(projectId) };
+}

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

@@ -0,0 +1,130 @@
+import type { CreateTeamRequest } from '@swarmroom/shared';
+export declare function createTeam(input: CreateTeamRequest & {
+    color?: string;
+}): {
+    agents: {
+        agentCard: any;
+        id: string;
+        name: string;
+        displayName: string | null;
+        url: string;
+        status: string | null;
+        lastHeartbeat: number | null;
+        createdAt: number | null;
+        updatedAt: number | null;
+    }[];
+    id: string;
+    name: string;
+    description: string | null;
+    color: string | null;
+    createdAt: number | null;
+} | null;
+export declare function listTeams(): {
+    agentCount: number;
+    id: string;
+    name: string;
+    description: string | null;
+    color: string | null;
+    createdAt: number | null;
+}[];
+export declare function getTeamById(id: string): {
+    agents: {
+        agentCard: any;
+        id: string;
+        name: string;
+        displayName: string | null;
+        url: string;
+        status: string | null;
+        lastHeartbeat: number | null;
+        createdAt: number | null;
+        updatedAt: number | null;
+    }[];
+    id: string;
+    name: string;
+    description: string | null;
+    color: string | null;
+    createdAt: number | null;
+} | null;
+export declare function updateTeam(id: string, updates: Partial<{
+    name: string;
+    description: string;
+    color: string;
+}>): {
+    agents: {
+        agentCard: any;
+        id: string;
+        name: string;
+        displayName: string | null;
+        url: string;
+        status: string | null;
+        lastHeartbeat: number | null;
+        createdAt: number | null;
+        updatedAt: number | null;
+    }[];
+    id: string;
+    name: string;
+    description: string | null;
+    color: string | null;
+    createdAt: number | null;
+} | null;
+export declare function deleteTeam(id: string): {
+    id: string;
+    name: string;
+    description: string | null;
+    color: string | null;
+    createdAt: number | null;
+} | null;
+export declare function addAgentToTeam(teamId: string, agentId: string): {
+    error: "team_not_found";
+    data?: undefined;
+} | {
+    error: "agent_not_found";
+    data?: undefined;
+} | {
+    data: {
+        agents: {
+            agentCard: any;
+            id: string;
+            name: string;
+            displayName: string | null;
+            url: string;
+            status: string | null;
+            lastHeartbeat: number | null;
+            createdAt: number | null;
+            updatedAt: number | null;
+        }[];
+        id: string;
+        name: string;
+        description: string | null;
+        color: string | null;
+        createdAt: number | null;
+    } | null;
+    error?: undefined;
+};
+export declare function removeAgentFromTeam(teamId: string, agentId: string): {
+    error: "team_not_found";
+    data?: undefined;
+} | {
+    error: "not_a_member";
+    data?: undefined;
+} | {
+    data: {
+        agents: {
+            agentCard: any;
+            id: string;
+            name: string;
+            displayName: string | null;
+            url: string;
+            status: string | null;
+            lastHeartbeat: number | null;
+            createdAt: number | null;
+            updatedAt: number | null;
+        }[];
+        id: string;
+        name: string;
+        description: string | null;
+        color: string | null;
+        createdAt: number | null;
+    } | null;
+    error?: undefined;
+};

package/dist/services/team-service.js

@@ -0,0 +1,104 @@
+import { eq, and, count } from 'drizzle-orm';
+import { db, teams, agentTeams, agents } from '../db/index.js';
+export function createTeam(input) {
+    const id = crypto.randomUUID();
+    const now = Date.now();
+    db.insert(teams)
+        .values({
+        id,
+        name: input.name,
+        description: input.description ?? null,
+        color: input.color ?? '#6366f1',
+        createdAt: now,
+    })
+        .run();
+    if (input.agentIds && input.agentIds.length > 0) {
+        for (const agentId of input.agentIds) {
+            db.insert(agentTeams).values({ agentId, teamId: id }).run();
+        }
+    }
+    return getTeamById(id);
+}
+export function listTeams() {
+    const allTeams = db.select().from(teams).all();
+    return allTeams.map((team) => {
+        const result = db
+            .select({ value: count() })
+            .from(agentTeams)
+            .where(eq(agentTeams.teamId, team.id))
+            .get();
+        return {
+            ...team,
+            agentCount: result?.value ?? 0,
+        };
+    });
+}
+export function getTeamById(id) {
+    const team = db.select().from(teams).where(eq(teams.id, id)).get();
+    if (!team)
+        return null;
+    const memberRows = db
+        .select()
+        .from(agents)
+        .innerJoin(agentTeams, eq(agents.id, agentTeams.agentId))
+        .where(eq(agentTeams.teamId, id))
+        .all();
+    return {
+        ...team,
+        agents: memberRows.map((r) => ({
+            ...r.agents,
+            agentCard: r.agents.agentCard ? JSON.parse(r.agents.agentCard) : null,
+        })),
+    };
+}
+export function updateTeam(id, updates) {
+    const existing = db.select().from(teams).where(eq(teams.id, id)).get();
+    if (!existing)
+        return null;
+    const values = {};
+    if (updates.name !== undefined)
+        values.name = updates.name;
+    if (updates.description !== undefined)
+        values.description = updates.description;
+    if (updates.color !== undefined)
+        values.color = updates.color;
+    if (Object.keys(values).length > 0) {
+        db.update(teams).set(values).where(eq(teams.id, id)).run();
+    }
+    return getTeamById(id);
+}
+export function deleteTeam(id) {
+    const existing = db.select().from(teams).where(eq(teams.id, id)).get();
+    if (!existing)
+        return null;
+    db.delete(agentTeams).where(eq(agentTeams.teamId, id)).run();
+    db.delete(teams).where(eq(teams.id, id)).run();
+    return existing;
+}
+export function addAgentToTeam(teamId, agentId) {
+    const team = db.select().from(teams).where(eq(teams.id, teamId)).get();
+    if (!team)
+        return { error: 'team_not_found' };
+    const agent = db.select().from(agents).where(eq(agents.id, agentId)).get();
+    if (!agent)
+        return { error: 'agent_not_found' };
+    db.insert(agentTeams).values({ agentId, teamId }).run();
+    return { data: getTeamById(teamId) };
+}
+export function removeAgentFromTeam(teamId, agentId) {
+    const team = db.select().from(teams).where(eq(teams.id, teamId)).get();
+    if (!team)
+        return { error: 'team_not_found' };
+    const membership = db
+        .select()
+        .from(agentTeams)
+        .where(eq(agentTeams.teamId, teamId))
+        .all()
+        .find((r) => r.agentId === agentId);
+    if (!membership)
+        return { error: 'not_a_member' };
+    db.delete(agentTeams)
+        .where(and(eq(agentTeams.teamId, teamId), eq(agentTeams.agentId, agentId)))
+        .run();
+    return { data: getTeamById(teamId) };
+}

package/dist/services/ws-manager.d.ts

@@ -0,0 +1,19 @@
+import type { WSContext } from 'hono/ws';
+import type { WSMessageType } from '@swarmroom/shared';
+export declare function registerClient(clientId: string, ws: WSContext): void;
+export declare function unregisterClient(ws: WSContext): void;
+export declare function sendToClient(clientId: string, type: WSMessageType, payload: unknown): void;
+export declare function broadcast(type: WSMessageType, payload: unknown): void;
+export declare function sendToDashboards(type: WSMessageType, payload: unknown): void;
+export declare function sendToDaemons(type: WSMessageType, payload: unknown): void;
+export declare function hasActiveConnections(clientId: string): boolean;
+export declare function handleIncomingMessage(ws: WSContext, raw: string): void;
+export declare function broadcastAgentOnline(agent: {
+    id: string;
+    name: string;
+}): void;
+export declare function broadcastAgentOffline(agent: {
+    id: string;
+    name: string;
+}): void;
+export declare function pushMessageToRecipient(recipientId: string, message: unknown): void;

package/dist/services/ws-manager.js

@@ -0,0 +1,165 @@
+import { DAEMON_KEY } from '@swarmroom/shared';
+const DASHBOARD_KEY = '__dashboard__';
+const PING_INTERVAL_MS = 30_000;
+const PONG_TIMEOUT_MS = 10_000;
+const clients = new Map();
+const pingTimers = new Map();
+const pongTimers = new Map();
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+function makeMessage(type, payload) {
+    const msg = {
+        type,
+        payload,
+        timestamp: new Date().toISOString(),
+    };
+    return JSON.stringify(msg);
+}
+function safeSend(ws, data) {
+    try {
+        if (ws.readyState === 1) {
+            ws.send(data);
+        }
+    }
+    catch {
+    }
+}
+// ─── Ping/Pong ───────────────────────────────────────────────────────────────
+function startPing(ws) {
+    const interval = setInterval(() => {
+        if (ws.readyState !== 1) {
+            clearPing(ws);
+            return;
+        }
+        safeSend(ws, makeMessage('heartbeat', { ping: true }));
+        const timeout = setTimeout(() => {
+            console.log('[ws] Client failed pong check, closing connection');
+            ws.close(1000, 'pong timeout');
+        }, PONG_TIMEOUT_MS);
+        pongTimers.set(ws, timeout);
+    }, PING_INTERVAL_MS);
+    pingTimers.set(ws, interval);
+}
+function clearPing(ws) {
+    const interval = pingTimers.get(ws);
+    if (interval) {
+        clearInterval(interval);
+        pingTimers.delete(ws);
+    }
+    const timeout = pongTimers.get(ws);
+    if (timeout) {
+        clearTimeout(timeout);
+        pongTimers.delete(ws);
+    }
+}
+function handlePong(ws) {
+    const timeout = pongTimers.get(ws);
+    if (timeout) {
+        clearTimeout(timeout);
+        pongTimers.delete(ws);
+    }
+}
+// ─── Registration ────────────────────────────────────────────────────────────
+export function registerClient(clientId, ws) {
+    const existing = clients.get(clientId) ?? [];
+    existing.push(ws);
+    clients.set(clientId, existing);
+    startPing(ws);
+    console.log(`[ws] Client registered: ${clientId} (${existing.length} connection(s))`);
+}
+export function unregisterClient(ws) {
+    for (const [clientId, connections] of clients.entries()) {
+        const idx = connections.indexOf(ws);
+        if (idx !== -1) {
+            connections.splice(idx, 1);
+            console.log(`[ws] Client disconnected: ${clientId} (${connections.length} remaining)`);
+            if (connections.length === 0) {
+                clients.delete(clientId);
+            }
+            clearPing(ws);
+            return;
+        }
+    }
+    clearPing(ws);
+}
+// ─── Sending ─────────────────────────────────────────────────────────────────
+export function sendToClient(clientId, type, payload) {
+    const connections = clients.get(clientId);
+    if (!connections || connections.length === 0)
+        return;
+    const data = makeMessage(type, payload);
+    for (const ws of connections) {
+        safeSend(ws, data);
+    }
+}
+export function broadcast(type, payload) {
+    const data = makeMessage(type, payload);
+    for (const connections of clients.values()) {
+        for (const ws of connections) {
+            safeSend(ws, data);
+        }
+    }
+}
+export function sendToDashboards(type, payload) {
+    sendToClient(DASHBOARD_KEY, type, payload);
+}
+export function sendToDaemons(type, payload) {
+    sendToClient(DAEMON_KEY, type, payload);
+}
+export function hasActiveConnections(clientId) {
+    const connections = clients.get(clientId);
+    return !!connections && connections.length > 0;
+}
+// ─── Message Handling ────────────────────────────────────────────────────────
+export function handleIncomingMessage(ws, raw) {
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        safeSend(ws, makeMessage('error', { message: 'Invalid JSON' }));
+        return;
+    }
+    if (!parsed.type) {
+        safeSend(ws, makeMessage('error', { message: 'Missing "type" field' }));
+        return;
+    }
+    switch (parsed.type) {
+        case 'register': {
+            const payload = parsed.payload;
+            if (payload?.clientType === 'dashboard') {
+                registerClient(DASHBOARD_KEY, ws);
+                safeSend(ws, makeMessage('register', { status: 'ok', clientType: 'dashboard' }));
+            }
+            else if (payload?.clientType === 'daemon') {
+                registerClient(DAEMON_KEY, ws);
+                safeSend(ws, makeMessage('register', { status: 'ok', clientType: 'daemon' }));
+            }
+            else if (payload?.agentId) {
+                registerClient(payload.agentId, ws);
+                safeSend(ws, makeMessage('register', { status: 'ok', agentId: payload.agentId }));
+            }
+            else {
+                safeSend(ws, makeMessage('error', { message: 'Register requires agentId or clientType' }));
+            }
+            break;
+        }
+        case 'heartbeat': {
+            handlePong(ws);
+            break;
+        }
+        default: {
+            safeSend(ws, makeMessage('error', { message: `Unknown message type: ${parsed.type}` }));
+        }
+    }
+}
+// ─── Public Integration ──────────────────────────────────────────────────────
+export function broadcastAgentOnline(agent) {
+    broadcast('agent_online', { agentId: agent.id, name: agent.name });
+}
+export function broadcastAgentOffline(agent) {
+    broadcast('agent_offline', { agentId: agent.id, name: agent.name });
+}
+export function pushMessageToRecipient(recipientId, message) {
+    sendToClient(recipientId, 'message', message);
+    sendToDashboards('message', message);
+}

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@swarmroom/server",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "SwarmRoom hub server - HTTP, WebSocket, MCP, and mDNS services",
+  "keywords": ["swarmroom", "server", "hub", "mcp", "websocket"],
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/visual-z/swarm.git",
+    "directory": "packages/server"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js",
+    "./dist/*": "./dist/*"
+  },
+  "files": ["dist", "README.md", "LICENSE"],
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsx watch src/index.ts",
+    "start": "node dist/index.js",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@homebridge/ciao": "^1.3.5",
+    "@hono/node-server": "^1.19.9",
+    "@hono/node-ws": "^1.3.0",
+    "@modelcontextprotocol/sdk": "^1.26.0",
+    "@swarmroom/shared": "^0.1.0",
+    "better-sqlite3": "^12.6.2",
+    "drizzle-orm": "^0.45.1",
+    "hono": "^4.11.9",
+    "tsx": "^4.21.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
+    "drizzle-kit": "^0.31.9",
+    "vitest": "^4.0.18"
+  }
+}