#!/usr/bin/env node
import express from "express";
import { createServer } from "http";
import { Server } from "socket.io";
import cors from "cors";
import { v4 as uuidv4 } from "uuid";
import fs from "fs/promises";
import path from "path";
import chokidar from "chokidar";
import sqlite3 from "sqlite3";
import winston from "winston";
const app = express();
const httpServer = createServer(app);
const io = new Server(httpServer, {
cors: {
origin: "*",
methods: ["GET", "POST"],
},
});
app.use(cors());
app.use(express.json());
// Configuration
const SHARED_DIR = process.env.SHARED_DIR || path.join(process.cwd(), "shared");
const DATA_DIR = process.env.DATA_DIR || path.join(process.cwd(), "data");
// Logging setup
const logger = winston.createLogger({
level: "info",
format: winston.format.combine(
winston.format.timestamp(),
winston.format.errors({ stack: true }),
winston.format.json()
),
defaultMeta: { service: "claude-symphony-of-one-hub" },
transports: [
new winston.transports.File({
filename: path.join(DATA_DIR, "error.log"),
level: "error",
}),
new winston.transports.File({
filename: path.join(DATA_DIR, "combined.log"),
}),
new winston.transports.Console({
format: winston.format.simple(),
}),
],
});
// Database setup
const db = new sqlite3.Database(
path.join(DATA_DIR, "claude-symphony-of-one.db")
);
// In-memory storage (with database persistence)
const rooms = new Map();
const agents = new Map();
const messages = new Map();
const tasks = new Map();
const fileWatcher = new Map();
const agentMemory = new Map(); // Persistent agent memories
// Initialize directories and database
async function initializeSystem() {
try {
await fs.access(SHARED_DIR);
} catch {
await fs.mkdir(SHARED_DIR, { recursive: true });
logger.info(`Created shared directory: ${SHARED_DIR}`);
}
try {
await fs.access(DATA_DIR);
} catch {
await fs.mkdir(DATA_DIR, { recursive: true });
logger.info(`Created data directory: ${DATA_DIR}`);
}
// Initialize database tables
db.serialize(() => {
db.run(`CREATE TABLE IF NOT EXISTS rooms (
id TEXT PRIMARY KEY,
name TEXT UNIQUE,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
is_active BOOLEAN DEFAULT 1,
settings TEXT
)`);
db.run(`CREATE TABLE IF NOT EXISTS agents (
id TEXT PRIMARY KEY,
name TEXT,
room TEXT,
capabilities TEXT,
joined_at DATETIME DEFAULT CURRENT_TIMESTAMP,
last_active DATETIME DEFAULT CURRENT_TIMESTAMP,
status TEXT DEFAULT 'active'
)`);
db.run(`CREATE TABLE IF NOT EXISTS messages (
id TEXT PRIMARY KEY,
room TEXT,
agent_id TEXT,
agent_name TEXT,
content TEXT,
type TEXT DEFAULT 'message',
mentions TEXT,
metadata TEXT,
timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
)`);
db.run(`CREATE TABLE IF NOT EXISTS tasks (
id TEXT PRIMARY KEY,
room TEXT,
title TEXT,
description TEXT,
assignee TEXT,
creator TEXT,
priority TEXT DEFAULT 'medium',
status TEXT DEFAULT 'todo',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
)`);
db.run(`CREATE TABLE IF NOT EXISTS agent_memory (
id TEXT PRIMARY KEY,
agent_id TEXT,
room TEXT,
key TEXT,
value TEXT,
type TEXT DEFAULT 'note',
created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
expires_at DATETIME
)`);
db.run(`CREATE TABLE IF NOT EXISTS notifications (
id TEXT PRIMARY KEY,
agent_id TEXT,
room TEXT,
message TEXT,
type TEXT DEFAULT 'mention',
is_read BOOLEAN DEFAULT 0,
created_at DATETIME DEFAULT CURRENT_TIMESTAMP
)`);
});
// Load existing data into memory
await loadDataFromDatabase();
}
// Load data from database into memory maps
async function loadDataFromDatabase() {
return new Promise((resolve, reject) => {
db.all("SELECT * FROM rooms WHERE is_active = 1", (err, rows) => {
if (err) {
logger.error("Failed to load rooms from database:", err);
return reject(err);
}
rows.forEach((row) => {
rooms.set(row.name, {
name: row.name,
agents: new Set(),
createdAt: row.created_at,
isActive: row.is_active === 1,
settings: row.settings ? JSON.parse(row.settings) : {},
});
messages.set(row.name, []);
});
logger.info(`Loaded ${rows.length} rooms from database`);
resolve();
});
});
}
// Parse mentions from message content (@agentName)
function parseMentions(content) {
const mentionRegex = /@(\w+(?:-\w+)*)/g;
const mentions = [];
let match;
while ((match = mentionRegex.exec(content)) !== null) {
mentions.push(match[1]);
}
return mentions;
}
// Create notifications for mentioned agents
async function createNotifications(message, mentions) {
const notifications = mentions
.map((agentName) => ({
id: uuidv4(),
agent_id: findAgentByName(agentName)?.id,
room: message.room,
message: `${message.agentName} mentioned you: ${message.content.substring(
0,
100
)}...`,
type: "mention",
created_at: new Date().toISOString(),
}))
.filter((n) => n.agent_id); // Only create notifications for existing agents
notifications.forEach((notification) => {
db.run(
"INSERT INTO notifications (id, agent_id, room, message, type, created_at) VALUES (?, ?, ?, ?, ?, ?)",
[
notification.id,
notification.agent_id,
notification.room,
notification.message,
notification.type,
notification.created_at,
]
);
// Send real-time notification to agent if connected
const agent = agents.get(notification.agent_id);
if (agent && agent.socketId) {
io.to(agent.socketId).emit("notification", notification);
}
});
return notifications;
}
// Find agent by name in current agents
function findAgentByName(agentName) {
for (const agent of agents.values()) {
if (agent.name === agentName) {
return agent;
}
}
return null;
}
// Setup file watcher for a room
function setupFileWatcher(roomName) {
if (fileWatcher.has(roomName)) return;
const watcher = chokidar.watch(SHARED_DIR, {
ignored: /[\/\\]\./,
persistent: true,
});
watcher.on("change", (filePath) => {
const relativePath = path.relative(SHARED_DIR, filePath);
const message = {
id: uuidv4(),
type: "file_change",
content: `File modified: ${relativePath}`,
timestamp: new Date().toISOString(),
room: roomName,
metadata: { filePath: relativePath, action: "change" },
};
messages.get(roomName)?.push(message);
io.to(roomName).emit("message", message);
});
watcher.on("add", (filePath) => {
const relativePath = path.relative(SHARED_DIR, filePath);
const message = {
id: uuidv4(),
type: "file_change",
content: `File created: ${relativePath}`,
timestamp: new Date().toISOString(),
room: roomName,
metadata: { filePath: relativePath, action: "add" },
};
messages.get(roomName)?.push(message);
io.to(roomName).emit("message", message);
});
watcher.on("unlink", (filePath) => {
const relativePath = path.relative(SHARED_DIR, filePath);
const message = {
id: uuidv4(),
type: "file_change",
content: `File deleted: ${relativePath}`,
timestamp: new Date().toISOString(),
room: roomName,
metadata: { filePath: relativePath, action: "delete" },
};
messages.get(roomName)?.push(message);
io.to(roomName).emit("message", message);
});
fileWatcher.set(roomName, watcher);
}
// Room management
function getRoom(roomName) {
if (!rooms.has(roomName)) {
const room = {
name: roomName,
agents: new Set(),
createdAt: new Date().toISOString(),
isActive: true,
settings: {},
};
rooms.set(roomName, room);
messages.set(roomName, []);
setupFileWatcher(roomName);
// Persist to database
db.run(
"INSERT OR REPLACE INTO rooms (id, name, created_at, is_active, settings) VALUES (?, ?, ?, ?, ?)",
[uuidv4(), roomName, room.createdAt, 1, JSON.stringify(room.settings)]
);
logger.info(`Created new room: ${roomName}`);
}
return rooms.get(roomName);
}
// HTTP API Endpoints
app.post("/api/join/:room", (req, res) => {
const { room: roomName } = req.params;
const { agentId, agentName, capabilities = {} } = req.body;
const room = getRoom(roomName);
room.agents.add(agentId);
const agent = {
id: agentId,
name: agentName,
room: roomName,
capabilities,
joinedAt: new Date().toISOString(),
lastActive: new Date().toISOString(),
socketId: null,
status: "active",
};
agents.set(agentId, agent);
// Persist agent to database
db.run(
"INSERT OR REPLACE INTO agents (id, name, room, capabilities, joined_at, last_active, status) VALUES (?, ?, ?, ?, ?, ?, ?)",
[
agentId,
agentName,
roomName,
JSON.stringify(capabilities),
agent.joinedAt,
agent.lastActive,
agent.status,
]
);
const joinMessage = {
id: uuidv4(),
type: "system",
agentId: null,
agentName: "System",
content: `${agentName} has joined the room`,
timestamp: new Date().toISOString(),
room: roomName,
mentions: [],
metadata: { type: "join" },
};
messages.get(roomName).push(joinMessage);
// Persist message to database
db.run(
"INSERT INTO messages (id, room, agent_id, agent_name, content, type, mentions, metadata, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
[
joinMessage.id,
roomName,
null,
"System",
joinMessage.content,
joinMessage.type,
JSON.stringify(joinMessage.mentions),
JSON.stringify(joinMessage.metadata),
joinMessage.timestamp,
]
);
io.to(roomName).emit("message", joinMessage);
logger.info(`Agent ${agentName} (${agentId}) joined room ${roomName}`);
res.json({
success: true,
roomName,
agentId,
currentAgents: Array.from(room.agents).map((id) => agents.get(id)),
});
});
app.post("/api/leave/:agentId", (req, res) => {
const { agentId } = req.params;
const agent = agents.get(agentId);
if (!agent) {
return res.status(404).json({ success: false, error: "Agent not found" });
}
const room = rooms.get(agent.room);
if (room) {
room.agents.delete(agentId);
const leaveMessage = {
id: uuidv4(),
type: "system",
content: `${agent.name} has left the room`,
timestamp: new Date().toISOString(),
room: agent.room,
};
messages.get(agent.room).push(leaveMessage);
io.to(agent.room).emit("message", leaveMessage);
}
agents.delete(agentId);
res.json({ success: true });
});
app.post("/api/send", (req, res) => {
const { agentId, content, metadata = {} } = req.body;
const agent = agents.get(agentId);
if (!agent) {
return res.status(404).json({ success: false, error: "Agent not found" });
}
// Parse mentions from content
const mentions = parseMentions(content);
const message = {
id: uuidv4(),
type: "message",
agentId,
agentName: agent.name,
content,
mentions,
metadata,
timestamp: new Date().toISOString(),
room: agent.room,
};
messages.get(agent.room).push(message);
// Persist message to database
db.run(
"INSERT INTO messages (id, room, agent_id, agent_name, content, type, mentions, metadata, timestamp) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
[
message.id,
agent.room,
agentId,
agent.name,
content,
message.type,
JSON.stringify(mentions),
JSON.stringify(metadata),
message.timestamp,
]
);
// Update agent last active time
agent.lastActive = new Date().toISOString();
db.run("UPDATE agents SET last_active = ? WHERE id = ?", [
agent.lastActive,
agentId,
]);
// Create notifications for mentions
if (mentions.length > 0) {
createNotifications(message, mentions);
}
io.to(agent.room).emit("message", message);
logger.info(
`Message sent by ${agent.name} in ${agent.room}${
mentions.length > 0 ? ` with mentions: ${mentions.join(", ")}` : ""
}`
);
res.json({ success: true, messageId: message.id, mentions });
});
app.get("/api/messages/:room", (req, res) => {
const { room } = req.params;
const { since, limit = 100 } = req.query;
let roomMessages = messages.get(room) || [];
if (since) {
const sinceTime = new Date(since).getTime();
roomMessages = roomMessages.filter(
(m) => new Date(m.timestamp).getTime() > sinceTime
);
}
res.json({
messages: roomMessages.slice(-parseInt(limit)),
});
});
app.get("/api/rooms", (req, res) => {
const roomList = Array.from(rooms.entries()).map(([name, room]) => ({
name,
agentCount: room.agents.size,
agents: Array.from(room.agents)
.map((id) => agents.get(id))
.filter(Boolean),
createdAt: room.createdAt,
}));
res.json({ rooms: roomList });
});
app.get("/api/agents/:room", (req, res) => {
const { room: roomName } = req.params;
const room = rooms.get(roomName);
if (!room) {
return res.status(404).json({ success: false, error: "Room not found" });
}
const roomAgents = Array.from(room.agents)
.map((id) => agents.get(id))
.filter(Boolean);
res.json({ agents: roomAgents });
});
// Task endpoints
app.post("/api/tasks", (req, res) => {
const {
roomName,
title,
description,
assignee,
creator,
priority = "medium",
} = req.body;
const task = {
id: uuidv4(),
room: roomName,
title,
description,
assignee,
creator,
priority,
status: "todo",
createdAt: new Date().toISOString(),
updatedAt: new Date().toISOString(),
};
tasks.set(task.id, task);
io.to(roomName).emit("task", { type: "created", task });
res.json({ success: true, task });
});
app.get("/api/tasks/:room", (req, res) => {
const { room } = req.params;
const roomTasks = Array.from(tasks.values()).filter((t) => t.room === room);
res.json({ tasks: roomTasks });
});
// Agent management endpoints
app.get("/api/stats", (req, res) => {
const stats = {
totalRooms: rooms.size,
totalAgents: agents.size,
totalTasks: tasks.size,
sharedDirectory: SHARED_DIR,
rooms: Array.from(rooms.entries()).map(([name, room]) => ({
name,
agentCount: room.agents.size,
messageCount: messages.get(name)?.length || 0,
isActive: room.isActive,
})),
};
res.json(stats);
});
app.post("/api/broadcast/:room", (req, res) => {
const { room: roomName } = req.params;
const { content, from = "Orchestrator" } = req.body;
const message = {
id: uuidv4(),
type: "broadcast",
content: `[${from}] ${content}`,
timestamp: new Date().toISOString(),
room: roomName,
from,
};
messages.get(roomName)?.push(message);
io.to(roomName).emit("message", message);
res.json({ success: true, messageId: message.id });
});
app.post("/api/tasks/:taskId/update", (req, res) => {
const { taskId } = req.params;
const { status, assignee, priority } = req.body;
const task = tasks.get(taskId);
if (!task) {
return res.status(404).json({ success: false, error: "Task not found" });
}
if (status) task.status = status;
if (assignee) task.assignee = assignee;
if (priority) task.priority = priority;
task.updatedAt = new Date().toISOString();
// Update in database
db.run(
"UPDATE tasks SET status = ?, assignee = ?, priority = ?, updated_at = ? WHERE id = ?",
[task.status, task.assignee, task.priority, task.updatedAt, taskId]
);
io.to(task.room).emit("task", { type: "updated", task });
logger.info(
`Task ${taskId} updated: status=${task.status}, assignee=${task.assignee}`
);
res.json({ success: true, task });
});
// Agent memory endpoints
app.post("/api/memory/:agentId", (req, res) => {
const { agentId } = req.params;
const { key, value, type = "note", expiresIn } = req.body;
const agent = agents.get(agentId);
if (!agent) {
return res.status(404).json({ success: false, error: "Agent not found" });
}
const memoryId = uuidv4();
const expiresAt = expiresIn
? new Date(Date.now() + expiresIn * 1000).toISOString()
: null;
const memory = {
id: memoryId,
agentId,
room: agent.room,
key,
value,
type,
createdAt: new Date().toISOString(),
expiresAt,
};
// Store in database
db.run(
"INSERT INTO agent_memory (id, agent_id, room, key, value, type, created_at, expires_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)",
[
memoryId,
agentId,
agent.room,
key,
value,
type,
memory.createdAt,
expiresAt,
]
);
logger.info(`Memory stored for agent ${agent.name}: ${key}`);
res.json({ success: true, memoryId, memory });
});
app.get("/api/memory/:agentId", (req, res) => {
const { agentId } = req.params;
const { key, type } = req.query;
let query =
"SELECT * FROM agent_memory WHERE agent_id = ? AND (expires_at IS NULL OR expires_at > datetime('now'))";
const params = [agentId];
if (key) {
query += " AND key = ?";
params.push(key);
}
if (type) {
query += " AND type = ?";
params.push(type);
}
query += " ORDER BY created_at DESC";
db.all(query, params, (err, rows) => {
if (err) {
logger.error("Failed to retrieve agent memory:", err);
return res.status(500).json({ success: false, error: "Database error" });
}
res.json({ success: true, memories: rows });
});
});
app.get("/api/notifications/:agentId", (req, res) => {
const { agentId } = req.params;
const { unreadOnly = false } = req.query;
let query = "SELECT * FROM notifications WHERE agent_id = ?";
const params = [agentId];
if (unreadOnly === "true") {
query += " AND is_read = 0";
}
query += " ORDER BY created_at DESC LIMIT 50";
db.all(query, params, (err, rows) => {
if (err) {
logger.error("Failed to retrieve notifications:", err);
return res.status(500).json({ success: false, error: "Database error" });
}
res.json({ success: true, notifications: rows });
});
});
app.post("/api/notifications/:notificationId/read", (req, res) => {
const { notificationId } = req.params;
db.run(
"UPDATE notifications SET is_read = 1 WHERE id = ?",
[notificationId],
function (err) {
if (err) {
logger.error("Failed to mark notification as read:", err);
return res
.status(500)
.json({ success: false, error: "Database error" });
}
res.json({ success: true, updated: this.changes > 0 });
}
);
});
// WebSocket handling
io.on("connection", (socket) => {
console.log(`Client connected: ${socket.id}`);
socket.on("register", ({ agentId, room }) => {
const agent = agents.get(agentId);
if (agent) {
agent.socketId = socket.id;
socket.join(room);
console.log(`Agent ${agent.name} registered with socket ${socket.id}`);
}
});
socket.on("message", (data) => {
if (data.room) {
io.to(data.room).emit("message", data);
}
});
socket.on("disconnect", () => {
console.log(`Client disconnected: ${socket.id}`);
});
});
// Start server
const PORT = process.env.PORT || 3000;
async function startServer() {
await initializeSystem();
httpServer.listen(PORT, () => {
logger.info(`Claude Gateway Hub started on port ${PORT}`);
console.log(`š Claude Gateway Hub running on http://localhost:${PORT}`);
console.log(`š Shared Directory: ${SHARED_DIR}`);
console.log(`š¾ Data Directory: ${DATA_DIR}`);
console.log(`\nCore Endpoints:`);
console.log(` POST /api/join/:room - Join a room`);
console.log(` POST /api/leave/:agentId - Leave current room`);
console.log(` POST /api/send - Send a message`);
console.log(` GET /api/messages/:room - Get room messages`);
console.log(` GET /api/rooms - List all rooms`);
console.log(` GET /api/agents/:room - Get room agents`);
console.log(`\nTask Management:`);
console.log(` POST /api/tasks - Create a task`);
console.log(` GET /api/tasks/:room - Get room tasks`);
console.log(` POST /api/tasks/:id/update - Update task status`);
console.log(`\nAgent Memory & Notifications:`);
console.log(` POST /api/memory/:agentId - Store agent memory`);
console.log(` GET /api/memory/:agentId - Retrieve agent memory`);
console.log(` GET /api/notifications/:id - Get notifications`);
console.log(` POST /api/notifications/:id/read - Mark as read`);
console.log(`\nOrchestration:`);
console.log(` GET /api/stats - Get system stats`);
console.log(` POST /api/broadcast/:room - Broadcast to room`);
console.log(`\nFeatures:`);
console.log(` š·ļø Agent tagging with @mentions`);
console.log(` š Real-time notifications`);
console.log(` š¾ Persistent logging & storage`);
console.log(` š Agent memory management`);
console.log(`\nWebSocket Events:`);
console.log(` - message: Chat messages & file changes`);
console.log(` - task: Task updates`);
console.log(` - notification: Mentions & alerts`);
console.log(`\nš¤ Ready for MCP agent connections!`);
});
}
startServer().catch(console.error);
