server.js

#!/usr/bin/env node
const { Server } = require('@modelcontextprotocol/sdk/server/index.js');
const { StdioServerTransport } = require('@modelcontextprotocol/sdk/server/stdio.js');
const https = require('https');

const fetch = (url) => {
  return new Promise((resolve, reject) => {
    const urlObj = new URL(url);
    https.get({
      hostname: urlObj.hostname,
      path: urlObj.pathname + urlObj.search,
      headers: { 'User-Agent': 'Node.js' }
    }, (res) => {
      if (res.statusCode === 301 || res.statusCode === 302) {
        return fetch(res.headers.location).then(resolve).catch(reject);
      }
      let data = '';
      res.on('data', chunk => data += chunk);
      res.on('end', () => resolve({ ok: res.statusCode === 200, data }));
    }).on('error', reject);
  });
};

const cleanEmail = (email) => email.replace(/['"]/g, '').trim().toLowerCase();

const extractEmails = (patch) => {
  const matches = patch.match(/^From: .+ <(.+)>/gm) || [];
  return matches.map(m => cleanEmail(m.match(/<(.+)>/)?.[1] || '')).filter(Boolean);
};

const delay = (ms) => new Promise(r => setTimeout(r, ms));

const findEmails = async (username) => {
  const emails = new Set();
  const seen = new Set();

  // Scan events
  for (let p = 1; p <= 10; p++) {
    const res = await fetch(`https://api.github.com/users/${username}/events/public?per_page=100&page=${p}`);
    if (!res.ok) break;
    const events = JSON.parse(res.data);
    if (!events.length) break;

    for (const e of events) {
      if (e.type !== 'PushEvent') continue;
      for (const c of e.payload?.commits || []) {
        if (seen.has(c.sha)) continue;
        seen.add(c.sha);
        try {
          const patch = await fetch(`https://github.com/${e.repo?.name}/commit/${c.sha}.patch`);
          if (patch.ok) extractEmails(patch.data).forEach(x => emails.add(x));
        } catch {}
        await delay(50);
      }
    }
  }

  // Scan repos
  const repos = await fetch(`https://api.github.com/users/${username}/repos?per_page=100`);
  if (repos.ok) {
    for (const repo of JSON.parse(repos.data).filter(r => !r.fork)) {
      for (let p = 1; p <= 5; p++) {
        const res = await fetch(`https://api.github.com/repos/${username}/${repo.name}/commits?per_page=100&page=${p}`);
        if (!res.ok) break;
        const commits = JSON.parse(res.data);
        if (!commits.length) break;

        for (const c of commits) {
          if (seen.has(c.sha)) continue;
          seen.add(c.sha);
          try {
            const patch = await fetch(`https://github.com/${username}/${repo.name}/commit/${c.sha}.patch`);
            if (patch.ok) extractEmails(patch.data).forEach(x => emails.add(x));
          } catch {}
          await delay(50);
        }
      }
    }
  }

  return { emails: [...emails].sort(), commitCount: seen.size };
};

const server = new Server(
  { name: 'github-email-finder', version: '1.0.0' },
  { capabilities: { tools: {} } }
);

server.setRequestHandler('tools/list', async () => ({
  tools: [{
    name: 'find_github_emails',
    description: 'Find email addresses from a GitHub user by scanning their commit patches',
    inputSchema: {
      type: 'object',
      properties: {
        username: {
          type: 'string',
          description: 'GitHub username to scan'
        }
      },
      required: ['username']
    }
  }]
}));

server.setRequestHandler('tools/call', async (request) => {
  if (request.params.name === 'find_github_emails') {
    const { username } = request.params.arguments;
    try {
      const result = await findEmails(username);
      return {
        content: [{
          type: 'text',
          text: result.emails.length
            ? `Found ${result.emails.length} email(s) from ${result.commitCount} commits:\n\n${result.emails.join('\n')}`
            : `No emails found for ${username}`
        }]
      };
    } catch (error) {
      return {
        content: [{ type: 'text', text: `Error: ${error.message}` }],
        isError: true
      };
    }
  }
});

const main = async () => {
  const transport = new StdioServerTransport();
  await server.connect(transport);
};

main().catch(console.error);