@swarmroom/server 0.1.0

package/dist/services/agent-service.js

@@ -0,0 +1,131 @@
+import { eq, and, count, asc, desc, inArray } from 'drizzle-orm';
+import { db, agents, agentTeams, agentProjects } from '../db/index.js';
+import { generateDisplayName } from '../lib/names.js';
+function resolveUniqueDisplayName(existingNames, candidate) {
+    if (!existingNames.includes(candidate)) {
+        return candidate;
+    }
+    let suffix = 1;
+    while (existingNames.includes(`${candidate}-${suffix}`)) {
+        suffix++;
+    }
+    return `${candidate}-${suffix}`;
+}
+export function createAgent(input) {
+    const id = crypto.randomUUID();
+    const now = Date.now();
+    const allAgents = db.select({ displayName: agents.displayName }).from(agents).all();
+    const existingNames = allAgents
+        .map((a) => a.displayName)
+        .filter((n) => n !== null);
+    const rawDisplayName = generateDisplayName();
+    const displayName = resolveUniqueDisplayName(existingNames, rawDisplayName);
+    db.insert(agents)
+        .values({
+        id,
+        name: input.name,
+        displayName,
+        url: input.url,
+        status: 'online',
+        agentCard: input.agentCard ? JSON.stringify(input.agentCard) : null,
+        lastHeartbeat: now,
+        createdAt: now,
+        updatedAt: now,
+    })
+        .run();
+    if (input.teamIds && input.teamIds.length > 0) {
+        for (const teamId of input.teamIds) {
+            db.insert(agentTeams).values({ agentId: id, teamId }).run();
+        }
+    }
+    return getAgentById(id);
+}
+export function listAgents(filters) {
+    const conditions = [];
+    if (filters?.status) {
+        conditions.push(eq(agents.status, filters.status));
+    }
+    if (filters?.teamId) {
+        const agentIdsInTeam = db
+            .select({ agentId: agentTeams.agentId })
+            .from(agentTeams)
+            .where(eq(agentTeams.teamId, filters.teamId))
+            .all()
+            .map((r) => r.agentId);
+        if (agentIdsInTeam.length === 0) {
+            return [];
+        }
+        conditions.push(inArray(agents.id, agentIdsInTeam));
+    }
+    if (filters?.projectId) {
+        const agentIdsInProject = db
+            .select({ agentId: agentProjects.agentId })
+            .from(agentProjects)
+            .where(eq(agentProjects.projectId, filters.projectId))
+            .all()
+            .map((r) => r.agentId);
+        if (agentIdsInProject.length === 0) {
+            return [];
+        }
+        conditions.push(inArray(agents.id, agentIdsInProject));
+    }
+    const query = db
+        .select()
+        .from(agents)
+        .orderBy(desc(agents.status), asc(agents.name));
+    if (conditions.length > 0) {
+        return query.where(and(...conditions)).all();
+    }
+    return query.all();
+}
+export function getAgentById(id) {
+    const agent = db.select().from(agents).where(eq(agents.id, id)).get();
+    if (!agent)
+        return null;
+    const teamRows = db
+        .select({ teamId: agentTeams.teamId })
+        .from(agentTeams)
+        .where(eq(agentTeams.agentId, id))
+        .all();
+    const projectRows = db
+        .select({ projectId: agentProjects.projectId })
+        .from(agentProjects)
+        .where(eq(agentProjects.agentId, id))
+        .all();
+    return {
+        ...agent,
+        agentCard: agent.agentCard ? JSON.parse(agent.agentCard) : null,
+        teamIds: teamRows.map((r) => r.teamId),
+        projectIds: projectRows.map((r) => r.projectId),
+    };
+}
+export function updateAgent(id, updates) {
+    const existing = db.select().from(agents).where(eq(agents.id, id)).get();
+    if (!existing)
+        return null;
+    const values = { updatedAt: Date.now() };
+    if (updates.name !== undefined)
+        values.name = updates.name;
+    if (updates.url !== undefined)
+        values.url = updates.url;
+    if (updates.status !== undefined)
+        values.status = updates.status;
+    if (updates.agentCard !== undefined)
+        values.agentCard = updates.agentCard;
+    db.update(agents).set(values).where(eq(agents.id, id)).run();
+    return getAgentById(id);
+}
+export function deregisterAgent(id) {
+    const existing = db.select().from(agents).where(eq(agents.id, id)).get();
+    if (!existing)
+        return null;
+    db.update(agents)
+        .set({ status: 'offline', updatedAt: Date.now() })
+        .where(eq(agents.id, id))
+        .run();
+    return getAgentById(id);
+}
+export function getAgentCount() {
+    const result = db.select({ value: count() }).from(agents).get();
+    return result?.value ?? 0;
+}

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

@@ -0,0 +1,2 @@
+export declare function startHeartbeatChecker(): void;
+export declare function stopHeartbeatChecker(): void;

package/dist/services/heartbeat-service.js

@@ -0,0 +1,35 @@
+import { eq, lt, and, ne } from 'drizzle-orm';
+import { db, agents } from '../db/index.js';
+import { HEARTBEAT_INTERVAL_MS, STALE_TIMEOUT_MS } from '@swarmroom/shared';
+import { broadcastAgentOffline } from './ws-manager.js';
+let intervalId = null;
+function markStaleAgentsOffline() {
+    const cutoff = Date.now() - STALE_TIMEOUT_MS;
+    const staleAgents = db
+        .select({ id: agents.id, name: agents.name, status: agents.status })
+        .from(agents)
+        .where(and(lt(agents.lastHeartbeat, cutoff), ne(agents.status, 'offline')))
+        .all();
+    for (const agent of staleAgents) {
+        console.log(`[heartbeat] Agent "${agent.name}" (${agent.id}) transitioned from "${agent.status}" to "offline" (stale heartbeat)`);
+        db.update(agents)
+            .set({ status: 'offline', updatedAt: Date.now() })
+            .where(eq(agents.id, agent.id))
+            .run();
+        broadcastAgentOffline({ id: agent.id, name: agent.name });
+    }
+}
+export function startHeartbeatChecker() {
+    if (intervalId !== null) {
+        return;
+    }
+    console.log(`[heartbeat] Starting stale agent checker (interval: ${HEARTBEAT_INTERVAL_MS}ms, timeout: ${STALE_TIMEOUT_MS}ms)`);
+    intervalId = setInterval(markStaleAgentsOffline, HEARTBEAT_INTERVAL_MS);
+}
+export function stopHeartbeatChecker() {
+    if (intervalId !== null) {
+        clearInterval(intervalId);
+        intervalId = null;
+        console.log('[heartbeat] Stopped stale agent checker');
+    }
+}

package/dist/services/mdns-browser.d.ts

@@ -0,0 +1,2 @@
+export declare function startBrowsing(): void;
+export declare function stopBrowsing(): void;

package/dist/services/mdns-browser.js

@@ -0,0 +1,53 @@
+import { createSocket } from 'dgram';
+import { MDNS_SERVICE_TYPE } from '@swarmroom/shared';
+const MDNS_ADDRESS = '224.0.0.251';
+const MDNS_PORT = 5353;
+let socket = null;
+let running = false;
+export function startBrowsing() {
+    if (process.env.SWARMROOM_DISABLE_MDNS === 'true') {
+        return;
+    }
+    try {
+        socket = createSocket({ type: 'udp4', reuseAddr: true });
+        socket.on('message', (msg) => {
+            const content = msg.toString('utf8');
+            if (content.includes(MDNS_SERVICE_TYPE.replace(/^_/, '').replace(/\._tcp$/, ''))) {
+                console.log(`[mdns-browser] Detected ${MDNS_SERVICE_TYPE} service activity on the network`);
+            }
+        });
+        socket.on('error', (err) => {
+            console.warn('[mdns-browser] Socket error:', err.message);
+            stopBrowsing();
+        });
+        socket.bind(MDNS_PORT, () => {
+            try {
+                socket?.addMembership(MDNS_ADDRESS);
+                running = true;
+                console.log(`[mdns-browser] Browsing for ${MDNS_SERVICE_TYPE} services on the network`);
+            }
+            catch (error) {
+                console.warn('[mdns-browser] Failed to join multicast group:', error);
+                stopBrowsing();
+            }
+        });
+    }
+    catch (error) {
+        console.warn('[mdns-browser] Failed to start browsing — continuing without mDNS browsing:', error);
+        socket = null;
+    }
+}
+export function stopBrowsing() {
+    if (socket) {
+        try {
+            socket.close();
+        }
+        catch {
+        }
+        socket = null;
+    }
+    if (running) {
+        running = false;
+        console.log('[mdns-browser] Stopped browsing');
+    }
+}

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

@@ -0,0 +1,2 @@
+export declare function startMdns(port: number): Promise<void>;
+export declare function stopMdns(): Promise<void>;

package/dist/services/mdns-service.js

@@ -0,0 +1,66 @@
+import { getResponder } from '@homebridge/ciao';
+import { MDNS_SERVICE_TYPE } from '@swarmroom/shared';
+import { networkInterfaces } from 'os';
+let responder = null;
+let service = null;
+function getLocalIpAddress() {
+    const nets = networkInterfaces();
+    for (const name of Object.keys(nets)) {
+        const netInfos = nets[name];
+        if (!netInfos)
+            continue;
+        for (const net of netInfos) {
+            if (!net.internal && net.family === 'IPv4') {
+                return net.address;
+            }
+        }
+    }
+    return '127.0.0.1';
+}
+export async function startMdns(port) {
+    if (process.env.SWARMROOM_DISABLE_MDNS === 'true') {
+        console.log('[mdns] mDNS disabled via SWARMROOM_DISABLE_MDNS');
+        return;
+    }
+    try {
+        responder = getResponder();
+        const ip = getLocalIpAddress();
+        const serviceType = MDNS_SERVICE_TYPE.replace(/^_/, '').replace(/\._tcp$/, '');
+        service = responder.createService({
+            name: 'SwarmRoom Hub',
+            type: serviceType,
+            port,
+            txt: {
+                version: '0.1.0',
+                hub: 'true',
+                url: `http://${ip}:${port}`,
+            },
+        });
+        service.on('name-change', (newName) => {
+            console.log(`[mdns] Service name changed to "${newName}" (conflict resolution)`);
+        });
+        await service.advertise();
+        console.log(`[mdns] Advertising ${MDNS_SERVICE_TYPE} on port ${port} (url: http://${ip}:${port})`);
+    }
+    catch (error) {
+        console.warn('[mdns] Failed to start mDNS advertisement — continuing without mDNS:', error);
+        responder = null;
+        service = null;
+    }
+}
+export async function stopMdns() {
+    try {
+        if (service) {
+            await service.end();
+            service = null;
+        }
+        if (responder) {
+            await responder.shutdown();
+            responder = null;
+        }
+        console.log('[mdns] Stopped mDNS advertisement');
+    }
+    catch (error) {
+        console.warn('[mdns] Error stopping mDNS:', error);
+    }
+}

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

@@ -0,0 +1,82 @@
+import type { SendMessageRequest } from '@swarmroom/shared';
+export declare function createMessage(input: SendMessageRequest): {
+    id: string;
+    from: string;
+    to: string;
+    senderType: string | null;
+    content: string;
+    type: string | null;
+    replyTo: string | undefined;
+    metadata: any;
+    read: boolean;
+    createdAt: number | null;
+} | {
+    id: string;
+    from: string;
+    to: string;
+    senderType: string | null;
+    content: string;
+    type: string | null;
+    replyTo: string | undefined;
+    metadata: any;
+    read: boolean;
+    createdAt: number | null;
+}[];
+export declare function getMessagesForAgent(agentId: string, options?: {
+    since?: string;
+    limit?: number;
+    type?: string;
+}): {
+    id: string;
+    from: string;
+    to: string;
+    senderType: string | null;
+    content: string;
+    type: string | null;
+    replyTo: string | undefined;
+    metadata: any;
+    read: boolean;
+    createdAt: number | null;
+}[];
+export declare function getMessageById(id: string): {
+    id: string;
+    from: string;
+    to: string;
+    senderType: string | null;
+    content: string;
+    type: string | null;
+    replyTo: string | undefined;
+    metadata: any;
+    read: boolean;
+    createdAt: number | null;
+} | null;
+export declare function markMessageAsRead(id: string): {
+    id: string;
+    from: string;
+    to: string;
+    senderType: string | null;
+    content: string;
+    type: string | null;
+    replyTo: string | undefined;
+    metadata: any;
+    read: boolean;
+    createdAt: number | null;
+} | null;
+export declare function getConversation(agentA: string, agentB: string, limit?: number): {
+    id: string;
+    from: string;
+    to: string;
+    senderType: string | null;
+    content: string;
+    type: string | null;
+    replyTo: string | undefined;
+    metadata: any;
+    read: boolean;
+    createdAt: number | null;
+}[];
+export declare class MessageSizeError extends Error {
+    constructor(message: string);
+}
+export declare class InvalidReplyError extends Error {
+    constructor(message: string);
+}

package/dist/services/message-service.js

@@ -0,0 +1,172 @@
+import { eq, and, or, desc, asc, gt } from 'drizzle-orm';
+import { db, messages, agents } from '../db/index.js';
+import { MAX_MESSAGE_SIZE_BYTES } from '@swarmroom/shared';
+import { pushMessageToRecipient, hasActiveConnections, sendToDaemons } from './ws-manager.js';
+export function createMessage(input) {
+    const contentBytes = new TextEncoder().encode(input.content).length;
+    if (contentBytes > MAX_MESSAGE_SIZE_BYTES) {
+        throw new MessageSizeError(`Message content exceeds maximum size of ${MAX_MESSAGE_SIZE_BYTES} bytes (got ${contentBytes})`);
+    }
+    if (input.replyTo) {
+        const parent = db
+            .select({ id: messages.id })
+            .from(messages)
+            .where(eq(messages.id, input.replyTo))
+            .get();
+        if (!parent) {
+            throw new InvalidReplyError(`Parent message "${input.replyTo}" not found`);
+        }
+    }
+    const now = Date.now();
+    if (input.to === 'broadcast') {
+        const onlineAgents = db
+            .select({ id: agents.id })
+            .from(agents)
+            .where(eq(agents.status, 'online'))
+            .all();
+        const createdMessages = [];
+        for (const agent of onlineAgents) {
+            if (agent.id === input.from)
+                continue;
+            const id = crypto.randomUUID();
+            db.insert(messages)
+                .values({
+                id,
+                fromAgentId: input.from,
+                toAgentId: agent.id,
+                senderType: input.senderType ?? 'agent',
+                content: input.content,
+                type: input.type ?? 'notification',
+                replyTo: input.replyTo ?? null,
+                metadata: input.metadata ? JSON.stringify(input.metadata) : null,
+                read: 0,
+                createdAt: now,
+            })
+                .run();
+            createdMessages.push(getMessageById(id));
+        }
+        for (const msg of createdMessages) {
+            pushMessageToRecipient(msg.to, msg);
+            // Notify daemons if recipient has no active WebSocket connections
+            if (!hasActiveConnections(msg.to)) {
+                const recipient = db
+                    .select({ name: agents.name })
+                    .from(agents)
+                    .where(eq(agents.id, msg.to))
+                    .get();
+                if (recipient) {
+                    sendToDaemons('message_undelivered', {
+                        recipientAgentId: msg.to,
+                        recipientAgentName: recipient.name,
+                        message: msg,
+                    });
+                }
+            }
+        }
+        return createdMessages;
+    }
+    const id = crypto.randomUUID();
+    db.insert(messages)
+        .values({
+        id,
+        fromAgentId: input.from,
+        toAgentId: input.to,
+        senderType: input.senderType ?? 'agent',
+        content: input.content,
+        type: input.type ?? 'notification',
+        replyTo: input.replyTo ?? null,
+        metadata: input.metadata ? JSON.stringify(input.metadata) : null,
+        read: 0,
+        createdAt: now,
+    })
+        .run();
+    const created = getMessageById(id);
+    pushMessageToRecipient(created.to, created);
+    if (!hasActiveConnections(created.to)) {
+        const recipient = db
+            .select({ name: agents.name })
+            .from(agents)
+            .where(eq(agents.id, created.to))
+            .get();
+        if (recipient) {
+            sendToDaemons('message_undelivered', {
+                recipientAgentId: created.to,
+                recipientAgentName: recipient.name,
+                message: created,
+            });
+        }
+    }
+    return created;
+}
+export function getMessagesForAgent(agentId, options) {
+    const conditions = [eq(messages.toAgentId, agentId)];
+    if (options?.since) {
+        const sinceTs = Number(options.since);
+        if (!Number.isNaN(sinceTs)) {
+            conditions.push(gt(messages.createdAt, sinceTs));
+        }
+    }
+    if (options?.type) {
+        conditions.push(eq(messages.type, options.type));
+    }
+    const limit = options?.limit ?? 50;
+    const rows = db
+        .select()
+        .from(messages)
+        .where(and(...conditions))
+        .orderBy(desc(messages.createdAt))
+        .limit(limit)
+        .all();
+    return rows.map(formatMessage);
+}
+export function getMessageById(id) {
+    const row = db.select().from(messages).where(eq(messages.id, id)).get();
+    if (!row)
+        return null;
+    return formatMessage(row);
+}
+export function markMessageAsRead(id) {
+    const existing = db.select().from(messages).where(eq(messages.id, id)).get();
+    if (!existing)
+        return null;
+    db.update(messages).set({ read: 1 }).where(eq(messages.id, id)).run();
+    return getMessageById(id);
+}
+export function getConversation(agentA, agentB, limit = 100) {
+    const rows = db
+        .select()
+        .from(messages)
+        .where(or(and(eq(messages.fromAgentId, agentA), eq(messages.toAgentId, agentB)), and(eq(messages.fromAgentId, agentB), eq(messages.toAgentId, agentA))))
+        .orderBy(asc(messages.createdAt))
+        .limit(limit)
+        .all();
+    return rows.map(formatMessage);
+}
+// ─── Helpers ────────────────────────────────────────────────────────────────
+function formatMessage(row) {
+    return {
+        id: row.id,
+        from: row.fromAgentId,
+        to: row.toAgentId,
+        senderType: row.senderType,
+        content: row.content,
+        type: row.type,
+        replyTo: row.replyTo ?? undefined,
+        metadata: row.metadata ? JSON.parse(row.metadata) : undefined,
+        read: row.read === 1,
+        createdAt: row.createdAt,
+    };
+}
+// ─── Custom Errors ──────────────────────────────────────────────────────────
+export class MessageSizeError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'MessageSizeError';
+    }
+}
+export class InvalidReplyError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'InvalidReplyError';
+    }
+}

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

@@ -0,0 +1,130 @@
+import type { CreateProjectRequest } from '@swarmroom/shared';
+export declare function createProject(input: CreateProjectRequest & {
+    repository?: 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;
+    repository: string | null;
+    createdAt: number | null;
+} | null;
+export declare function listProjects(): {
+    agentCount: number;
+    id: string;
+    name: string;
+    description: string | null;
+    repository: string | null;
+    createdAt: number | null;
+}[];
+export declare function getProjectById(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;
+    repository: string | null;
+    createdAt: number | null;
+} | null;
+export declare function updateProject(id: string, updates: Partial<{
+    name: string;
+    description: string;
+    repository: 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;
+    repository: string | null;
+    createdAt: number | null;
+} | null;
+export declare function deleteProject(id: string): {
+    id: string;
+    name: string;
+    description: string | null;
+    repository: string | null;
+    createdAt: number | null;
+} | null;
+export declare function addAgentToProject(projectId: string, agentId: string): {
+    error: "project_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;
+        repository: string | null;
+        createdAt: number | null;
+    } | null;
+    error?: undefined;
+};
+export declare function removeAgentFromProject(projectId: string, agentId: string): {
+    error: "project_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;
+        repository: string | null;
+        createdAt: number | null;
+    } | null;
+    error?: undefined;
+};