import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import { execSync } from "child_process";

const server = new McpServer({
  name: "git-tools",
  version: "1.0.0",
});

// Register a tool
server.tool(
  "git_log",
  "Get recent git commits for a repository",
  {
    repo_path: z.string().describe("Path to the git repository"),
    limit: z.number().default(10).describe("Number of commits to return"),
  },
  async ({ repo_path, limit }) => {
    try {
      const log = execSync(
        `git -C "${repo_path}" log --oneline -${limit}`,
        { encoding: "utf-8" }
      );
      return {
        content: [{ type: "text", text: log }],
      };
    } catch (error) {
      return {
        content: [{ type: "text", text: `Error: ${error.message}` }],
        isError: true,
      };
    }
  }
);

// Register a tool that creates files
server.tool(
  "create_file",
  "Create a new file with given content",
  {
    path: z.string().describe("File path to create"),
    content: z.string().describe("File content"),
  },
  async ({ path, content }) => {
    await fs.writeFile(path, content, "utf-8");
    return {
      content: [{ type: "text", text: `Created ${path}` }],
    };
  }
);

// Start 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: ["/path/to/my-server/index.js"],
});

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

await client.connect(transport);

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

// Call a tool
const result = await client.callTool({
  name: "git_log",
  arguments: {
    repo_path: "/home/user/myproject",
    limit: 5
  }
});

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

// Use with Claude (via Anthropic SDK)
import Anthropic from "@anthropic-ai/sdk";

const anthropic = new Anthropic();

// Convert MCP tools to Anthropic format
const anthropicTools = tools.tools.map(tool => ({
  name: tool.name,
  description: tool.description,
  input_schema: tool.inputSchema
}));

const response = await anthropic.messages.create({
  model: "claude-opus-4-5",
  max_tokens: 4096,
  tools: anthropicTools,
  messages: [{ role: "user", content: "What were the last 5 commits in my project?" }]
});

// Handle tool use
if (response.stop_reason === "tool_use") {
  for (const block of response.content) {
    if (block.type === "tool_use") {
      const toolResult = await client.callTool({
        name: block.name,
        arguments: block.input
      });
      // Feed back to Claude...
    }
  }
}

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

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

const server = new McpServer({
  name: "production-api-tools",
  version: "1.0.0",
});

// Register tools...
server.tool("query_database", "Query the production database", {
  sql: z.string().describe("SQL query (SELECT only)"),
}, async ({ sql }) => {
  // Validate: only SELECT queries
  if (!sql.trim().toUpperCase().startsWith("SELECT")) {
    return { content: [{ type: "text", text: "Only SELECT queries allowed" }], isError: true };
  }
  const results = await db.query(sql);
  return { content: [{ type: "text", text: JSON.stringify(results, null, 2) }] };
});

// Handle MCP over HTTP
app.post("/mcp", async (req, res) => {
  const transport = new StreamableHTTPServerTransport({
    sessionIdGenerator: undefined, // stateless mode
  });
  
  res.on("close", () => transport.close());
  await server.connect(transport);
  await transport.handleRequest(req, res, req.body);
});

app.listen(3000);

// OAuth 2.0 example (MCP 2025-11-05 spec)
const transport = new StreamableHTTPServerTransport({
  sessionIdGenerator: () => crypto.randomUUID(),
  onsessioninitialized: async (sessionId, request) => {
    const authHeader = request.headers.authorization;
    if (!authHeader?.startsWith("Bearer ")) {
      throw new Error("Unauthorized");
    }
    const token = authHeader.slice(7);
    await validateToken(token); // Your auth logic
  }
});