tak-server-mcp-skyfi/dist/index.js

Model Context Protocol (MCP) server for TAK Server integration with geospatial support

#!/usr/bin/env node
"use strict";
var __importDefault = (this && this.__importDefault) || function (mod) {
    return (mod && mod.__esModule) ? mod : { "default": mod };
};
Object.defineProperty(exports, "__esModule", { value: true });
const index_js_1 = require("@modelcontextprotocol/sdk/server/index.js");
const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
const types_js_1 = require("@modelcontextprotocol/sdk/types.js");
const pino_1 = __importDefault(require("pino"));
const index_1 = require("./config/index");
const tak_server_1 = require("./clients/tak-server");
const registry_1 = require("./tools/registry");
const http_1 = require("./transports/http");
const sse_1 = require("./transports/sse");
const logger = (0, pino_1.default)({
    level: process.env.LOG_LEVEL || 'info',
    transport: {
        target: 'pino-pretty',
        options: {
            colorize: true
        }
    }
});
async function main() {
    const config = (0, index_1.getConfig)();
    logger.info('Starting TAK Server MCP...');
    // Initialize TAK Server client
    const takClient = new tak_server_1.TAKServerClient({
        url: config.takServer.url,
        apiToken: config.takServer.apiToken,
        clientCert: config.takServer.clientCert,
        clientKey: config.takServer.clientKey,
        verifySsl: config.takServer.verifySsl
    });
    // Test connection
    try {
        await takClient.testConnection();
        logger.info('Successfully connected to TAK Server');
    }
    catch (error) {
        logger.error('Failed to connect to TAK Server:', error);
        process.exit(1);
    }
    // Create MCP server
    const server = new index_js_1.Server({
        name: 'tak-server-mcp',
        vendor: 'skyfi',
        version: '0.1.0',
        description: 'Model Context Protocol server for TAK Server integration'
    }, {
        capabilities: {
            tools: {}
        }
    });
    // Register tool handlers
    server.setRequestHandler(types_js_1.ListToolsRequestSchema, async () => {
        const tools = registry_1.toolRegistry.getEnabledTools(config.tools.enabledTools);
        return { tools };
    });
    server.setRequestHandler(types_js_1.CallToolRequestSchema, async (request) => {
        const tool = registry_1.toolRegistry.getTool(request.params.name);
        if (!tool) {
            throw new Error(`Tool not found: ${request.params.name}`);
        }
        try {
            const result = await tool.handler({
                takClient,
                params: request.params.arguments || {},
                logger: logger.child({ tool: request.params.name })
            });
            return {
                content: [
                    {
                        type: 'text',
                        text: typeof result === 'string' ? result : JSON.stringify(result, null, 2)
                    }
                ]
            };
        }
        catch (error) {
            logger.error(`Tool execution failed: ${request.params.name}`, error);
            return {
                content: [
                    {
                        type: 'text',
                        text: `Error: ${error instanceof Error ? error.message : 'Unknown error'}`
                    }
                ]
            };
        }
    });
    // Select transport based on configuration
    let transport;
    switch (config.mcp.transport) {
        case 'stdio':
            logger.info('Using stdio transport');
            transport = new stdio_js_1.StdioServerTransport();
            break;
        case 'http':
            logger.info(`Using HTTP transport on port ${config.mcp.port}`);
            transport = await (0, http_1.createHttpTransport)(server, config);
            break;
        case 'sse':
            logger.info(`Using SSE transport on port ${config.mcp.port}`);
            transport = await (0, sse_1.createSSETransport)(server, config);
            break;
        default:
            throw new Error(`Unknown transport: ${config.mcp.transport}`);
    }
    // Start server
    await server.connect(transport);
    logger.info('TAK Server MCP is running');
    // Handle shutdown
    process.on('SIGINT', async () => {
        logger.info('Shutting down...');
        await server.close();
        process.exit(0);
    });
}
// Error handling
process.on('unhandledRejection', (reason, promise) => {
    logger.error('Unhandled Rejection at:', promise, 'reason:', reason);
    process.exit(1);
});
main().catch((error) => {
    logger.error('Fatal error:', error);
    process.exit(1);
});
//# sourceMappingURL=index.js.map