@launchframe/mcp 1.0.0

package/dist/tools/queues.js

@@ -0,0 +1,81 @@
+import { z } from 'zod';
+import { loadContent } from '../lib/content.js';
+const QUEUE_NAMES = ['emails', 'api', 'webhooks'];
+export function registerQueueTools(server) {
+    server.tool('queue_get_names', 'List all available Bull queues in LaunchFrame with their purpose and usage rules.', {}, async () => ({
+        content: [{ type: 'text', text: loadContent('queues/names.md') }],
+    }));
+    server.tool('queue_scaffold_producer', 'Get the code to inject and use a Bull queue as a producer in a NestJS service.', {
+        queueName: z
+            .enum(QUEUE_NAMES)
+            .describe('The queue to produce jobs for'),
+    }, async ({ queueName }) => {
+        const snippet = `import { InjectQueue } from '@nestjs/bull';
+import { Injectable } from '@nestjs/common';
+import { Queue } from 'bull';
+import { BullQueueModule } from '../bull/bull.module';
+
+// In your module imports array:
+// BullQueueModule,
+// BullModule.registerQueue({ name: '${queueName}' }),  // from '@nestjs/bull'
+
+@Injectable()
+export class YourService {
+  constructor(
+    @InjectQueue('${queueName}') private readonly ${camelCase(queueName)}Queue: Queue,
+  ) {}
+
+  async enqueueJob(data: Record<string, unknown>): Promise<void> {
+    await this.${camelCase(queueName)}Queue.add('job-name', data, {
+      attempts: 3,
+      backoff: { type: 'exponential', delay: 2000 },
+    });
+  }
+}`;
+        return {
+            content: [{ type: 'text', text: snippet }],
+        };
+    });
+    server.tool('queue_scaffold_processor', 'Get a Bull processor class scaffold for a given queue and job name.', {
+        queueName: z
+            .enum(QUEUE_NAMES)
+            .describe('The queue this processor listens to'),
+        jobName: z
+            .string()
+            .describe('The job name string passed to queue.add() (e.g. "send-email")'),
+    }, async ({ queueName, jobName }) => {
+        const className = toPascalCase(queueName) + 'Processor';
+        const snippet = `import { Processor, Process } from '@nestjs/bull';
+import { Logger } from '@nestjs/common';
+import { Job } from 'bull';
+
+// Add this class to the providers array of your module.
+// Your module must also import BullQueueModule and BullModule.registerQueue({ name: '${queueName}' }).
+
+@Processor('${queueName}')
+export class ${className} {
+  private readonly logger = new Logger(${className}.name);
+
+  @Process('${jobName}')
+  async handle(job: Job<Record<string, unknown>>): Promise<void> {
+    this.logger.log(\`Processing job \${job.id}\`);
+    try {
+      // TODO: implement job logic using job.data
+    } catch (error) {
+      this.logger.error(\`Job \${job.id} failed\`, error);
+      throw error; // Required — Bull needs the error to trigger retries
+    }
+  }
+}`;
+        return {
+            content: [{ type: 'text', text: snippet }],
+        };
+    });
+}
+function camelCase(str) {
+    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toPascalCase(str) {
+    const camel = camelCase(str);
+    return camel.charAt(0).toUpperCase() + camel.slice(1);
+}

package/dist/tools/variants.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerVariantTools(server: McpServer): void;

package/dist/tools/variants.js

@@ -0,0 +1,6 @@
+import { loadContent } from '../lib/content.js';
+export function registerVariantTools(server) {
+    server.tool('variant_get_overview', 'Get an overview of LaunchFrame project variants: Base (B2B single-tenant), Multi-tenant, and B2B2C. Covers differences, section marker syntax for CLI code generation, and coding guidelines per variant.', {}, async () => ({
+        content: [{ type: 'text', text: loadContent('variants/overview.md') }],
+    }));
+}

package/dist/tools/webhooks.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerWebhookTools(server: McpServer): void;

package/dist/tools/webhooks.js

@@ -0,0 +1,121 @@
+import { z } from 'zod';
+import { loadContent } from '../lib/content.js';
+const PROVIDERS = ['POLAR', 'PAYPAL', 'STRIPE'];
+export function registerWebhookTools(server) {
+    server.tool('webhook_get_architecture', 'Get an overview of the LaunchFrame webhook architecture: receipt/processing separation, WebhookLog entity, Bull queue, and retry cron.', {}, async () => ({
+        content: [{ type: 'text', text: loadContent('webhooks/architecture.md') }],
+    }));
+    server.tool('webhook_scaffold_handler', 'Get a scaffold for a new webhook handler: controller receipt + Bull processor for a given provider and event type.', {
+        provider: z
+            .enum(PROVIDERS)
+            .describe('The webhook provider (POLAR, PAYPAL, or STRIPE)'),
+        eventType: z
+            .string()
+            .describe('The event type string from the provider (e.g. "subscription.created", "order.paid")'),
+    }, async ({ provider, eventType }) => {
+        const providerLower = provider.toLowerCase();
+        const providerPascal = provider.charAt(0) + provider.slice(1).toLowerCase();
+        const guardName = `${providerPascal}WebhookGuard`;
+        const processorClass = `${providerPascal}WebhooksProcessor`;
+        const jobName = eventType;
+        const snippet = `// ─── Controller (receipt — already exists for POLAR, add for other providers) ───
+// File: src/modules/webhooks/controllers/${providerLower}-webhooks.controller.ts
+
+import { Controller, Post, Req, Res, UseGuards } from '@nestjs/common';
+import { InjectQueue } from '@nestjs/bull';
+import { Queue } from 'bull';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { Public } from '../../auth/auth.decorator';
+import { ${guardName} } from '../guards/${providerLower}-webhook.guard';
+import { WebhookLog, WebhookProvider } from '../entities/webhook-log.entity';
+
+@Controller('webhooks')
+export class ${providerPascal}WebhooksController {
+  constructor(
+    @InjectQueue('webhooks') private readonly webhooksQueue: Queue,
+    @InjectRepository(WebhookLog) private readonly webhookLogRepo: Repository<WebhookLog>,
+  ) {}
+
+  @Post('${providerLower}')
+  @Public()
+  @UseGuards(${guardName})
+  async handle(@Req() req: any, @Res() res: any): Promise<void> {
+    const log = this.webhookLogRepo.create({
+      provider: WebhookProvider.${provider},
+      eventType: req.body?.type ?? 'unknown',
+      webhookId: req.body?.id ?? null,
+      payload: req.body,
+      headers: req.headers,
+    });
+    const saved = await this.webhookLogRepo.save(log);
+    await this.webhooksQueue.add('process-webhook', { webhookLogId: saved.id }, {
+      attempts: 3,
+      backoff: { type: 'exponential', delay: 2000 },
+    });
+    res.status(200).send();
+  }
+}
+
+// ─── Processor (processing layer) ───
+// File: src/modules/webhooks/processors/${providerLower}-webhooks.processor.ts
+
+import { Processor, Process } from '@nestjs/bull';
+import { Logger } from '@nestjs/common';
+import { Job } from 'bull';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import { WebhookLog } from '../entities/webhook-log.entity';
+
+@Processor('webhooks')
+export class ${processorClass} {
+  private readonly logger = new Logger(${processorClass}.name);
+
+  constructor(
+    @InjectRepository(WebhookLog) private readonly webhookLogRepo: Repository<WebhookLog>,
+  ) {}
+
+  @Process('process-webhook')
+  async handle(job: Job<{ webhookLogId: number }>): Promise<void> {
+    const log = await this.webhookLogRepo.findOneOrFail({ where: { id: job.data.webhookLogId } });
+    this.logger.log(\`Processing \${log.provider} webhook \${log.eventType} (log id: \${log.id})\`);
+    try {
+      switch (log.eventType) {
+        case '${jobName}':
+          await this.handle${toPascalCase(eventType)}(log.payload);
+          break;
+        default:
+          this.logger.warn(\`Unhandled event type: \${log.eventType}\`);
+      }
+      log.processed = true;
+      await this.webhookLogRepo.save(log);
+    } catch (error) {
+      log.retryCount += 1;
+      log.processingError = (error as Error).message;
+      await this.webhookLogRepo.save(log);
+      this.logger.error(\`Webhook \${log.id} failed (attempt \${log.retryCount})\`, error);
+      throw error; // Required — Bull needs the error to trigger retries
+    }
+  }
+
+  private async handle${toPascalCase(eventType)}(payload: Record<string, unknown>): Promise<void> {
+    // TODO: implement handler for '${eventType}'
+  }
+}
+
+// ─── Module registration ───
+// Add to your webhooks module:
+//   imports: [BullQueueModule, BullModule.registerQueue({ name: 'webhooks' }), TypeOrmModule.forFeature([WebhookLog])]
+//   controllers: [${providerPascal}WebhooksController]
+//   providers: [${processorClass}]
+`;
+        return {
+            content: [{ type: 'text', text: snippet }],
+        };
+    });
+}
+function toPascalCase(str) {
+    return str
+        .replace(/[^a-zA-Z0-9]+(.)/g, (_, c) => c.toUpperCase())
+        .replace(/^./, c => c.toUpperCase());
+}

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@launchframe/mcp",
+  "version": "1.0.0",
+  "description": "LaunchFrame MCP Server — knowledge tools for AI agents building LaunchFrame projects",
+  "bin": { "launchframe-mcp": "dist/index.js" },
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsc && cp -r src/content dist/content",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.4.0",
+    "@types/node": "^22.0.0"
+  },
+  "publishConfig": { "access": "public" },
+  "license": "MIT",
+  "type": "module"
+}