480 lines
15 KiB
JavaScript
480 lines
15 KiB
JavaScript
#!/usr/bin/env node
|
|
/**
|
|
b * Multi-Agent Orchestrator MCP Server v2.0
|
|
*
|
|
* Cursor Agent CLI를 활용한 멀티에이전트 시스템
|
|
* - PM (Cursor IDE): 전체 조율
|
|
* - Sub-agents (agent CLI): 전문가별 작업 수행
|
|
*
|
|
* 모든 AI 호출이 Cursor Team Plan으로 처리됨!
|
|
* API 키 불필요!
|
|
*/
|
|
|
|
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
|
|
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
|
|
import {
|
|
CallToolRequestSchema,
|
|
ListToolsRequestSchema,
|
|
} from "@modelcontextprotocol/sdk/types.js";
|
|
import { spawn } from "child_process";
|
|
import { platform } from "os";
|
|
import { AGENT_CONFIGS } from "./agents/prompts.js";
|
|
import { AgentType, ParallelResult } from "./agents/types.js";
|
|
import { logger } from "./utils/logger.js";
|
|
|
|
// OS 감지
|
|
const isWindows = platform() === "win32";
|
|
logger.info(`Platform detected: ${platform()} (isWindows: ${isWindows})`);
|
|
|
|
// MCP 서버 생성
|
|
const server = new Server(
|
|
{
|
|
name: "agent-orchestrator",
|
|
version: "2.0.0",
|
|
},
|
|
{
|
|
capabilities: {
|
|
tools: {},
|
|
},
|
|
}
|
|
);
|
|
|
|
/**
|
|
* 유틸: ms만큼 대기
|
|
*/
|
|
function sleep(ms: number): Promise<void> {
|
|
return new Promise((resolve) => setTimeout(resolve, ms));
|
|
}
|
|
|
|
/**
|
|
* Cursor Agent CLI 단일 호출 (내부용)
|
|
* spawn + stdin 직접 전달
|
|
*/
|
|
function spawnAgentOnce(
|
|
agentType: AgentType,
|
|
fullPrompt: string,
|
|
model: string
|
|
): Promise<string> {
|
|
const agentPath = isWindows ? 'agent' : `${process.env.HOME}/.local/bin/agent`;
|
|
|
|
return new Promise<string>((resolve, reject) => {
|
|
let stdout = '';
|
|
let stderr = '';
|
|
let settled = false;
|
|
|
|
const child = spawn(agentPath, ['--model', model, '--print'], {
|
|
cwd: process.cwd(),
|
|
env: {
|
|
...process.env,
|
|
PATH: `${process.env.HOME}/.local/bin:${process.env.PATH}`,
|
|
},
|
|
stdio: ['pipe', 'pipe', 'pipe'],
|
|
});
|
|
|
|
child.stdout.on('data', (data: Buffer) => {
|
|
stdout += data.toString();
|
|
});
|
|
|
|
child.stderr.on('data', (data: Buffer) => {
|
|
stderr += data.toString();
|
|
});
|
|
|
|
child.on('error', (err: Error) => {
|
|
if (!settled) {
|
|
settled = true;
|
|
reject(err);
|
|
}
|
|
});
|
|
|
|
child.on('close', (code: number | null) => {
|
|
if (settled) return;
|
|
settled = true;
|
|
|
|
if (stderr) {
|
|
const significantStderr = stderr
|
|
.split('\n')
|
|
.filter((line: string) => line && !line.includes('warning') && !line.includes('info') && !line.includes('debug'))
|
|
.join('\n');
|
|
if (significantStderr) {
|
|
logger.warn(`${agentType} agent stderr`, { stderr: significantStderr.substring(0, 500) });
|
|
}
|
|
}
|
|
|
|
if (code === 0 || stdout.trim().length > 0) {
|
|
resolve(stdout.trim());
|
|
} else {
|
|
reject(new Error(
|
|
`Agent exited with code ${code}. stderr: ${stderr.substring(0, 1000)}`
|
|
));
|
|
}
|
|
});
|
|
|
|
// 타임아웃 (5분)
|
|
const timeout = setTimeout(() => {
|
|
if (!settled) {
|
|
settled = true;
|
|
child.kill('SIGTERM');
|
|
reject(new Error(`${agentType} agent timed out after 5 minutes`));
|
|
}
|
|
}, 300000);
|
|
|
|
child.on('close', () => clearTimeout(timeout));
|
|
|
|
// stdin으로 프롬프트 직접 전달
|
|
child.stdin.write(fullPrompt);
|
|
child.stdin.end();
|
|
});
|
|
}
|
|
|
|
/**
|
|
* Cursor Agent CLI를 통해 에이전트 호출 (재시도 포함)
|
|
*
|
|
* - 최대 2회 재시도 (총 3회 시도)
|
|
* - 재시도 간 2초 대기 (Cursor CLI 동시 실행 제한 대응)
|
|
*/
|
|
async function callAgentCLI(
|
|
agentType: AgentType,
|
|
task: string,
|
|
context?: string
|
|
): Promise<string> {
|
|
const config = AGENT_CONFIGS[agentType];
|
|
const model = agentType === 'pm' ? 'opus-4.5' : 'sonnet-4.5';
|
|
const maxRetries = 2;
|
|
|
|
logger.info(`Calling ${agentType} agent via CLI (spawn+retry)`, {
|
|
model,
|
|
task: task.substring(0, 100),
|
|
});
|
|
|
|
const userMessage = context
|
|
? `${task}\n\n배경 정보:\n${context}`
|
|
: task;
|
|
const fullPrompt = `${config.systemPrompt}\n\n---\n\n${userMessage}`;
|
|
|
|
let lastError: Error | null = null;
|
|
|
|
for (let attempt = 0; attempt <= maxRetries; attempt++) {
|
|
try {
|
|
if (attempt > 0) {
|
|
const delay = attempt * 2000; // 2초, 4초
|
|
logger.info(`${agentType} agent retry ${attempt}/${maxRetries} (waiting ${delay}ms)`);
|
|
await sleep(delay);
|
|
}
|
|
|
|
const result = await spawnAgentOnce(agentType, fullPrompt, model);
|
|
logger.info(`${agentType} agent completed (attempt ${attempt + 1})`);
|
|
return result;
|
|
} catch (error) {
|
|
lastError = error instanceof Error ? error : new Error(String(error));
|
|
logger.warn(`${agentType} agent attempt ${attempt + 1} failed`, {
|
|
error: lastError.message.substring(0, 200),
|
|
});
|
|
}
|
|
}
|
|
|
|
// 모든 재시도 실패
|
|
logger.error(`${agentType} agent failed after ${maxRetries + 1} attempts`);
|
|
throw lastError!;
|
|
}
|
|
|
|
/**
|
|
* 도구 목록 핸들러
|
|
*/
|
|
server.setRequestHandler(ListToolsRequestSchema, async () => {
|
|
return {
|
|
tools: [
|
|
{
|
|
name: "ask_backend_agent",
|
|
description:
|
|
"백엔드 전문가에게 질문하거나 작업을 요청합니다. " +
|
|
"API 설계, 서비스 로직, 라우팅, 미들웨어 관련 작업에 사용하세요. " +
|
|
"담당 폴더: backend-node/src/ (Cursor Agent CLI, sonnet-4.5 모델)" +
|
|
"주의: 단순 파일 읽기/수정은 PM이 직접 처리하세요. 깊은 분석이 필요할 때만 호출!",
|
|
inputSchema: {
|
|
type: "object" as const,
|
|
properties: {
|
|
task: {
|
|
type: "string",
|
|
description: "백엔드 에이전트에게 요청할 작업 내용",
|
|
},
|
|
context: {
|
|
type: "string",
|
|
description: "작업에 필요한 배경 정보 (선택사항)",
|
|
},
|
|
},
|
|
required: ["task"],
|
|
},
|
|
},
|
|
{
|
|
name: "ask_db_agent",
|
|
description:
|
|
"DB 전문가에게 질문하거나 작업을 요청합니다. " +
|
|
"스키마 설계, SQL 쿼리, MyBatis 매퍼, 마이그레이션 관련 작업에 사용하세요. " +
|
|
"담당 폴더: src/com/pms/mapper/, db/ (Cursor Agent CLI, sonnet-4.5 모델)" +
|
|
"주의: 단순 스키마 확인은 PM이 직접 처리하세요. 복잡한 쿼리 설계/최적화 시에만 호출!",
|
|
inputSchema: {
|
|
type: "object" as const,
|
|
properties: {
|
|
task: {
|
|
type: "string",
|
|
description: "DB 에이전트에게 요청할 작업 내용",
|
|
},
|
|
context: {
|
|
type: "string",
|
|
description: "작업에 필요한 배경 정보 (선택사항)",
|
|
},
|
|
},
|
|
required: ["task"],
|
|
},
|
|
},
|
|
{
|
|
name: "ask_frontend_agent",
|
|
description:
|
|
"프론트엔드 전문가에게 질문하거나 작업을 요청합니다. " +
|
|
"React 컴포넌트, 페이지, 스타일링, 상태관리 관련 작업에 사용하세요. " +
|
|
"담당 폴더: frontend/ (Cursor Agent CLI, sonnet-4.5 모델)" +
|
|
"주의: 단순 컴포넌트 읽기/수정은 PM이 직접 처리하세요. 구조 분석이 필요할 때만 호출!",
|
|
inputSchema: {
|
|
type: "object" as const,
|
|
properties: {
|
|
task: {
|
|
type: "string",
|
|
description: "프론트엔드 에이전트에게 요청할 작업 내용",
|
|
},
|
|
context: {
|
|
type: "string",
|
|
description: "작업에 필요한 배경 정보 (선택사항)",
|
|
},
|
|
},
|
|
required: ["task"],
|
|
},
|
|
},
|
|
{
|
|
name: "parallel_ask",
|
|
description:
|
|
"여러 전문가에게 동시에 질문합니다 (진짜 병렬 실행!). " +
|
|
"3개 영역(FE+BE+DB) 크로스도메인 분석이 필요할 때만 사용하세요. " +
|
|
"주의: 호출 시간이 오래 걸림! 단순 작업은 PM이 직접 처리하는 게 훨씬 빠릅니다. " +
|
|
"적합한 경우: 전체 아키텍처 파악, 대규모 리팩토링 계획, 크로스도메인 영향 분석",
|
|
inputSchema: {
|
|
type: "object" as const,
|
|
properties: {
|
|
requests: {
|
|
type: "array",
|
|
description: "각 에이전트에게 보낼 요청 목록",
|
|
items: {
|
|
type: "object",
|
|
properties: {
|
|
agent: {
|
|
type: "string",
|
|
enum: ["backend", "db", "frontend"],
|
|
description: "요청할 에이전트 타입",
|
|
},
|
|
task: {
|
|
type: "string",
|
|
description: "해당 에이전트에게 요청할 작업",
|
|
},
|
|
context: {
|
|
type: "string",
|
|
description: "배경 정보 (선택사항)",
|
|
},
|
|
},
|
|
required: ["agent", "task"],
|
|
},
|
|
},
|
|
},
|
|
required: ["requests"],
|
|
},
|
|
},
|
|
{
|
|
name: "get_agent_info",
|
|
description:
|
|
"에이전트 시스템의 현재 상태와 사용 가능한 에이전트 정보를 확인합니다.",
|
|
inputSchema: {
|
|
type: "object" as const,
|
|
properties: {},
|
|
},
|
|
},
|
|
],
|
|
};
|
|
});
|
|
|
|
/**
|
|
* 도구 호출 핸들러
|
|
*/
|
|
server.setRequestHandler(CallToolRequestSchema, async (request) => {
|
|
const { name, arguments: args } = request.params;
|
|
|
|
logger.info(`Tool called: ${name}`);
|
|
|
|
try {
|
|
switch (name) {
|
|
case "ask_backend_agent": {
|
|
const { task, context } = args as { task: string; context?: string };
|
|
const result = await callAgentCLI("backend", task, context);
|
|
return {
|
|
content: [{ type: "text" as const, text: result }],
|
|
};
|
|
}
|
|
|
|
case "ask_db_agent": {
|
|
const { task, context } = args as { task: string; context?: string };
|
|
const result = await callAgentCLI("db", task, context);
|
|
return {
|
|
content: [{ type: "text" as const, text: result }],
|
|
};
|
|
}
|
|
|
|
case "ask_frontend_agent": {
|
|
const { task, context } = args as { task: string; context?: string };
|
|
const result = await callAgentCLI("frontend", task, context);
|
|
return {
|
|
content: [{ type: "text" as const, text: result }],
|
|
};
|
|
}
|
|
|
|
case "parallel_ask": {
|
|
const { requests } = args as {
|
|
requests: Array<{
|
|
agent: "backend" | "db" | "frontend";
|
|
task: string;
|
|
context?: string;
|
|
}>;
|
|
};
|
|
|
|
logger.info(`Parallel ask to ${requests.length} agents (STAGGERED PARALLEL)`);
|
|
|
|
// 시차 병렬 실행: 각 에이전트를 500ms 간격으로 시작
|
|
// Cursor Agent CLI 동시 실행 제한 대응
|
|
const STAGGER_DELAY = 500; // ms
|
|
|
|
const results: ParallelResult[] = await Promise.all(
|
|
requests.map(async (req, index) => {
|
|
try {
|
|
// 시차 적용 (첫 번째는 즉시, 이후 500ms 간격)
|
|
if (index > 0) {
|
|
await sleep(index * STAGGER_DELAY);
|
|
}
|
|
const result = await callAgentCLI(req.agent, req.task, req.context);
|
|
return { agent: req.agent, result };
|
|
} catch (error) {
|
|
return {
|
|
agent: req.agent,
|
|
result: "",
|
|
error: error instanceof Error ? error.message : "Unknown error",
|
|
};
|
|
}
|
|
})
|
|
);
|
|
|
|
// 결과를 보기 좋게 포맷팅
|
|
const formattedResults = results.map((r) => {
|
|
const header = `\n${"=".repeat(60)}\n## ${r.agent.toUpperCase()} Agent 응답\n${"=".repeat(60)}\n`;
|
|
if (r.error) {
|
|
return `${header}❌ 에러: ${r.error}`;
|
|
}
|
|
return `${header}${r.result}`;
|
|
});
|
|
|
|
return {
|
|
content: [
|
|
{
|
|
type: "text" as const,
|
|
text: formattedResults.join("\n"),
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
case "get_agent_info": {
|
|
const info = {
|
|
system: "Multi-Agent Orchestrator v2.0",
|
|
version: "2.0.0",
|
|
backend: "Cursor Agent CLI (Team Plan)",
|
|
cliPath: `${process.env.HOME}/.local/bin/agent`,
|
|
apiKey: "NOT REQUIRED! Using Cursor Team Plan credits",
|
|
agents: {
|
|
pm: {
|
|
role: "Project Manager",
|
|
model: "opus-4.5 (Cursor IDE에서 직접)",
|
|
description: "전체 조율, 사용자 의도 파악, 작업 분배",
|
|
},
|
|
backend: {
|
|
role: "Backend Specialist",
|
|
model: "sonnet-4.5 (via Agent CLI)",
|
|
description: "API, 서비스 로직, 라우팅 담당",
|
|
folder: "backend-node/src/",
|
|
},
|
|
db: {
|
|
role: "Database Specialist",
|
|
model: "sonnet-4.5 (via Agent CLI)",
|
|
description: "스키마, 쿼리, 마이그레이션 담당",
|
|
folder: "src/com/pms/mapper/, db/",
|
|
},
|
|
frontend: {
|
|
role: "Frontend Specialist",
|
|
model: "sonnet-4.5 (via Agent CLI)",
|
|
description: "컴포넌트, 페이지, 스타일링 담당",
|
|
folder: "frontend/",
|
|
},
|
|
},
|
|
features: {
|
|
parallel_execution: true,
|
|
cursor_team_plan: true,
|
|
cursor_agent_cli: true,
|
|
separate_api_key: false,
|
|
cross_platform: true,
|
|
},
|
|
usage: {
|
|
single_agent: "ask_backend_agent, ask_db_agent, ask_frontend_agent",
|
|
parallel: "parallel_ask로 여러 에이전트 동시 호출",
|
|
workflow: "1. parallel_ask로 정보 수집 → 2. 개별 에이전트로 작업 분배",
|
|
},
|
|
};
|
|
|
|
return {
|
|
content: [
|
|
{
|
|
type: "text" as const,
|
|
text: JSON.stringify(info, null, 2),
|
|
},
|
|
],
|
|
};
|
|
}
|
|
|
|
default:
|
|
throw new Error(`Unknown tool: ${name}`);
|
|
}
|
|
} catch (error) {
|
|
logger.error(`Tool error: ${name}`, error);
|
|
return {
|
|
content: [
|
|
{
|
|
type: "text" as const,
|
|
text: `❌ 에러 발생: ${error instanceof Error ? error.message : "Unknown error"}`,
|
|
},
|
|
],
|
|
isError: true,
|
|
};
|
|
}
|
|
});
|
|
|
|
/**
|
|
* 서버 시작
|
|
*/
|
|
async function main() {
|
|
logger.info("Starting Multi-Agent Orchestrator MCP Server v2.0...");
|
|
logger.info(`Backend: Cursor Agent CLI (${process.env.HOME}/.local/bin/agent)`);
|
|
logger.info("Credits: Cursor Team Plan - No API Key Required!");
|
|
|
|
const transport = new StdioServerTransport();
|
|
await server.connect(transport);
|
|
|
|
logger.info("MCP Server connected and ready!");
|
|
}
|
|
|
|
main().catch((error) => {
|
|
logger.error("Server failed to start", error);
|
|
process.exit(1);
|
|
});
|