mcp-http-webhook 1.0.0

package/examples/github-server.ts

@@ -0,0 +1,223 @@
+import { createMCPServer } from '../src';
+import { InMemoryStore } from '../src/stores';
+import crypto from 'crypto';
+
+/**
+ * GitHub MCP Server Example
+ * Demonstrates webhook-based subscriptions
+ */
+
+const store = new InMemoryStore();
+
+const server = createMCPServer({
+  name: 'github-mcp',
+  version: '1.0.0',
+  publicUrl: process.env.PUBLIC_URL || 'https://mcp.example.com',
+  port: 3000,
+  store,
+
+  tools: [
+    {
+      name: 'create_issue',
+      description: 'Create a GitHub issue',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          owner: { type: 'string', description: 'Repository owner' },
+          repo: { type: 'string', description: 'Repository name' },
+          title: { type: 'string', description: 'Issue title' },
+          body: { type: 'string', description: 'Issue body' },
+        },
+        required: ['owner', 'repo', 'title'],
+      },
+      handler: async (input, context) => {
+        // Simulate GitHub API call
+        console.log('Creating issue:', input);
+
+        return {
+          issue: {
+            number: 42,
+            title: input.title,
+            state: 'open',
+            html_url: `https://github.com/${input.owner}/${input.repo}/issues/42`,
+          },
+        };
+      },
+    },
+  ],
+
+  resources: [
+    {
+      uri: 'github://repo/{owner}/{repo}/issues',
+      name: 'GitHub Repository Issues',
+      description: 'All issues in a GitHub repository',
+      mimeType: 'application/json',
+
+      read: async (uri, context) => {
+        const parts = uri.split('/');
+        const owner = parts[3];
+        const repo = parts[4];
+
+        console.log(`Reading issues for ${owner}/${repo}`);
+
+        // Simulate GitHub API call
+        return {
+          contents: [
+            {
+              number: 1,
+              title: 'Example issue',
+              state: 'open',
+            },
+          ],
+        };
+      },
+
+      list: async (context) => {
+        return [
+          {
+            uri: 'github://repo/octocat/hello-world/issues',
+            name: 'octocat/hello-world Issues',
+            description: 'Issues for hello-world repository',
+          },
+        ];
+      },
+
+      subscription: {
+        onSubscribe: async (uri, subscriptionId, thirdPartyWebhookUrl, context) => {
+          console.log('Subscribing to:', uri);
+          console.log('Third-party webhook URL:', thirdPartyWebhookUrl);
+
+          // In production, this would:
+          // 1. Call GitHub API to create webhook
+          // 2. Store webhook ID
+          // Example:
+          // const webhook = await octokit.repos.createWebhook({
+          //   owner,
+          //   repo,
+          //   config: {
+          //     url: thirdPartyWebhookUrl,
+          //     content_type: 'json',
+          //     secret: process.env.GITHUB_WEBHOOK_SECRET
+          //   },
+          //   events: ['issues']
+          // });
+
+          return {
+            thirdPartyWebhookId: 'webhook_123',
+            metadata: {
+              owner: 'octocat',
+              repo: 'hello-world',
+            },
+          };
+        },
+
+        onUnsubscribe: async (uri, subscriptionId, storedData, context) => {
+          console.log('Unsubscribing from:', uri);
+          console.log('Removing webhook:', storedData.thirdPartyWebhookId);
+
+          // In production, this would:
+          // await octokit.repos.deleteWebhook({
+          //   owner,
+          //   repo,
+          //   hook_id: storedData.thirdPartyWebhookId
+          // });
+        },
+
+        onWebhook: async (subscriptionId, payload, headers) => {
+          console.log('Received GitHub webhook:', subscriptionId);
+
+          // Verify signature
+          const signature = headers['x-hub-signature-256'];
+          if (signature) {
+            // Verification logic here
+          }
+
+          const event = headers['x-github-event'];
+
+          if (event === 'issues') {
+            const { action, issue, repository } = payload;
+
+            if (['opened', 'edited', 'closed'].includes(action)) {
+              return {
+                resourceUri: `github://repo/${repository.owner.login}/${repository.name}/issues`,
+                changeType: action === 'opened' ? 'created' : action === 'closed' ? 'deleted' : 'updated',
+                data: {
+                  issueNumber: issue.number,
+                  title: issue.title,
+                  state: issue.state,
+                  action,
+                },
+              };
+            }
+          }
+
+          return null;
+        },
+      },
+    },
+  ],
+
+  webhooks: {
+    incomingPath: '/webhooks/incoming',
+    incomingSecret: process.env.GITHUB_WEBHOOK_SECRET,
+
+    verifyIncomingSignature: (payload, signature, secret) => {
+      const hmac = crypto.createHmac('sha256', secret);
+      hmac.update(JSON.stringify(payload));
+      const expected = `sha256=${hmac.digest('hex')}`;
+      return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
+    },
+
+    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')}`;
+      },
+    },
+  },
+
+  authenticate: async (req) => {
+    const token = req.headers.authorization?.replace('Bearer ', '');
+    if (!token) {
+      throw new Error('Missing authorization token');
+    }
+
+    // In production, verify JWT token
+    return {
+      userId: 'user-123',
+      githubToken: token,
+    };
+  },
+
+  logLevel: 'debug',
+});
+
+server.start().then(() => {
+  console.log('GitHub MCP Server running!');
+  console.log('');
+  console.log('Subscribe to issues:');
+  console.log('POST http://localhost:3000/mcp/resources/subscribe');
+  console.log('  Body:');
+  console.log('  {');
+  console.log('    "method": "resources/subscribe",');
+  console.log('    "params": {');
+  console.log('      "uri": "github://repo/octocat/hello-world/issues",');
+  console.log('      "callbackUrl": "https://client.example.com/webhook",');
+  console.log('      "callbackSecret": "client-secret"');
+  console.log('    }');
+  console.log('  }');
+  console.log('');
+  console.log('Webhook endpoint:');
+  console.log(`${process.env.PUBLIC_URL}/webhooks/incoming/{subscriptionId}`);
+});
+
+process.on('SIGTERM', async () => {
+  await server.stop();
+  store.destroy();
+  process.exit(0);
+});