import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
  ListResourcesRequestSchema,
  ReadResourceRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";

// Initialize MCP server
const server = new Server(
  { name: "metrics-server", version: "1.0.0" },
  { capabilities: { tools: {}, resources: {} } }
);

// Define available tools
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "get_error_rate",
      description: "Get the error rate for a service in the last N minutes",
      inputSchema: {
        type: "object",
        properties: {
          service: {
            type: "string",
            description: "Service name (e.g., api, worker, frontend)"
          },
          minutes: {
            type: "number",
            description: "Time window in minutes (default: 60)",
            default: 60
          }
        },
        required: ["service"]
      }
    },
    {
      name: "get_active_incidents",
      description: "List all currently active incidents",
      inputSchema: {
        type: "object",
        properties: {
          severity: {
            type: "string",
            enum: ["critical", "high", "medium", "low", "all"],
            default: "all"
          }
        }
      }
    },
    {
      name: "create_incident",
      description: "Create a new incident in PagerDuty",
      inputSchema: {
        type: "object",
        properties: {
          title: { type: "string" },
          service: { type: "string" },
          severity: {
            type: "string",
            enum: ["critical", "high", "medium", "low"]
          },
          description: { type: "string" }
        },
        required: ["title", "service", "severity"]
      }
    }
  ]
}));

// Handle tool calls
server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;

  switch (name) {
    case "get_error_rate": {
      const errorRate = await fetchErrorRate(
        args.service as string,
        (args.minutes as number) ?? 60
      );
      return {
        content: [
          {
            type: "text",
            text: JSON.stringify({
              service: args.service,
              timeWindow: `${args.minutes ?? 60} minutes`,
              errorRate: `${errorRate.toFixed(2)}%`,
              threshold: "1.0%",
              status: errorRate > 1.0 ? "ALERT" : "OK"
            }, null, 2)
          }
        ]
      };
    }

    case "get_active_incidents": {
      const incidents = await fetchActiveIncidents(
        args.severity as string ?? "all"
      );
      return {
        content: [
          {
            type: "text",
            text: incidents.length === 0
              ? "No active incidents."
              : `Found ${incidents.length} active incidents:\n\n${
                  incidents.map(inc =>
                    `• [${inc.severity.toUpperCase()}] ${inc.title} (${inc.service})\n  Started: ${inc.createdAt}\n  ID: ${inc.id}`
                  ).join("\n\n")
                }`
          }
        ]
      };
    }

    case "create_incident": {
      const incident = await createPagerDutyIncident({
        title: args.title as string,
        service: args.service as string,
        severity: args.severity as string,
        description: args.description as string
      });
      return {
        content: [
          {
            type: "text",
            text: `✅ Incident created: ${incident.id}\nTitle: ${incident.title}\nURL: ${incident.url}`
          }
        ]
      };
    }

    default:
      throw new Error(`Unknown tool: ${name}`);
  }
});

// Start the server
const transport = new StdioServerTransport();
await server.connect(transport);

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

// Connect to an MCP server
const transport = new StdioClientTransport({
  command: "node",
  args: ["./metrics-server/dist/index.js"]
});

const client = new Client(
  { name: "my-app", version: "1.0.0" },
  { capabilities: {} }
);

await client.connect(transport);

// List available tools
const { tools } = await client.listTools();
console.log("Available tools:", tools.map(t => t.name));

// Call a tool
const result = await client.callTool({
  name: "get_error_rate",
  arguments: { service: "api", minutes: 30 }
});

console.log(result.content[0].text);

await client.close();

// Bad: expose all database access
tools: [{ name: "execute_sql", description: "Run any SQL query..." }]

// Good: expose specific, scoped operations  
tools: [
  { name: "get_user", description: "Look up a user by ID (read-only)" },
  { name: "list_orders", description: "Get orders for a customer (last 90 days)" }
]

case "get_user": {
  const userId = args.user_id as string;
  
  // Validate input
  if (!/^\d+$/.test(userId)) {
    throw new Error("Invalid user_id: must be numeric");
  }
  
  // Use parameterized queries — never interpolate user input
  const user = await db.query(
    "SELECT id, name, email FROM users WHERE id = $1",
    [parseInt(userId)]
  );
  
  return { content: [{ type: "text", text: JSON.stringify(user) }] };
}

server.setRequestHandler(CallToolRequestSchema, async (request) => {
  const { name, arguments: args } = request.params;
  
  // Log every tool call
  await auditLog.write({
    timestamp: new Date().toISOString(),
    tool: name,
    arguments: args,
    sessionId: request.params._meta?.sessionId
  });
  
  // ... handle tool
});

import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
import express from "express";

const app = express();
app.use(express.json());

app.post('/mcp', async (req, res) => {
  const transport = new StreamableHTTPServerTransport({
    sessionIdGenerator: () => crypto.randomUUID()
  });
  
  await server.connect(transport);
  await transport.handleRequest(req, res, req.body);
});

app.listen(3000);