#!/usr/bin/env node
/**
* Code-MCP HTTP Server
* Cloud-deployable version with HTTP transport and authentication
*/
import express, { Request, Response, NextFunction } from 'express';
import cors from 'cors';
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import {
CallToolRequestSchema,
ListResourcesRequestSchema,
ListToolsRequestSchema,
ReadResourceRequestSchema,
ListPromptsRequestSchema,
GetPromptRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { zodToJsonSchema } from "zod-to-json-schema";
// Import all tools (same as index.ts)
import { sequentialThinkingSchema, sequentialThinkingHandler } from "./tools/thinking.js";
import { saveMemorySchema, readMemorySchema, listMemoriesSchema, clearMemorySchema, saveMemoryHandler, readMemoryHandler, listMemoriesHandler, clearMemoryHandler } from "./tools/memory.js";
import { validateCodeSchema, validateCodeHandler } from "./tools/validator.js";
import {
generateCursorRulesSchema, generateCursorRulesHandler,
generateGeminiConfigSchema, generateGeminiConfigHandler,
generateClaudeConfigSchema, generateClaudeConfigHandler,
generateWindsurfConfigSchema, generateWindsurfConfigHandler,
generateAiderConfigSchema, generateAiderConfigHandler,
generateClineConfigSchema, generateClineConfigHandler,
generateCopilotConfigSchema, generateCopilotConfigHandler
} from "./tools/aiconfigs.js";
import {
planTaskSchema, planTaskHandler,
reflectOnCodeSchema, reflectOnCodeHandler,
analyzeArchitectureSchema, analyzeArchitectureHandler,
debugProblemSchema, debugProblemHandler,
brainstormSolutionsSchema, brainstormSolutionsHandler,
compareApproachesSchema, compareApproachesHandler,
estimateComplexitySchema, estimateComplexityHandler,
generateTestsSchema, generateTestsHandler,
explainCodeSchema, explainCodeHandler
} from "./tools/cognitive.js";
import {
checkImportsSchema, checkImportsHandler,
lintCodeSchema, lintCodeHandler,
formatCodeSchema, formatCodeHandler
} from "./tools/linting.js";
import {
generateContinueConfigSchema, generateContinueConfigHandler,
generateTabnineConfigSchema, generateTabnineConfigHandler,
generateVSCodeTasksSchema, generateVSCodeTasksHandler,
generateVSCodeLaunchSchema, generateVSCodeLaunchHandler,
generateJetBrainsConfigSchema, generateJetBrainsConfigHandler
} from "./tools/ideconfigs.js";
import {
trackProjectSchema, trackProjectHandler,
checkDependenciesSchema, checkDependenciesHandler,
generateGitHubActionsSchema, generateGitHubActionsHandler,
fullStackScaffoldSchema, fullStackScaffoldHandler,
developerRulesSchema, developerRulesHandler
} from "./tools/fullstack.js";
import { prompts, getPrompt } from "./prompts.js";
// Load registries
import languagesRegistry from "./data/languages.json" with { type: "json" };
import databasesRegistry from "./data/databases.json" with { type: "json" };
import frameworksRegistry from "./data/frameworks.json" with { type: "json" };
const app = express();
app.use(cors());
app.use(express.json());
// API Key Authentication (optional)
const API_KEY = process.env.CODE_MCP_API_KEY;
const authMiddleware = (req: Request, res: Response, next: NextFunction) => {
if (API_KEY) {
const key = req.headers['x-api-key'];
if (key !== API_KEY) {
return res.status(401).json({ error: 'Unauthorized' });
}
}
next();
};
// Tool registry (same as index.ts)
const toolRegistry = new Map<string, { schema: any; handler: any }>([
["sequential_thinking", { schema: sequentialThinkingSchema, handler: sequentialThinkingHandler }],
["plan_task", { schema: planTaskSchema, handler: planTaskHandler }],
["reflect_on_code", { schema: reflectOnCodeSchema, handler: reflectOnCodeHandler }],
["analyze_architecture", { schema: analyzeArchitectureSchema, handler: analyzeArchitectureHandler }],
["debug_problem", { schema: debugProblemSchema, handler: debugProblemHandler }],
["brainstorm_solutions", { schema: brainstormSolutionsSchema, handler: brainstormSolutionsHandler }],
["compare_approaches", { schema: compareApproachesSchema, handler: compareApproachesHandler }],
["estimate_complexity", { schema: estimateComplexitySchema, handler: estimateComplexityHandler }],
["generate_tests", { schema: generateTestsSchema, handler: generateTestsHandler }],
["explain_code", { schema: explainCodeSchema, handler: explainCodeHandler }],
["save_memory", { schema: saveMemorySchema, handler: saveMemoryHandler }],
["read_memory", { schema: readMemorySchema, handler: readMemoryHandler }],
["list_memories", { schema: listMemoriesSchema, handler: listMemoriesHandler }],
["clear_memory", { schema: clearMemorySchema, handler: clearMemoryHandler }],
["validate_code", { schema: validateCodeSchema, handler: validateCodeHandler }],
["check_imports", { schema: checkImportsSchema, handler: checkImportsHandler }],
["lint_code", { schema: lintCodeSchema, handler: lintCodeHandler }],
["format_code", { schema: formatCodeSchema, handler: formatCodeHandler }],
["generate_cursor_rules", { schema: generateCursorRulesSchema, handler: generateCursorRulesHandler }],
["generate_gemini_config", { schema: generateGeminiConfigSchema, handler: generateGeminiConfigHandler }],
["generate_claude_config", { schema: generateClaudeConfigSchema, handler: generateClaudeConfigHandler }],
["generate_windsurf_config", { schema: generateWindsurfConfigSchema, handler: generateWindsurfConfigHandler }],
["generate_aider_config", { schema: generateAiderConfigSchema, handler: generateAiderConfigHandler }],
["generate_cline_config", { schema: generateClineConfigSchema, handler: generateClineConfigHandler }],
["generate_copilot_config", { schema: generateCopilotConfigSchema, handler: generateCopilotConfigHandler }],
["generate_continue_config", { schema: generateContinueConfigSchema, handler: generateContinueConfigHandler }],
["generate_tabnine_config", { schema: generateTabnineConfigSchema, handler: generateTabnineConfigHandler }],
["generate_vscode_tasks", { schema: generateVSCodeTasksSchema, handler: generateVSCodeTasksHandler }],
["generate_vscode_launch", { schema: generateVSCodeLaunchSchema, handler: generateVSCodeLaunchHandler }],
["generate_jetbrains_config", { schema: generateJetBrainsConfigSchema, handler: generateJetBrainsConfigHandler }],
["track_project", { schema: trackProjectSchema, handler: trackProjectHandler }],
["check_dependencies", { schema: checkDependenciesSchema, handler: checkDependenciesHandler }],
["generate_github_actions", { schema: generateGitHubActionsSchema, handler: generateGitHubActionsHandler }],
["full_stack_scaffold", { schema: fullStackScaffoldSchema, handler: fullStackScaffoldHandler }],
["developer_rules", { schema: developerRulesSchema, handler: developerRulesHandler }],
]);
// Health check
app.get('/health', (req, res) => {
res.json({
status: 'healthy',
version: '1.0.0',
tools: toolRegistry.size,
resources: (languagesRegistry as any).languages.length +
(databasesRegistry as any).databases.length +
(frameworksRegistry as any).frameworks.length,
prompts: Object.keys(prompts).length
});
});
// List tools
app.get('/tools', authMiddleware, (req, res) => {
const tools = Array.from(toolRegistry.values()).map(({ schema }) => ({
name: schema.name,
description: schema.description,
inputSchema: zodToJsonSchema(schema.inputSchema)
}));
res.json({ tools });
});
// Call tool
app.post('/tools/:name', authMiddleware, async (req, res) => {
const { name } = req.params;
const args = req.body;
const tool = toolRegistry.get(name);
if (!tool) {
return res.status(404).json({ error: `Tool not found: ${name}` });
}
try {
const result = await tool.handler(args);
res.json(result);
} catch (error) {
res.status(500).json({ error: (error as Error).message });
}
});
// List resources
app.get('/resources', authMiddleware, (req, res) => {
const langs = (languagesRegistry as any).languages.map((l: any) => ({
uri: `code-rules://language/${l.id}`,
name: `${l.name} Coding Rules`
}));
const dbs = (databasesRegistry as any).databases.map((d: any) => ({
uri: `code-rules://database/${d.id}`,
name: `${d.name} Best Practices`
}));
const fws = (frameworksRegistry as any).frameworks.map((f: any) => ({
uri: `code-rules://framework/${f.id}`,
name: `${f.name} Best Practices`
}));
res.json({ resources: [...langs, ...dbs, ...fws] });
});
// List prompts
app.get('/prompts', authMiddleware, (req, res) => {
res.json({
prompts: Object.values(prompts).map(p => ({
name: p.name,
description: p.description
}))
});
});
// MCP-compatible endpoint (JSON-RPC)
app.post('/mcp', authMiddleware, async (req, res) => {
const { jsonrpc, id, method, params } = req.body;
try {
let result;
switch (method) {
case 'tools/list':
result = {
tools: Array.from(toolRegistry.values()).map(({ schema }) => ({
name: schema.name,
description: schema.description,
inputSchema: zodToJsonSchema(schema.inputSchema)
}))
};
break;
case 'tools/call':
const tool = toolRegistry.get(params.name);
if (!tool) throw new Error(`Tool not found: ${params.name}`);
result = await tool.handler(params.arguments);
break;
default:
throw new Error(`Unknown method: ${method}`);
}
res.json({ jsonrpc: '2.0', id, result });
} catch (error) {
res.json({ jsonrpc: '2.0', id, error: { message: (error as Error).message } });
}
});
const PORT = process.env.PORT || 3000;
app.listen(PORT, () => {
console.log(`Code-MCP HTTP Server running on port ${PORT}`);
console.log(`Tools: ${toolRegistry.size} | Resources: 130+ | Prompts: ${Object.keys(prompts).length}`);
});