#!/usr/bin/env node
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import axios from 'axios';
import { io } from 'socket.io-client';
import { v4 as uuidv4 } from 'uuid';
import fs from 'fs/promises';
import path from 'path';
import { fileURLToPath } from 'url';
const __dirname = path.dirname(fileURLToPath(import.meta.url));
const SERVER_URL = process.env.CHAT_SERVER_URL || 'http://localhost:3000';
const SHARED_DIR = process.env.SHARED_DIR || path.join(process.cwd(), 'shared');
// Global state
let currentAgentId = null;
let currentRoom = null;
let socket = null;
let agentName = process.env.AGENT_NAME || `Agent-${uuidv4().slice(0, 8)}`;
let notifications = [];
let messageHistory = [];
let watchPatterns = [];
// Ensure shared directory exists
async function ensureSharedDir() {
try {
await fs.access(SHARED_DIR);
} catch {
await fs.mkdir(SHARED_DIR, { recursive: true });
console.error(`Created shared directory: ${SHARED_DIR}`);
}
}
// Initialize socket connection
function connectSocket() {
if (socket) socket.disconnect();
socket = io(SERVER_URL);
socket.on('connect', () => {
console.error(`[${agentName}] Connected to chat server at ${SERVER_URL}`);
if (currentAgentId && currentRoom) {
socket.emit('register', { agentId: currentAgentId, room: currentRoom });
}
});
socket.on('message', (message) => {
messageHistory.push(message);
// Keep only last 1000 messages
if (messageHistory.length > 1000) {
messageHistory = messageHistory.slice(-1000);
}
// Check for notifications
const content = message.content?.toLowerCase() || '';
if (message.mentions?.includes(agentName)) {
notifications.push({
id: uuidv4(),
type: 'mention',
message: message,
timestamp: new Date().toISOString(),
read: false
});
}
for (const pattern of watchPatterns) {
if (content.includes(pattern.toLowerCase())) {
notifications.push({
id: uuidv4(),
type: 'keyword',
pattern: pattern,
message: message,
timestamp: new Date().toISOString(),
read: false
});
break;
}
}
console.error(`[${message.agentName || 'System'}]: ${message.content}`);
});
socket.on('notification', (notification) => {
notifications.push({
id: uuidv4(),
type: 'system',
...notification,
timestamp: new Date().toISOString(),
read: false
});
console.error(`🔔 [Notification]: ${notification.message}`);
});
socket.on('task_assigned', (task) => {
notifications.push({
id: uuidv4(),
type: 'task',
task: task,
message: `Task assigned: ${task.title}`,
timestamp: new Date().toISOString(),
read: false
});
console.error(`📋 [Task Assigned]: ${task.title}`);
});
socket.on('disconnect', () => {
console.error(`[${agentName}] Disconnected from chat server`);
});
}
const server = new Server(
{
name: 'symphony-of-one-mcp',
version: '1.0.0',
},
{
capabilities: {
tools: {},
},
}
);
// Tool handlers
async function joinRoom(params) {
currentAgentId = uuidv4();
currentRoom = params.roomName;
if (params.agentName) {
agentName = params.agentName;
}
try {
const response = await axios.post(`${SERVER_URL}/api/join/${params.roomName}`, {
agentId: currentAgentId,
agentName: agentName,
capabilities: params.capabilities || { role: 'ai-agent', type: 'claude' }
});
connectSocket();
return {
success: true,
roomName: params.roomName,
agentId: currentAgentId,
agentName: agentName,
currentAgents: response.data.currentAgents
};
} catch (error) {
throw new Error(`Failed to join room: ${error.message}`);
}
}
async function leaveRoom() {
if (!currentAgentId) {
throw new Error('Not connected to a room');
}
try {
await axios.post(`${SERVER_URL}/api/leave`, {
agentId: currentAgentId
});
if (socket) {
socket.disconnect();
socket = null;
}
const leftRoom = currentRoom;
currentAgentId = null;
currentRoom = null;
messageHistory = [];
notifications = [];
return {
success: true,
message: `Left room "${leftRoom}"`
};
} catch (error) {
throw new Error(`Failed to leave room: ${error.message}`);
}
}
async function sendMessage(params) {
if (!currentAgentId) {
throw new Error('Not connected to a room. Use room_join first.');
}
try {
await axios.post(`${SERVER_URL}/api/send`, {
agentId: currentAgentId,
content: params.content,
metadata: params.metadata || {}
});
return {
success: true,
message: `Message sent to room "${currentRoom}"`
};
} catch (error) {
throw new Error(`Failed to send message: ${error.message}`);
}
}
async function getMessages(params) {
if (!currentRoom) {
throw new Error('Not in a room. Use room_join first.');
}
try {
// First try to get from local history
if (!params.since && messageHistory.length > 0) {
const limit = params.limit || 50;
return {
messages: messageHistory.slice(-limit),
source: 'local_cache'
};
}
// Otherwise fetch from server
const response = await axios.get(`${SERVER_URL}/api/messages/${currentRoom}`, {
params: {
since: params.since,
limit: params.limit || 50
}
});
return {
messages: response.data.messages,
source: 'server'
};
} catch (error) {
throw new Error(`Failed to get messages: ${error.message}`);
}
}
async function searchMessages(params) {
if (!currentRoom) {
throw new Error('Not in a room. Use room_join first.');
}
try {
const response = await axios.get(`${SERVER_URL}/api/messages/${currentRoom}/search`, {
params: {
query: params.query,
agentName: params.agentName,
type: params.type,
mentioned: params.mentioned
}
});
return {
messages: response.data.messages,
count: response.data.messages.length
};
} catch (error) {
throw new Error(`Failed to search messages: ${error.message}`);
}
}
async function subscribeToAlerts(params) {
if (!currentAgentId) {
throw new Error('Not connected to a room. Use room_join first.');
}
// Add patterns to watch list
if (params.patterns) {
watchPatterns = [...new Set([...watchPatterns, ...params.patterns])];
}
// Subscribe to mentions
if (params.mentions !== false) {
// Mentions are automatically tracked
}
return {
success: true,
watchPatterns: watchPatterns,
mentionsEnabled: params.mentions !== false
};
}
async function getNotifications(params) {
if (!currentAgentId) {
throw new Error('Not connected to a room. Use room_join first.');
}
let filtered = notifications;
if (params.unreadOnly) {
filtered = filtered.filter(n => !n.read);
}
if (params.type) {
filtered = filtered.filter(n => n.type === params.type);
}
return {
notifications: filtered,
unreadCount: notifications.filter(n => !n.read).length
};
}
async function markNotificationRead(params) {
const notification = notifications.find(n => n.id === params.notificationId);
if (!notification) {
throw new Error('Notification not found');
}
notification.read = true;
return {
success: true,
notificationId: params.notificationId
};
}
async function markAllNotificationsRead() {
let count = 0;
notifications.forEach(n => {
if (!n.read) {
n.read = true;
count++;
}
});
return {
success: true,
markedCount: count
};
}
async function getTasks(params) {
if (!currentRoom) {
throw new Error('Not in a room. Use room_join first.');
}
try {
const response = await axios.get(`${SERVER_URL}/api/tasks/${currentRoom}`, {
params: {
status: params.status,
assignee: params.assignee || agentName,
priority: params.priority
}
});
return {
tasks: response.data.tasks
};
} catch (error) {
throw new Error(`Failed to get tasks: ${error.message}`);
}
}
async function createTask(params) {
if (!currentRoom) {
throw new Error('Not in a room. Use room_join first.');
}
try {
const response = await axios.post(`${SERVER_URL}/api/tasks/${currentRoom}`, {
title: params.title,
description: params.description,
assignee: params.assignee,
priority: params.priority || 'medium',
creator: agentName
});
return {
success: true,
task: response.data.task
};
} catch (error) {
throw new Error(`Failed to create task: ${error.message}`);
}
}
async function updateTask(params) {
try {
const response = await axios.put(`${SERVER_URL}/api/tasks/${params.taskId}`, {
status: params.status,
progress: params.progress,
assignee: params.assignee,
priority: params.priority
});
return {
success: true,
task: response.data.task
};
} catch (error) {
throw new Error(`Failed to update task: ${error.message}`);
}
}
async function addTaskComment(params) {
try {
const response = await axios.post(`${SERVER_URL}/api/tasks/${params.taskId}/comments`, {
content: params.content,
author: agentName
});
return {
success: true,
comment: response.data.comment
};
} catch (error) {
throw new Error(`Failed to add comment: ${error.message}`);
}
}
async function getRoomAgents() {
if (!currentRoom) {
throw new Error('Not in a room. Use room_join first.');
}
try {
const response = await axios.get(`${SERVER_URL}/api/rooms/${currentRoom}/agents`);
return {
agents: response.data.agents,
room: currentRoom
};
} catch (error) {
throw new Error(`Failed to get room agents: ${error.message}`);
}
}
async function updateStatus(params) {
if (!currentAgentId) {
throw new Error('Not connected to a room. Use room_join first.');
}
try {
await axios.put(`${SERVER_URL}/api/agents/${currentAgentId}/status`, {
status: params.status,
message: params.message
});
return {
success: true,
status: params.status
};
} catch (error) {
throw new Error(`Failed to update status: ${error.message}`);
}
}
async function storeMemory(params) {
if (!currentAgentId) {
throw new Error('Not connected to a room. Use room_join first.');
}
try {
await axios.post(`${SERVER_URL}/api/memory/${currentAgentId}`, {
key: params.key,
value: params.value,
type: params.type || 'note',
expiresIn: params.expiresIn
});
return {
success: true,
key: params.key
};
} catch (error) {
throw new Error(`Failed to store memory: ${error.message}`);
}
}
async function retrieveMemory(params) {
if (!currentAgentId) {
throw new Error('Not connected to a room. Use room_join first.');
}
try {
const queryParams = new URLSearchParams();
if (params.key) queryParams.append('key', params.key);
if (params.type) queryParams.append('type', params.type);
const response = await axios.get(`${SERVER_URL}/api/memory/${currentAgentId}?${queryParams}`);
return {
memories: response.data.memories
};
} catch (error) {
throw new Error(`Failed to retrieve memory: ${error.message}`);
}
}
// Tool definitions
const tools = [
{
name: 'room_join',
description: 'Join a chat room to collaborate with other agents',
inputSchema: {
type: 'object',
properties: {
roomName: { type: 'string', description: 'Name of the room to join' },
agentName: { type: 'string', description: 'Your agent name (optional)' },
capabilities: {
type: 'object',
description: 'Your capabilities and role',
properties: {
skills: { type: 'array', items: { type: 'string' } },
role: { type: 'string' },
expertise: { type: 'string' }
}
}
},
required: ['roomName']
},
handler: joinRoom
},
{
name: 'room_leave',
description: 'Leave the current chat room',
inputSchema: {
type: 'object',
properties: {}
},
handler: leaveRoom
},
{
name: 'send_message',
description: 'Send a message to all agents in the current room (supports @mentions)',
inputSchema: {
type: 'object',
properties: {
content: { type: 'string', description: 'Message content' },
metadata: {
type: 'object',
description: 'Optional metadata',
properties: {
type: { type: 'string', enum: ['code', 'documentation', 'question', 'answer', 'task'] },
language: { type: 'string' },
urgency: { type: 'string', enum: ['low', 'normal', 'high'] }
}
}
},
required: ['content']
},
handler: sendMessage
},
{
name: 'get_messages',
description: 'Get recent messages from current room',
inputSchema: {
type: 'object',
properties: {
since: { type: 'string', description: 'ISO timestamp to get messages after' },
limit: { type: 'number', description: 'Maximum number of messages (default: 50)' }
}
},
handler: getMessages
},
{
name: 'search_messages',
description: 'Search messages in the current room',
inputSchema: {
type: 'object',
properties: {
query: { type: 'string', description: 'Search query' },
agentName: { type: 'string', description: 'Filter by agent name' },
type: { type: 'string', description: 'Filter by message type' },
mentioned: { type: 'string', description: 'Find messages mentioning this agent' }
},
required: ['query']
},
handler: searchMessages
},
{
name: 'subscribe_alerts',
description: 'Subscribe to alerts for mentions and keywords',
inputSchema: {
type: 'object',
properties: {
patterns: {
type: 'array',
items: { type: 'string' },
description: 'Keywords to watch for'
},
mentions: { type: 'boolean', description: 'Subscribe to @mentions (default: true)' }
}
},
handler: subscribeToAlerts
},
{
name: 'get_notifications',
description: 'Get your notifications',
inputSchema: {
type: 'object',
properties: {
unreadOnly: { type: 'boolean', description: 'Only return unread notifications' },
type: {
type: 'string',
enum: ['mention', 'keyword', 'task', 'system'],
description: 'Filter by notification type'
}
}
},
handler: getNotifications
},
{
name: 'mark_notification_read',
description: 'Mark a notification as read',
inputSchema: {
type: 'object',
properties: {
notificationId: { type: 'string', description: 'ID of notification to mark as read' }
},
required: ['notificationId']
},
handler: markNotificationRead
},
{
name: 'mark_all_notifications_read',
description: 'Mark all notifications as read',
inputSchema: {
type: 'object',
properties: {}
},
handler: markAllNotificationsRead
},
{
name: 'get_tasks',
description: 'Get tasks assigned to you or in the room',
inputSchema: {
type: 'object',
properties: {
status: {
type: 'string',
enum: ['todo', 'in_progress', 'review', 'done', 'blocked'],
description: 'Filter by status'
},
assignee: { type: 'string', description: 'Filter by assignee (defaults to you)' },
priority: {
type: 'string',
enum: ['low', 'medium', 'high'],
description: 'Filter by priority'
}
}
},
handler: getTasks
},
{
name: 'create_task',
description: 'Create a new task',
inputSchema: {
type: 'object',
properties: {
title: { type: 'string', description: 'Task title' },
description: { type: 'string', description: 'Task description' },
assignee: { type: 'string', description: 'Agent to assign to' },
priority: {
type: 'string',
enum: ['low', 'medium', 'high'],
description: 'Task priority (default: medium)'
}
},
required: ['title', 'description']
},
handler: createTask
},
{
name: 'update_task',
description: 'Update a task status or details',
inputSchema: {
type: 'object',
properties: {
taskId: { type: 'string', description: 'Task ID' },
status: {
type: 'string',
enum: ['todo', 'in_progress', 'review', 'done', 'blocked']
},
progress: { type: 'number', description: 'Progress percentage (0-100)' },
assignee: { type: 'string', description: 'New assignee' },
priority: {
type: 'string',
enum: ['low', 'medium', 'high']
}
},
required: ['taskId']
},
handler: updateTask
},
{
name: 'add_task_comment',
description: 'Add a comment to a task',
inputSchema: {
type: 'object',
properties: {
taskId: { type: 'string', description: 'Task ID' },
content: { type: 'string', description: 'Comment content' }
},
required: ['taskId', 'content']
},
handler: addTaskComment
},
{
name: 'get_room_agents',
description: 'Get list of agents in current room',
inputSchema: {
type: 'object',
properties: {}
},
handler: getRoomAgents
},
{
name: 'update_status',
description: 'Update your agent status',
inputSchema: {
type: 'object',
properties: {
status: {
type: 'string',
enum: ['online', 'busy', 'away', 'offline'],
description: 'Your status'
},
message: { type: 'string', description: 'Optional status message' }
},
required: ['status']
},
handler: updateStatus
},
{
name: 'memory_store',
description: 'Store information in persistent memory',
inputSchema: {
type: 'object',
properties: {
key: { type: 'string', description: 'Memory key' },
value: { type: 'string', description: 'Memory value' },
type: { type: 'string', description: 'Memory type (e.g., note, context, learning)' },
expiresIn: { type: 'number', description: 'Expiration time in seconds (optional)' }
},
required: ['key', 'value']
},
handler: storeMemory
},
{
name: 'memory_retrieve',
description: 'Retrieve information from persistent memory',
inputSchema: {
type: 'object',
properties: {
key: { type: 'string', description: 'Memory key (optional, returns all if not specified)' },
type: { type: 'string', description: 'Filter by memory type' }
}
},
handler: retrieveMemory
}
];
// Register all tools
tools.forEach(tool => {
server.registerTool(tool.name, tool.description, tool.inputSchema, tool.handler);
});
// Start the server
async function main() {
await ensureSharedDir();
const transport = new StdioServerTransport();
await server.connect(transport);
console.error(`Symphony of One MCP Server v1.0.0 - Agent Communication Tools`);
console.error(`Hub Server: ${SERVER_URL}`);
console.error(`Agent Name: ${agentName}`);
}
main().catch(console.error);
