test-server.ts

/**
 * MCP Test Server
 *
 * A lightweight HTTP server that wraps the MCP server for testing purposes.
 * This allows the admin tools page to test MCP-only tools via HTTP.
 *
 * Usage:
 *   CONTEXTSTREAM_API_KEY="your_key" npx tsx src/test-server.ts
 *
 * Endpoints:
 *   POST /test-tool - Execute an MCP tool
 *     Body: { "tool": "session_init", "arguments": { ... } }
 *   GET /health - Health check
 *   GET /tools - List available tools
 */

import { createServer, IncomingMessage, ServerResponse } from "http";
import { spawn, ChildProcess } from "child_process";
import { createInterface, Interface } from "readline";
import { loadConfig } from "./config.js";
import { VERSION } from "./version.js";

const PORT = parseInt(process.env.MCP_TEST_PORT || "3099", 10);

interface JsonRpcRequest {
  jsonrpc: "2.0";
  id: number;
  method: string;
  params?: unknown;
}

interface JsonRpcResponse {
  jsonrpc: "2.0";
  id: number;
  result?: unknown;
  error?: {
    code: number;
    message: string;
    data?: unknown;
  };
}

// Pending requests map
const pendingRequests = new Map<
  number,
  {
    resolve: (value: JsonRpcResponse) => void;
    reject: (error: Error) => void;
  }
>();

let requestId = 0;
let mcpProcess: ChildProcess | null = null;
let mcpReadline: Interface | null = null;
let initialized = false;

/**
 * Start the MCP server as a subprocess
 */
async function startMcpServer(): Promise<void> {
  const config = loadConfig();

  console.log("[MCP Test Server] Starting MCP subprocess...");
  console.log(`[MCP Test Server] API URL: ${config.apiUrl}`);
  console.log(`[MCP Test Server] Auth: ${config.apiKey ? "API Key" : config.jwt ? "JWT" : "None"}`);

  // Build env vars, only including auth vars if they have values
  // (empty strings fail Zod's min(1) validation)
  const mcpEnv: Record<string, string> = {
    ...(process.env as Record<string, string>),
    CONTEXTSTREAM_API_URL: config.apiUrl,
  };
  if (config.apiKey) mcpEnv.CONTEXTSTREAM_API_KEY = config.apiKey;
  if (config.jwt) mcpEnv.CONTEXTSTREAM_JWT = config.jwt;

  mcpProcess = spawn("node", ["dist/index.js"], {
    cwd: process.cwd(),
    env: mcpEnv,
    stdio: ["pipe", "pipe", "pipe"],
  });

  // Handle stderr (logs)
  mcpProcess.stderr?.on("data", (data: Buffer) => {
    const msg = data.toString().trim();
    if (msg) {
      console.log(`[MCP] ${msg}`);
    }
  });

  // Handle stdout (JSON-RPC responses)
  mcpReadline = createInterface({
    input: mcpProcess.stdout!,
    terminal: false,
  });

  mcpReadline.on("line", (line: string) => {
    try {
      const response = JSON.parse(line) as JsonRpcResponse;
      const pending = pendingRequests.get(response.id);
      if (pending) {
        pendingRequests.delete(response.id);
        pending.resolve(response);
      }
    } catch {
      // Ignore non-JSON lines
    }
  });

  mcpProcess.on("error", (err: Error) => {
    console.error("[MCP Test Server] MCP process error:", err);
  });

  mcpProcess.on("exit", (code: number | null) => {
    console.log(`[MCP Test Server] MCP process exited with code ${code}`);
    mcpProcess = null;
    initialized = false;
  });

  // Wait for MCP server to be ready
  await new Promise<void>((resolve) => setTimeout(resolve, 500));

  // Initialize the MCP session
  await initializeMcp();
}

/**
 * Send a JSON-RPC request to the MCP server
 */
async function sendRequest(method: string, params?: unknown): Promise<JsonRpcResponse> {
  if (!mcpProcess || !mcpProcess.stdin) {
    throw new Error("MCP process not running");
  }

  const id = ++requestId;
  const request: JsonRpcRequest = {
    jsonrpc: "2.0",
    id,
    method,
    params,
  };

  return new Promise((resolve, reject) => {
    pendingRequests.set(id, { resolve, reject });

    const timeoutId = setTimeout(() => {
      pendingRequests.delete(id);
      reject(new Error("Request timeout"));
    }, 30000);

    mcpProcess!.stdin!.write(JSON.stringify(request) + "\n", (err: Error | null | undefined) => {
      if (err) {
        clearTimeout(timeoutId);
        pendingRequests.delete(id);
        reject(err);
      }
    });

    // Clear timeout on success
    pendingRequests.get(id)!.resolve = (value: JsonRpcResponse) => {
      clearTimeout(timeoutId);
      resolve(value);
    };
  });
}

/**
 * Initialize the MCP connection
 */
async function initializeMcp(): Promise<void> {
  console.log("[MCP Test Server] Initializing MCP connection...");

  const response = await sendRequest("initialize", {
    protocolVersion: "2024-11-05",
    capabilities: {},
    clientInfo: {
      name: "mcp-test-server",
      version: VERSION,
    },
  });

  if (response.error) {
    throw new Error(`MCP initialization failed: ${response.error.message}`);
  }

  // Send initialized notification
  if (mcpProcess?.stdin) {
    mcpProcess.stdin.write(
      JSON.stringify({
        jsonrpc: "2.0",
        method: "notifications/initialized",
      }) + "\n"
    );
  }

  initialized = true;
  console.log("[MCP Test Server] MCP connection initialized");
}

/**
 * Call an MCP tool
 */
async function callTool(toolName: string, args: Record<string, unknown>): Promise<unknown> {
  if (!initialized) {
    await initializeMcp();
  }

  const response = await sendRequest("tools/call", {
    name: toolName,
    arguments: args,
  });

  if (response.error) {
    throw new Error(response.error.message);
  }

  return response.result;
}

/**
 * List available tools
 */
async function listTools(): Promise<unknown> {
  if (!initialized) {
    await initializeMcp();
  }

  const response = await sendRequest("tools/list", {});

  if (response.error) {
    throw new Error(response.error.message);
  }

  return response.result;
}

/**
 * Parse request body
 */
async function parseBody(req: IncomingMessage): Promise<unknown> {
  return new Promise((resolve, reject) => {
    let body = "";
    req.on("data", (chunk: Buffer) => {
      body += chunk.toString();
    });
    req.on("end", () => {
      try {
        resolve(body ? JSON.parse(body) : {});
      } catch {
        reject(new Error("Invalid JSON"));
      }
    });
    req.on("error", reject);
  });
}

/**
 * Send JSON response
 */
function sendJson(res: ServerResponse, status: number, data: unknown): void {
  res.writeHead(status, {
    "Content-Type": "application/json",
    "Access-Control-Allow-Origin": "*",
    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
    "Access-Control-Allow-Headers": "Content-Type, Authorization",
  });
  res.end(JSON.stringify(data));
}

/**
 * HTTP request handler
 */
async function handleRequest(req: IncomingMessage, res: ServerResponse): Promise<void> {
  const url = new URL(req.url || "/", `http://localhost:${PORT}`);

  // Handle CORS preflight
  if (req.method === "OPTIONS") {
    res.writeHead(204, {
      "Access-Control-Allow-Origin": "*",
      "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
      "Access-Control-Allow-Headers": "Content-Type, Authorization",
    });
    res.end();
    return;
  }

  try {
    // Health check
    if (url.pathname === "/health") {
      sendJson(res, 200, {
        status: "ok",
        version: VERSION,
        mcpRunning: mcpProcess !== null,
        initialized,
      });
      return;
    }

    // List tools
    if (url.pathname === "/tools" && req.method === "GET") {
      const tools = await listTools();
      sendJson(res, 200, { success: true, data: tools });
      return;
    }

    // Test tool
    if (url.pathname === "/test-tool" && req.method === "POST") {
      const body = (await parseBody(req)) as { tool?: string; arguments?: Record<string, unknown> };

      if (!body.tool) {
        sendJson(res, 400, { success: false, error: "Missing tool name" });
        return;
      }

      const start = Date.now();
      const result = await callTool(body.tool, body.arguments || {});
      const responseTime = Date.now() - start;

      sendJson(res, 200, {
        success: true,
        data: result,
        responseTime,
        tool: body.tool,
      });
      return;
    }

    // Not found
    sendJson(res, 404, { success: false, error: "Not found" });
  } catch (error: unknown) {
    const err = error as Error;
    console.error("[MCP Test Server] Error:", err.message);
    sendJson(res, 500, {
      success: false,
      error: err.message,
    });
  }
}

/**
 * Main entry point
 */
async function main(): Promise<void> {
  console.log(`[MCP Test Server] Starting on port ${PORT}...`);

  // Start MCP server subprocess
  await startMcpServer();

  // Create HTTP server
  const server = createServer(handleRequest);

  server.listen(PORT, "0.0.0.0", () => {
    console.log(`[MCP Test Server] Listening on http://0.0.0.0:${PORT}`);
    console.log(`[MCP Test Server] Endpoints:`);
    console.log(`  GET  /health     - Health check`);
    console.log(`  GET  /tools      - List available tools`);
    console.log(`  POST /test-tool  - Execute a tool`);
  });

  // Handle shutdown
  process.on("SIGINT", () => {
    console.log("\n[MCP Test Server] Shutting down...");
    if (mcpProcess) {
      mcpProcess.kill();
    }
    server.close();
    process.exit(0);
  });
}

main().catch((err) => {
  console.error("[MCP Test Server] Fatal error:", err);
  process.exit(1);
});