mcp-http-webhook 1.0.0

package/examples/github-server-live.ts

@@ -0,0 +1,690 @@
+import { createMCPServer } from '../src';
+import { InMemoryStore } from '../src/stores';
+import { Octokit } from '@octokit/rest';
+import ngrok from '@ngrok/ngrok';
+import crypto from 'crypto';
+
+/**
+ * GitHub MCP Server - LIVE Multi-User Example
+ *
+ * This example supports multiple users with different GitHub credentials.
+ * Each user is authenticated via a token, and their credentials are fetched
+ * from a credentials store (simulated here, but would be a service in production).
+ *
+ * Prerequisites:
+ * 1. ngrok auth token for public URL tunneling
+ * 2. User tokens configured in CREDENTIALS_STORE below
+ */
+
+/**
+ * User credentials interface
+ */
+interface UserCredentials {
+  githubToken: string;
+  githubOwner: string;
+  githubRepo: string;
+  githubLogin: string;
+}
+
+/**
+ * Simulated credentials store
+ * In production, this would be replaced by a service call
+ * that fetches credentials based on token and MCP server name
+ */
+const CREDENTIALS_STORE = new Map<string, UserCredentials>([
+  // Example user 1
+  [
+    'user-token-123',
+    {
+      githubToken: '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',
+      githubOwner: 'surajbhan',
+      githubRepo: 'test',
+      githubLogin: 'surajbhan',
+    },
+  ],
+  // Example user 2
+  [
+    'user-token-456',
+    {
+      githubToken: 'ghp_example_token_2',
+      githubOwner: 'anotheruser',
+      githubRepo: 'demo',
+      githubLogin: 'anotheruser',
+    },
+  ],
+  // Add more users as needed
+]);
+
+/**
+ * Fetch user credentials from the store (simulates a service call)
+ * In production, this would make an HTTP call to a credentials service
+ */
+async function fetchCredentials(
+  token: string,
+  mcpServerName: string
+): Promise<UserCredentials | null> {
+  // Simulate async service call
+  await new Promise((resolve) => setTimeout(resolve, 10));
+
+  // In production, this would be:
+  // const response = await fetch(`https://credentials-service.com/api/credentials`, {
+  //   method: 'POST',
+  //   headers: { 'Authorization': `Bearer ${token}` },
+  //   body: JSON.stringify({ mcpServerName })
+  // });
+  // return await response.json();
+
+  return CREDENTIALS_STORE.get(token) || null;
+}
+
+/**
+ * Create an Octokit instance for a specific user
+ */
+function createOctokit(credentials: UserCredentials): Octokit {
+  return new Octokit({ auth: credentials.githubToken });
+}
+
+async function main() {
+  console.log('╔═══════════════════════════════════════════════════════════╗');
+  console.log('║  GitHub MCP Server - Multi-User Live Integration        ║');
+  console.log('╚═══════════════════════════════════════════════════════════╝');
+  console.log('');
+
+  // Configuration
+  const ngrokAuthToken =
+    process.env.NGROK_AUTH_TOKEN || '343iE4JabU5sRNM235xJ0N1iFQK_4GHuxi3va6GFVDn5pW92W';
+  const webhookSecret = process.env.WEBHOOK_SECRET || crypto.randomBytes(32).toString('hex');
+  const mcpServerName = 'github-mcp-live';
+
+  console.log('🚀 Starting multi-user MCP server...');
+  console.log('');
+
+  // Start ngrok tunnel
+  console.log('🌐 Starting ngrok tunnel...');
+  let ngrokUrl: string;
+
+  try {
+    ngrokUrl = await ngrok
+      .connect({
+        addr: 3000,
+        authtoken: ngrokAuthToken || undefined,
+      })
+      .then((x) => {
+        const url = x.url();
+        console.log(`✅ ngrok tunnel established: ${url}`);
+        if (!url) {
+          console.log('❌ ngrok did not return a URL!');
+          process.exit(1);
+        }
+        return url;
+      })
+      .catch((err) => {
+        console.log('❌ Failed to start ngrok tunnel:', err.message);
+        console.log('   Set NGROK_AUTH_TOKEN environment variable');
+        process.exit(1);
+      });
+    console.log(`✅ Public URL: ${ngrokUrl}`);
+    console.log('');
+  } catch (error: any) {
+    console.log('❌ Failed to start ngrok tunnel:', error.message);
+    console.log('');
+    console.log('   Get your ngrok auth token:');
+    console.log('   https://dashboard.ngrok.com/get-started/your-authtoken');
+    console.log('   Then set: export NGROK_AUTH_TOKEN="your_token"');
+    process.exit(1);
+  }
+
+  // Store for webhook IDs (keyed by subscriptionId)
+  const webhookStore = new Map<
+    string,
+    { hookId: number; userId: string; owner: string; repo: string }
+  >();
+  const store = new InMemoryStore();
+
+  const server = createMCPServer({
+    name: 'github-mcp-live',
+    version: '1.0.0',
+    publicUrl: ngrokUrl,
+    port: 3000,
+    store,
+
+    tools: [
+      {
+        name: 'create_issue',
+        description: 'Create a GitHub issue',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            title: { type: 'string', description: 'Issue title' },
+            body: { type: 'string', description: 'Issue body' },
+            labels: {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'Issue labels',
+            },
+          },
+          required: ['title'],
+        },
+        handler: async (input, context) => {
+          console.log('📝 Creating GitHub issue:', input.title);
+
+          // Get user credentials from context
+          const credentials = context.credentials as UserCredentials;
+          if (!credentials) {
+            return {
+              success: false,
+              error: 'User not authenticated or credentials not found',
+            };
+          }
+
+          const octokit = createOctokit(credentials);
+
+          try {
+            const { data: issue } = await octokit.issues.create({
+              owner: credentials.githubOwner,
+              repo: credentials.githubRepo,
+              title: input.title,
+              body: input.body,
+              labels: input.labels,
+            });
+
+            console.log(`✅ Issue created: #${issue.number} (user: ${credentials.githubLogin})`);
+
+            return {
+              success: true,
+              issue: {
+                number: issue.number,
+                title: issue.title,
+                state: issue.state,
+                html_url: issue.html_url,
+                created_at: issue.created_at,
+              },
+            };
+          } catch (error: any) {
+            console.log('❌ Failed to create issue:', error.message);
+            return {
+              success: false,
+              error: error.message,
+            };
+          }
+        },
+      },
+
+      {
+        name: 'list_issues',
+        description: 'List issues from the repository',
+        inputSchema: {
+          type: 'object',
+          properties: {
+            state: {
+              type: 'string',
+              description: 'Filter by state: open, closed, all',
+              enum: ['open', 'closed', 'all'],
+            },
+            limit: {
+              type: 'number',
+              description: 'Number of issues to return',
+            },
+          },
+        },
+        handler: async (input, context) => {
+          console.log('📋 Listing GitHub issues...');
+
+          // Get user credentials from context
+          const credentials = context.credentials as UserCredentials;
+          if (!credentials) {
+            return {
+              success: false,
+              error: 'User not authenticated or credentials not found',
+            };
+          }
+
+          const octokit = createOctokit(credentials);
+
+          try {
+            const { data: issues } = await octokit.issues.listForRepo({
+              owner: credentials.githubOwner,
+              repo: credentials.githubRepo,
+              state: (input.state as any) || 'open',
+              per_page: input.limit || 10,
+            });
+
+            console.log(`✅ Listed ${issues.length} issues (user: ${credentials.githubLogin})`);
+
+            return {
+              success: true,
+              count: issues.length,
+              issues: issues.map((issue: any) => ({
+                number: issue.number,
+                title: issue.title,
+                state: issue.state,
+                html_url: issue.html_url,
+                created_at: issue.created_at,
+                labels: issue.labels.map((l: any) => l.name),
+              })),
+            };
+          } catch (error: any) {
+            console.log('❌ Failed to list issues:', error.message);
+            return {
+              success: false,
+              error: error.message,
+            };
+          }
+        },
+      },
+    ],
+
+    resources: [
+      {
+        uri: 'github://repo/{owner}/{repo}/issues',
+        name: 'GitHub Repository Issues',
+        description: 'Live issues from GitHub repository',
+        mimeType: 'application/json',
+
+        read: async (uri, context) => {
+          console.log('📖 Reading repository issues...');
+
+          // Get user credentials from context
+          const credentials = context.credentials as UserCredentials;
+          if (!credentials) {
+            throw new Error('User not authenticated or credentials not found');
+          }
+
+          const octokit = createOctokit(credentials);
+
+          try {
+            const { data: issues } = await octokit.issues.listForRepo({
+              owner: credentials.githubOwner,
+              repo: credentials.githubRepo,
+              state: 'open',
+              per_page: 100,
+            });
+
+            console.log(`✅ Read ${issues.length} issues (user: ${credentials.githubLogin})`);
+
+            return {
+              contents: issues.map((issue: any) => ({
+                number: issue.number,
+                title: issue.title,
+                state: issue.state,
+                html_url: issue.html_url,
+                created_at: issue.created_at,
+                updated_at: issue.updated_at,
+                labels: issue.labels.map((l: any) => l.name),
+              })),
+            };
+          } catch (error: any) {
+            console.log('❌ Failed to read issues:', error.message);
+            throw error;
+          }
+        },
+
+        list: async (context) => {
+          // Get user credentials from context
+          const credentials = context.credentials as UserCredentials;
+          if (!credentials) {
+            return [];
+          }
+
+          return [
+            {
+              uri: `github://repo/${credentials.githubOwner}/${credentials.githubRepo}/issues`,
+              name: `${credentials.githubOwner}/${credentials.githubRepo} Issues`,
+              description: `Live issues from ${credentials.githubOwner}/${credentials.githubRepo} repository`,
+            },
+          ];
+        },
+
+        subscription: {
+          onSubscribe: async (uri, subscriptionId, thirdPartyWebhookUrl, context) => {
+            console.log('');
+            console.log('🔔 Setting up GitHub webhook...');
+            console.log(`   Resource: ${uri}`);
+            console.log(`   Subscription ID: ${subscriptionId}`);
+            console.log(`   Webhook URL: ${thirdPartyWebhookUrl}`);
+
+            // Get user credentials from context
+            const credentials = context.credentials as UserCredentials;
+            if (!credentials) {
+              throw new Error('User not authenticated or credentials not found');
+            }
+
+            const octokit = createOctokit(credentials);
+
+            try {
+              // Create webhook on GitHub
+              const { data: hook } = await octokit.repos.createWebhook({
+                owner: credentials.githubOwner,
+                repo: credentials.githubRepo,
+                config: {
+                  url: thirdPartyWebhookUrl,
+                  content_type: 'json',
+                  secret: webhookSecret,
+                  insecure_ssl: '0',
+                },
+                events: ['issues', 'issue_comment'],
+                active: true,
+              });
+
+              webhookStore.set(subscriptionId, {
+                hookId: hook.id,
+                userId: context.userId,
+                owner: credentials.githubOwner,
+                repo: credentials.githubRepo,
+              });
+
+              console.log(
+                `✅ GitHub webhook created: ID ${hook.id} (user: ${credentials.githubLogin})`
+              );
+              console.log('');
+
+              return {
+                thirdPartyWebhookId: hook.id.toString(),
+                metadata: {
+                  owner: credentials.githubOwner,
+                  repo: credentials.githubRepo,
+                  events: ['issues', 'issue_comment'],
+                  webhook_url: hook.config.url,
+                  user: credentials.githubLogin,
+                },
+              };
+            } catch (error: any) {
+              console.log('❌ Failed to create webhook:', error.message);
+              throw error;
+            }
+          },
+
+          onUnsubscribe: async (uri, subscriptionId, storedData, context) => {
+            console.log('');
+            console.log('🗑️  Removing GitHub webhook...');
+            console.log(`   Subscription ID: ${subscriptionId}`);
+
+            const webhookInfo = webhookStore.get(subscriptionId);
+            if (!webhookInfo) {
+              console.log('⚠️  Webhook ID not found in store');
+              return;
+            }
+
+            // Get user credentials from context (or use stored info)
+            const credentials = context.credentials as UserCredentials;
+            if (!credentials) {
+              console.log('⚠️  User credentials not available for cleanup');
+              return;
+            }
+
+            const octokit = createOctokit(credentials);
+
+            try {
+              await octokit.repos.deleteWebhook({
+                owner: webhookInfo.owner,
+                repo: webhookInfo.repo,
+                hook_id: webhookInfo.hookId,
+              });
+
+              webhookStore.delete(subscriptionId);
+              console.log(`✅ GitHub webhook deleted: ID ${webhookInfo.hookId}`);
+              console.log('');
+            } catch (error: any) {
+              console.log('❌ Failed to delete webhook:', error.message);
+            }
+          },
+
+          onWebhook: async (subscriptionId, payload, headers) => {
+            const event = headers['x-github-event'];
+
+            console.log('');
+            console.log('📬 Received GitHub webhook');
+            console.log(`   Event: ${event}`);
+            console.log(`   Subscription: ${subscriptionId}`);
+
+            if (event === 'issues') {
+              const { action, issue, repository } = payload;
+              console.log(`   Action: ${action}`);
+              console.log(`   Issue: #${issue.number} - ${issue.title}`);
+
+              if (['opened', 'edited', 'closed', 'reopened'].includes(action)) {
+                return {
+                  resourceUri: `github://repo/${repository.owner.login}/${repository.name}/issues/${issue.number}`,
+                  changeType:
+                    action === 'opened' ? 'created' : action === 'closed' ? 'deleted' : 'updated',
+                  data: {
+                    issueNumber: issue.number,
+                    title: issue.title,
+                    state: issue.state,
+                    action,
+                    html_url: issue.html_url,
+                  },
+                };
+              }
+            }
+
+            if (event === 'issue_comment') {
+              const { action, issue, comment, repository } = payload;
+              console.log(`   Comment ${action} on issue #${issue.number}`);
+
+              return {
+                resourceUri: `github://repo/${repository.owner.login}/${repository.name}/issues`,
+                changeType: 'updated',
+                data: {
+                  issueNumber: issue.number,
+                  commentAction: action,
+                  comment: {
+                    id: comment.id,
+                    body: comment.body,
+                    user: comment.user.login,
+                  },
+                },
+              };
+            }
+
+            console.log('   ℹ️  Event not mapped to resource change');
+            return null;
+          },
+        },
+      },
+      {
+        uri: 'github://repo/{owner}/{repo}/issues/{issue_number}',
+        name: 'GitHub Repository Issue Detail',
+        description: 'Live issue details from GitHub repository',
+        mimeType: 'application/json',
+        read: async (uri, context) => {
+          console.log('📖 Reading repository issue detail...');
+          // Get user credentials from context
+          const credentials = context.credentials as UserCredentials;
+          if (!credentials) {
+            throw new Error('User not authenticated or credentials not found');
+          }
+
+          const parts = uri.split('/');
+          const owner = parts[3];
+          const repo = parts[4];
+          const issue_number = parseInt(parts[6], 10);
+
+          const octokit = createOctokit(credentials);
+
+          try {
+            const { data: issue } = await octokit.issues.get({
+              owner,
+              repo,
+              issue_number,
+            });
+            return {
+              contents: [
+                {
+                  number: issue.number,
+                  title: issue.title,
+                  state: issue.state,
+                  html_url: issue.html_url,
+                  created_at: issue.created_at,
+                  updated_at: issue.updated_at,
+                  labels: issue.labels.map((l: any) => l.name),
+                },
+              ],
+            };
+          } catch (error: any) {
+            console.log('❌ Failed to read issue detail:', error.message);
+            throw error;
+          }
+        },
+        list: async (context) => {
+          // Get user credentials from context
+          const credentials = context.credentials as UserCredentials;
+          if (!credentials) {
+            return [];
+          }
+
+          return [
+            {
+              uri: `github://repo/${credentials.githubOwner}/${credentials.githubRepo}/issues/{issue_number}`,
+              name: `${credentials.githubOwner}/${credentials.githubRepo} Issues`,
+              description: `Live issues from ${credentials.githubOwner}/${credentials.githubRepo} repository`,
+            },
+          ];
+        }
+      },
+    ],
+
+    webhooks: {
+      incomingPath: '/webhooks/incoming',
+      incomingSecret: webhookSecret,
+
+      verifyIncomingSignature: (payload, signature, secret) => {
+        if (!signature) return false;
+
+        const hmac = crypto.createHmac('sha256', secret);
+        hmac.update(JSON.stringify(payload));
+        const expected = `sha256=${hmac.digest('hex')}`;
+
+        try {
+          return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+        } catch {
+          return false;
+        }
+      },
+
+      outgoing: {
+        timeout: 5000,
+        retries: 3,
+        retryDelay: 1000,
+
+        signPayload: (payload, secret) => {
+          const hmac = crypto.createHmac('sha256', secret);
+          hmac.update(JSON.stringify(payload));
+          return `sha256=${hmac.digest('hex')}`;
+        },
+      },
+    },
+
+    // Authentication: Extract token and fetch credentials
+    authenticate: async (req) => {
+      // Extract token from Authorization header
+      const authHeader = req.headers.authorization;
+      console.log('Authorization Header:', authHeader);
+      if (!authHeader || !authHeader.startsWith('Bearer ')) {
+        throw new Error('Missing or invalid Authorization header');
+      }
+
+      const token = authHeader.substring(7); // Remove 'Bearer ' prefix
+
+      // Fetch credentials from store (or service in production)
+      const credentials = await fetchCredentials(token, mcpServerName);
+      if (!credentials) {
+        throw new Error('Invalid token or credentials not found');
+      }
+
+      console.log(`✅ User authenticated: ${credentials.githubLogin}`);
+
+      return {
+        userId: credentials.githubLogin,
+        credentials, // Store credentials in context for later use
+      };
+    },
+
+    logLevel: 'info',
+  });
+
+  await server.start();
+
+  console.log('');
+  console.log('╔═══════════════════════════════════════════════════════════╗');
+  console.log('║  🎉 GitHub MCP Server is LIVE! (Multi-User)             ║');
+  console.log('╚═══════════════════════════════════════════════════════════╝');
+  console.log('');
+  console.log('📍 MCP Endpoint:');
+  console.log(`   ${ngrokUrl}/mcp`);
+  console.log('');
+  console.log('� Authentication:');
+  console.log('   Add header: Authorization: Bearer <user-token>');
+  console.log('   Example tokens: user-token-123, user-token-456');
+  console.log('');
+  console.log('�🔍 Test with MCP Inspector:');
+  console.log(`   npx @modelcontextprotocol/inspector ${ngrokUrl}/mcp`);
+  console.log('');
+  console.log('📋 Available Tools:');
+  console.log('   - create_issue: Create a new GitHub issue');
+  console.log('   - list_issues: List repository issues');
+  console.log('');
+  console.log('📚 Available Resources (dynamic per user):');
+  console.log('   - github://repo/{owner}/{repo}/issues');
+  console.log('');
+  console.log('🔔 Webhook Subscription:');
+  console.log('   1. Authenticate with user token');
+  console.log('   2. Use MCP Inspector or POST to /mcp with resources/subscribe');
+  console.log('   3. Provide your callback URL in _meta.webhookUrl');
+  console.log("   4. GitHub webhook will be created for user's repo");
+  console.log('   5. Create/edit/close issues to see live updates!');
+  console.log('');
+  console.log('📝 Example: Create a test issue');
+  console.log('   curl -X POST http://localhost:3000/mcp \\');
+  console.log('     -H "Content-Type: application/json" \\');
+  console.log('     -H "Authorization: Bearer user-token-123" \\');
+  console.log('     -d \'{"jsonrpc":"2.0","id":1,"method":"tools/call",');
+  console.log('          "params":{"name":"create_issue",');
+  console.log('                    "arguments":{"title":"Test Issue"}}}\'');
+  console.log('');
+  console.log('⚠️  Press Ctrl+C to stop and cleanup webhooks');
+  console.log('');
+
+  // Graceful shutdown
+  const cleanup = async () => {
+    console.log('');
+    console.log('🧹 Shutting down...');
+
+    // Delete all webhooks
+    for (const [subscriptionId, webhookInfo] of webhookStore.entries()) {
+      try {
+        // Try to get credentials for cleanup
+        const credentials = CREDENTIALS_STORE.get(`user-token-${webhookInfo.userId}`);
+        if (credentials) {
+          const octokit = createOctokit(credentials);
+          await octokit.repos.deleteWebhook({
+            owner: webhookInfo.owner,
+            repo: webhookInfo.repo,
+            hook_id: webhookInfo.hookId,
+          });
+          console.log(`✅ Deleted webhook: ${webhookInfo.hookId} (user: ${webhookInfo.userId})`);
+        } else {
+          console.log(`⚠️  Cannot delete webhook ${webhookInfo.hookId}: credentials not found`);
+        }
+      } catch (error: any) {
+        console.log(`⚠️  Failed to delete webhook ${webhookInfo.hookId}: ${error.message}`);
+      }
+    }
+
+    await server.stop();
+    await ngrok.disconnect();
+    await ngrok.kill();
+    store.destroy();
+
+    console.log('👋 Goodbye!');
+    process.exit(0);
+  };
+
+  process.on('SIGTERM', cleanup);
+  process.on('SIGINT', cleanup);
+}
+
+main().catch((error) => {
+  console.error('💥 Fatal error:', error);
+  process.exit(1);
+});