#!/usr/bin/env node
// Enhanced environment loading inspired by Base MCP
import * as dotenv from 'dotenv';
import { existsSync } from 'fs';
import { join } from 'path';
// Load environment variables with Base MCP inspired approach
function loadEnvironment() {
// First try .env in current directory
const envPath = join(process.cwd(), '.env');
if (existsSync(envPath)) {
dotenv.config({ path: envPath });
} else {
// Fallback to default dotenv behavior
dotenv.config();
}
}
// Load environment first
loadEnvironment();
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
CallToolRequestSchema,
ListToolsRequestSchema,
Tool,
} from '@modelcontextprotocol/sdk/types.js';
import { networkTools, handleNetworkTool } from './tools/network/index.js';
import { proverActionProvider, handleProverTool } from './tools/prover/index.js';
import { monitoringTools, handleMonitoringTool } from './tools/monitoring/index.js';
import { handleCliArguments } from './main.js';
function displayBanner() {
console.error(`
██████╗ ██████╗ ██████╗ ██╗ ██╗███████╗██████╗ ███╗ ███╗ ██████╗██████╗
██╔══██╗██╔══██╗██╔═══██╗██║ ██║██╔════╝██╔══██╗ ████╗ ████║██╔════╝██╔══██╗
██████╔╝██████╔╝██║ ██║██║ ██║█████╗ ██████╔╝ ██╔████╔██║██║ ██████╔╝
██╔═══╝ ██╔══██╗██║ ██║╚██╗ ██╔╝██╔══╝ ██╔══██╗ ██║╚██╔╝██║██║ ██╔═══╝
██║ ██║ ██║╚██████╔╝ ╚████╔╝ ███████╗██║ ██║ ██║ ╚═╝ ██║╚██████╗██║
╚═╝ ╚═╝ ╚═╝ ╚═════╝ ╚═══╝ ╚══════╝╚═╝ ╚═╝ ╚═╝ ╚═╝ ╚═════╝╚═╝
🌟 Succinct Prover Network Monitoring & Optimization
`);
}
export async function startMcpServer() {
// Check for CLI arguments first
const shouldStartServer = await handleCliArguments();
if (!shouldStartServer) {
return;
}
// Display banner
displayBanner();
const server = new Server(
{
name: 'prover-mcp',
version: '2.0.0',
},
{
capabilities: {
tools: {},
},
}
);
// Get configuration from environment with enhanced debugging
const rpcUrl = process.env.SUCCINCT_RPC_URL || 'https://rpc-production.succinct.xyz';
const proverAddress = process.env.PROVER_ADDRESS;
const privateKey = process.env.PRIVATE_KEY || process.env.PROVER_PRIVATE_KEY;
// Production mode: minimal logging
const hasCredentials = privateKey && privateKey !== '' && privateKey !== 'your_private_key_here' && privateKey.length >= 64;
const hasProverAddress = proverAddress && proverAddress !== '' && proverAddress !== 'your_prover_address_here' && proverAddress.startsWith('0x');
if (process.env.NODE_ENV === 'development') {
console.error('🔧 Succinct Prover Network MCP Starting...');
console.error(`🌐 RPC URL: ${rpcUrl}`);
console.error(`🔐 Private Key: ${hasCredentials ? '✅ Valid (64+ chars)' : '❌ Missing/Invalid'}`);
console.error(`📍 Prover Address: ${hasProverAddress ? '✅ Valid' : '❌ Missing/Invalid'}`);
if (hasCredentials && hasProverAddress) {
console.error('🚀 PRODUCTION MODE: Full prover functionality available');
} else {
console.error('📊 MONITORING MODE: Read-only network analysis available');
}
}
// Instantiate the provider to get the tools
const proverProvider = proverActionProvider();
const proverTools = proverProvider.tools;
// List available tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
const allTools = [
...networkTools,
...proverTools,
...monitoringTools
];
return {
tools: allTools,
};
});
// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
const { name, arguments: args } = request.params;
try {
// Route to appropriate handler
if (networkTools.find((tool: Tool) => tool.name === name)) {
return await handleNetworkTool(name, args);
}
if (proverTools.find((tool: Tool) => tool.name === name)) {
return await handleProverTool(name, args);
}
if (monitoringTools.find((tool: Tool) => tool.name === name)) {
return await handleMonitoringTool(name, args);
}
throw new Error(`Unknown tool: ${name}`);
} catch (error) {
console.error(`Error handling tool ${name}:`, error);
return {
content: [
{
type: 'text',
text: `Error: ${error instanceof Error ? error.message : String(error)}`,
},
],
};
}
});
const transport = new StdioServerTransport();
await server.connect(transport);
console.error('✅ Succinct Prover Network MCP Server running');
}
// Handle graceful shutdown
process.on('SIGINT', async () => {
console.error('🛑 Shutting down MCP server...');
process.exit(0);
});
process.on('SIGTERM', async () => {
console.error('🛑 Shutting down MCP server...');
process.exit(0);
});
if (import.meta.url === `file://${process.argv[1]}`) {
startMcpServer().catch((error) => {
console.error('❌ Failed to start MCP server:', error);
process.exit(1);
});
}
