@launchframe/mcp 1.0.0

package/dist/server.js

@@ -0,0 +1,27 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { registerAuthTools } from './tools/auth.js';
+import { registerFeatureGatesTools } from './tools/feature-gates.js';
+import { registerCreditsTools } from './tools/credits.js';
+import { registerQueueTools } from './tools/queues.js';
+import { registerWebhookTools } from './tools/webhooks.js';
+import { registerCronTools } from './tools/crons.js';
+import { registerModuleTools } from './tools/modules.js';
+import { registerEntityTools } from './tools/entities.js';
+import { registerEnvTools } from './tools/env.js';
+import { registerVariantTools } from './tools/variants.js';
+// Phase 2: import { registerCliTools } from './tools/cli.js';
+export function createServer() {
+    const server = new McpServer({ name: 'launchframe-mcp', version: '1.0.0' });
+    registerAuthTools(server);
+    registerFeatureGatesTools(server);
+    registerCreditsTools(server);
+    registerQueueTools(server);
+    registerWebhookTools(server);
+    registerCronTools(server);
+    registerModuleTools(server);
+    registerEntityTools(server);
+    registerEnvTools(server);
+    registerVariantTools(server);
+    // Phase 2: registerCliTools(server);
+    return server;
+}

package/dist/tools/auth.d.ts

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

package/dist/tools/auth.js

@@ -0,0 +1,108 @@
+import { z } from 'zod';
+import { loadContent } from '../lib/content.js';
+export function registerAuthTools(server) {
+    server.tool('auth_get_overview', 'Get full auth system overview: guard hierarchy, session flow, Better Auth setup, roles, and decorator system.', {}, async () => ({
+        content: [{ type: 'text', text: loadContent('auth/overview.md') }],
+    }));
+    server.tool('auth_get_decorator_usage', 'Get the exact decorator and import for a specific auth need.', {
+        need: z.enum([
+            'public',
+            'optional',
+            'customer_portal',
+            'admin_only',
+            'current_user',
+            'full_session',
+        ]).describe('The auth need for the route'),
+    }, async ({ need }) => {
+        const map = {
+            public: `// No authentication required
+import { AllowAnonymous } from '../auth/auth.decorator';
+
+@AllowAnonymous()
+@Get('route')
+handler() { ... }`,
+            optional: `// Auth is checked but not required — user may be undefined
+import { OptionalAuth, UserSession } from '../auth/auth.decorator';
+import { User } from '../users/user.entity';
+
+@OptionalAuth()
+@Get('route')
+handler(@UserSession() user?: User) { ... }`,
+            customer_portal: `// Accessible by regular_user role (B2B2C variant only)
+// Without this decorator, regular_user gets 401
+import { CustomerPortal, UserSession } from '../auth/auth.decorator';
+import { User } from '../users/user.entity';
+
+@CustomerPortal()
+@Get('route')
+handler(@UserSession() user: User) { ... }`,
+            admin_only: `// Admin-only access: superadmin role only.
+// Admin routes are separated by the /admin/* prefix with AdminGuard (applied globally via RouterModule).
+// For a superadmin check on a non-admin route, guard manually in the handler:
+import { UserSession } from '../auth/auth.decorator';
+import { User } from '../users/user.entity';
+import { ForbiddenException } from '@nestjs/common';
+
+@Get('route')
+handler(@UserSession() user: User) {
+  if (user.role !== 'superadmin') throw new ForbiddenException();
+  ...
+}`,
+            current_user: `// Inject the current authenticated user
+import { UserSession } from '../auth/auth.decorator';
+import { User } from '../users/user.entity';
+
+@Get('route')
+handler(@UserSession() user: User) {
+  // user.id, user.email, user.role, etc.
+}`,
+            full_session: `// Inject the full Better Auth session (user + session metadata)
+import { Session } from '../auth/auth.decorator';
+
+@Get('route')
+handler(@Session() session: { user: any; session: any }) {
+  const { user, session: sessionData } = session;
+}`,
+        };
+        return {
+            content: [{ type: 'text', text: map[need] ?? `Unknown need: ${need}` }],
+        };
+    });
+    server.tool('auth_get_guard_usage', 'Get the guard class, import path, and decorator combo for a specific guard type.', {
+        guard: z.enum(['admin', 'business_user', 'credits']).describe('The guard to look up'),
+    }, async ({ guard }) => {
+        const map = {
+            admin: `// AdminGuard — applied globally to all /admin/* routes via RouterModule.
+// Source: src/modules/admin/guards/admin.guard.ts
+// You do NOT need to add @UseGuards(AdminGuard) manually on admin controllers.
+// The admin router config registers it globally for the admin route prefix.
+// Checking inside: verifies user.role === 'superadmin'`,
+            business_user: `// BetterAuthGuard — the global default guard (all routes).
+// Source: src/modules/auth/better-auth.guard.ts
+// Applied globally in app.module.ts as APP_GUARD.
+// Allows: business_user, superadmin
+// Blocks: unauthenticated, regular_user (unless @CustomerPortal())
+// You never need to add this manually.`,
+            credits: `// CreditsGuard — deducts credits per request based on @DeductCredits(n).
+// Source: src/modules/credits/guards/credits.guard.ts
+// MUST be combined with @DeductCredits(n) decorator.
+import { UseGuards } from '@nestjs/common';
+import { CreditsGuard } from '../credits/guards/credits.guard';
+import { DeductCredits } from '../credits/decorators/deduct-credits.decorator';
+
+@DeductCredits(10)
+@UseGuards(CreditsGuard)
+@Post('ai-operation')
+handler() { ... }
+
+// Strategy behaviour (read from AdminSettings, cached 24h in Redis):
+// - free:         bypass (no deduction)
+// - subscription: bypass (use feature gates instead)
+// - credits:      deduct from balance
+// - hybrid:       deduct from monthly allowance first, then Polar overage`,
+        };
+        return {
+            content: [{ type: 'text', text: map[guard] ?? `Unknown guard: ${guard}` }],
+        };
+    });
+}

package/dist/tools/credits.d.ts

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

package/dist/tools/credits.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+import { loadContent } from '../lib/content.js';
+export function registerCreditsTools(server) {
+    server.tool('credits_get_deduction_pattern', 'Get the decorator + guard pattern for deducting credits on a route.', {}, async () => ({
+        content: [{ type: 'text', text: loadContent('credits/deduction.md') }],
+    }));
+    server.tool('credits_get_add_pattern', 'Get the code snippet for programmatically adding credits to a user with a specific transaction type.', {
+        transactionType: z
+            .enum(['INITIAL', 'PURCHASE', 'USAGE', 'REFUND', 'BONUS', 'EXPIRY', 'REDEMPTION'])
+            .describe('The CreditTransactionType to use'),
+    }, async ({ transactionType }) => {
+        const descriptions = {
+            INITIAL: 'Grant starting credits to a new user',
+            PURCHASE: 'Credit top-up purchased by the user',
+            USAGE: 'Manual usage deduction (prefer CreditsGuard for route-level deduction)',
+            REFUND: 'Refund credits after a failed or cancelled operation',
+            BONUS: 'Promotional or reward credits',
+            EXPIRY: 'Expire/remove unused credits',
+            REDEMPTION: 'Redeem credits (e.g. voucher, referral)',
+        };
+        const snippet = `// ${descriptions[transactionType]}
+import { CreditsService } from '../credits/credits.service';
+import { CreditTransactionType } from '../credits/entities/credit-transaction.entity';
+
+// Inject in constructor:
+constructor(private readonly creditsService: CreditsService) {}
+
+// Call:
+await this.creditsService.addCredits(
+  user,                              // User entity
+  100,                               // amount (positive to add, negative to deduct)
+  CreditTransactionType.${transactionType},
+  'Optional description',            // optional
+  'optional-ref-id',                 // optional — external reference (e.g. Polar order ID)
+);`;
+        return {
+            content: [{ type: 'text', text: snippet }],
+        };
+    });
+    server.tool('credits_get_monetization_strategies', 'Get an overview of all monetization strategies (free, subscription, credits, hybrid) and when to use each.', {}, async () => ({
+        content: [{ type: 'text', text: loadContent('credits/strategies.md') }],
+    }));
+}

package/dist/tools/crons.d.ts

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

package/dist/tools/crons.js

@@ -0,0 +1,76 @@
+import { z } from 'zod';
+import { loadContent } from '../lib/content.js';
+const CRON_EXPRESSIONS = [
+    'EVERY_MINUTE',
+    'EVERY_30_MINUTES',
+    'EVERY_HOUR',
+    'EVERY_DAY_AT_MIDNIGHT',
+    'EVERY_WEEK',
+];
+export function registerCronTools(server) {
+    server.tool('cron_get_pattern', 'Get the LaunchFrame cron job pattern: where jobs live, available CronExpression presets, and module registration rules.', {}, async () => ({
+        content: [{ type: 'text', text: loadContent('crons/pattern.md') }],
+    }));
+    server.tool('cron_scaffold_job', 'Scaffold a new cron method to add to CronService (src/jobs/cron.service.ts).', {
+        methodName: z
+            .string()
+            .describe('The name of the cron method, camelCase (e.g. "syncUserStats")'),
+        schedule: z
+            .enum(CRON_EXPRESSIONS)
+            .describe('The CronExpression preset to use'),
+        queueName: z
+            .string()
+            .optional()
+            .describe('Optional Bull queue name to enqueue work into (e.g. "api"). Omit for jobs that do lightweight direct work.'),
+    }, async ({ methodName, schedule, queueName }) => {
+        const queueInjection = queueName
+            ? `\n    @InjectQueue('${queueName}') private readonly ${toCamelCase(queueName)}Queue: Queue,`
+            : '';
+        const queueImports = queueName
+            ? `\nimport { InjectQueue } from '@nestjs/bull';\nimport { Queue } from 'bull';`
+            : '';
+        const methodBody = queueName
+            ? `    this.logger.log('Starting ${methodName}...');
+    try {
+      // TODO: fetch items to process
+      // const items = await this.repo.find({ where: { ... } });
+      // for (const item of items) {
+      //   await this.${toCamelCase(queueName)}Queue.add({ id: item.id }, {
+      //     attempts: 3,
+      //     backoff: { type: 'exponential', delay: 2000 },
+      //   });
+      // }
+    } catch (error) {
+      this.logger.error('Error in ${methodName}:', error);
+    }`
+            : `    this.logger.log('Starting ${methodName}...');
+    try {
+      // TODO: implement job logic
+    } catch (error) {
+      this.logger.error('Error in ${methodName}:', error);
+    }`;
+        const snippet = `// Add this method to src/jobs/cron.service.ts
+// ─── Additional imports needed ───
+import { Cron, CronExpression } from '@nestjs/schedule';${queueImports}
+
+// ─── Add to CronService constructor params ───
+constructor(
+  // ... existing params ...${queueInjection}
+) {}
+
+// ─── New cron method ───
+@Cron(CronExpression.${schedule})
+async ${methodName}() {
+${methodBody}
+}`;
+        return {
+            content: [{ type: 'text', text: snippet }],
+        };
+    });
+}
+function toCamelCase(str) {
+    return str
+        .split('-')
+        .map((part, i) => (i === 0 ? part : part.charAt(0).toUpperCase() + part.slice(1)))
+        .join('');
+}

package/dist/tools/entities.d.ts

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

package/dist/tools/entities.js

@@ -0,0 +1,94 @@
+import { z } from 'zod';
+import { loadContent } from '../lib/content.js';
+export function registerEntityTools(server) {
+    server.tool('entity_get_conventions', 'Get TypeORM entity conventions for LaunchFrame: required decorators, naming strategy, column types, relations, and multi-tenancy.', {}, async () => ({
+        content: [{ type: 'text', text: loadContent('entities/conventions.md') }],
+    }));
+    server.tool('entity_scaffold_typeorm', 'Generate a TypeORM entity file following LaunchFrame conventions.', {
+        entityName: z
+            .string()
+            .describe('Entity class name in PascalCase (e.g. "FeedbackEntry", "AiSummary")'),
+        tableName: z
+            .string()
+            .describe('Database table name in snake_case (e.g. "feedback_entries", "ai_summaries")'),
+        primaryKeyType: z
+            .enum(['int', 'uuid'])
+            .default('int')
+            .describe('Primary key type: "int" (auto-increment) or "uuid"'),
+        multiTenant: z
+            .boolean()
+            .default(false)
+            .describe('Add projectId column for multi-tenant variant'),
+        withEnum: z
+            .string()
+            .optional()
+            .describe('Optional: define a status enum. Provide enum name in PascalCase (e.g. "EntryStatus"). Values will be a placeholder — edit as needed.'),
+    }, async ({ entityName, tableName, primaryKeyType, multiTenant, withEnum, }) => {
+        const pkDeclarator = primaryKeyType === 'uuid'
+            ? `@PrimaryGeneratedColumn('uuid')\n  id: string;`
+            : `@PrimaryGeneratedColumn()\n  id: number;`;
+        const enumBlock = withEnum
+            ? `export enum ${withEnum} {
+  ACTIVE = 'active',
+  INACTIVE = 'inactive',
+  // TODO: add values
+}
+
+`
+            : '';
+        const enumImportEntry = withEnum ? `, Column` : `, Column`;
+        const multiTenantBlock = multiTenant
+            ? `  // MULTI_TENANT_FIELDS_START
+  @Column() projectId: number;
+  // MULTI_TENANT_FIELDS_END
+
+`
+            : `  // MULTI_TENANT_FIELDS_START
+  // @Column() projectId: number;
+  // MULTI_TENANT_FIELDS_END
+
+`;
+        const enumColumnBlock = withEnum
+            ? `
+  @Column({ type: 'enum', enum: ${withEnum} })
+  status: ${withEnum};
+`
+            : '';
+        const imports = [
+            'Entity',
+            'PrimaryGeneratedColumn',
+            'Column',
+            'CreateDateColumn',
+            'UpdateDateColumn',
+        ];
+        const entityFile = `import { ${imports.join(', ')} } from 'typeorm';
+
+${enumBlock}@Entity('${tableName}')
+export class ${entityName} {
+  ${pkDeclarator}
+
+${multiTenantBlock}  // TODO: add domain columns here
+  // @Column() name: string;
+  // @Column({ type: 'text', nullable: true }) description: string;
+${enumColumnBlock}
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}
+`;
+        const registerNote = `// === Register in your module ===
+// In src/modules/<domain>/<domain>.module.ts:
+//   imports: [TypeOrmModule.forFeature([${entityName}])]
+`;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: `// === entities/${tableName}.entity.ts ===\n${entityFile}\n${registerNote}`,
+                },
+            ],
+        };
+    });
+}

package/dist/tools/env.d.ts

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

package/dist/tools/env.js

@@ -0,0 +1,6 @@
+import { loadContent } from '../lib/content.js';
+export function registerEnvTools(server) {
+    server.tool('env_get_conventions', 'Get environment variable conventions for LaunchFrame: single centralized .env location, variable naming rules, full key variable reference, and how to add new variables.', {}, async () => ({
+        content: [{ type: 'text', text: loadContent('env/conventions.md') }],
+    }));
+}

package/dist/tools/feature-gates.d.ts

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

package/dist/tools/feature-gates.js

@@ -0,0 +1,59 @@
+import { z } from 'zod';
+import { loadContent } from '../lib/content.js';
+export function registerFeatureGatesTools(server) {
+    server.tool('feature_gates_get_overview', 'Get the feature gate system overview: how features are stored, how to query them, and the check pattern.', {}, async () => ({
+        content: [{ type: 'text', text: loadContent('feature-gates/overview.md') }],
+    }));
+    server.tool('feature_gates_get_check_pattern', 'Get a copy-paste TypeScript snippet for checking a feature gate by code and type.', {
+        featureCode: z.string().describe('The feature code to check (as defined in the database)'),
+        featureType: z.enum(['boolean', 'numeric']).describe('Whether to generate a boolean or numeric (with limit) check'),
+    }, async ({ featureCode, featureType }) => {
+        const label = featureCode.replace(/_/g, ' ');
+        const camel = featureCode.split('_').map(w => w[0].toUpperCase() + w.slice(1)).join('');
+        const checkSnippet = featureType === 'boolean'
+            ? `const features = await this.userSubscriptionService.getCurrentFeatures(userId);
+
+const hasAccess = features['${featureCode}'] === true;
+if (!hasAccess) {
+  throw new ForbiddenException('Your plan does not include ${label}');
+}`
+            : `const features = await this.userSubscriptionService.getCurrentFeatures(userId);
+
+const limit = features['${featureCode}'] as number ?? 0;
+const isUnlimited = limit === -1;
+const currentCount = await this.get${camel}Count(userId);
+if (!isUnlimited && currentCount >= limit) {
+  throw new ForbiddenException(\`Plan limit reached for ${label} (\${limit})\`);
+}`;
+        return {
+            content: [{
+                    type: 'text',
+                    text: `# Feature Gate Check: \`${featureCode}\` (${featureType})
+
+## Imports
+
+\`\`\`typescript
+import { Injectable, ForbiddenException } from '@nestjs/common';
+import { UserSubscriptionService } from '../subscriptions/services/user-subscription.service';
+\`\`\`
+
+## Constructor Injection
+
+\`\`\`typescript
+constructor(
+  private readonly userSubscriptionService: UserSubscriptionService,
+) {}
+\`\`\`
+
+## Check
+
+\`\`\`typescript
+${checkSnippet}
+\`\`\`
+
+> Feature code \`${featureCode}\` must exist in the \`subscription_plan_features\` table and have values configured per plan.
+`,
+                }],
+        };
+    });
+}

package/dist/tools/modules.d.ts

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

package/dist/tools/modules.js

@@ -0,0 +1,144 @@
+import { z } from 'zod';
+import { loadContent } from '../lib/content.js';
+export function registerModuleTools(server) {
+    server.tool('module_get_structure', 'Get the NestJS module folder structure, conventions, and rules used in LaunchFrame.', {}, async () => ({
+        content: [{ type: 'text', text: loadContent('modules/structure.md') }],
+    }));
+    server.tool('module_scaffold_nestjs', 'Generate a NestJS module scaffold (module + service + optional controller + optional entity) following LaunchFrame conventions.', {
+        moduleName: z
+            .string()
+            .describe('Domain name in kebab-case (e.g. "projects", "ai-summaries")'),
+        withController: z
+            .boolean()
+            .default(true)
+            .describe('Include a controller with basic CRUD routes'),
+        withEntity: z
+            .boolean()
+            .default(true)
+            .describe('Include a TypeORM entity and register it via TypeOrmModule.forFeature'),
+    }, async ({ moduleName, withController, withEntity, }) => {
+        const pascal = toPascalCase(moduleName);
+        const camel = toCamelCase(moduleName);
+        const snake = toSnakeCase(moduleName);
+        const entityImport = withEntity
+            ? `import { TypeOrmModule } from '@nestjs/typeorm';\nimport { ${pascal} } from './entities/${moduleName}.entity';`
+            : '';
+        const entityFeature = withEntity
+            ? `\n    TypeOrmModule.forFeature([${pascal}]),`
+            : '';
+        const controllerImport = withController
+            ? `import { ${pascal}Controller } from './${moduleName}.controller';`
+            : '';
+        const controllerDecl = withController ? `\n  controllers: [${pascal}Controller],` : '';
+        const moduleFile = `import { Module } from '@nestjs/common';
+${entityImport}
+import { ${pascal}Service } from './${moduleName}.service';
+${controllerImport}
+
+@Module({
+  imports: [${entityFeature}
+    // MULTI_TENANT_MODULE_IMPORTS_START
+    // MULTI_TENANT_MODULE_IMPORTS_END
+  ],
+  providers: [
+    ${pascal}Service,
+    // MULTI_TENANT_PROVIDERS_START
+    // MULTI_TENANT_PROVIDERS_END
+  ],${controllerDecl}
+  exports: [${pascal}Service],
+})
+export class ${pascal}Module {}`;
+        const serviceFile = `import { Injectable } from '@nestjs/common';
+${withEntity ? `import { InjectRepository } from '@nestjs/typeorm';\nimport { Repository } from 'typeorm';\nimport { ${pascal} } from './entities/${moduleName}.entity';` : ''}
+
+@Injectable()
+export class ${pascal}Service {
+${withEntity ? `  constructor(
+    @InjectRepository(${pascal})
+    private readonly ${camel}Repository: Repository<${pascal}>,
+  ) {}` : ''}
+  // TODO: implement service methods
+}`;
+        const controllerFile = withController
+            ? `import { Controller, Get, Post, Body, Param, Delete, Put } from '@nestjs/common';
+import { ${pascal}Service } from './${moduleName}.service';
+import { CurrentUser } from '@/modules/auth/auth.decorator';
+import { User } from '@/modules/users/user.entity';
+
+@Controller('${moduleName}')
+export class ${pascal}Controller {
+  constructor(private readonly ${camel}Service: ${pascal}Service) {}
+
+  @Get()
+  findAll(@CurrentUser() user: User) {
+    // TODO: implement
+  }
+
+  @Get(':id')
+  findOne(@Param('id') id: string, @CurrentUser() user: User) {
+    // TODO: implement
+  }
+
+  @Post()
+  create(@Body() body: Record<string, unknown>, @CurrentUser() user: User) {
+    // TODO: implement
+  }
+
+  @Put(':id')
+  update(@Param('id') id: string, @Body() body: Record<string, unknown>, @CurrentUser() user: User) {
+    // TODO: implement
+  }
+
+  @Delete(':id')
+  remove(@Param('id') id: string, @CurrentUser() user: User) {
+    // TODO: implement
+  }
+}`
+            : null;
+        const entityFile = withEntity
+            ? `import { Entity, PrimaryGeneratedColumn, Column, CreateDateColumn, UpdateDateColumn } from 'typeorm';
+
+@Entity('${snake}')
+export class ${pascal} {
+  @PrimaryGeneratedColumn()
+  id: number;
+
+  // MULTI_TENANT_FIELDS_START
+  // @Column() projectId: number;
+  // MULTI_TENANT_FIELDS_END
+
+  // TODO: add domain columns here
+
+  @CreateDateColumn()
+  createdAt: Date;
+
+  @UpdateDateColumn()
+  updatedAt: Date;
+}`
+            : null;
+        const sections = [
+            `// === ${moduleName}.module.ts ===\n${moduleFile}`,
+            `\n// === ${moduleName}.service.ts ===\n${serviceFile}`,
+        ];
+        if (controllerFile)
+            sections.push(`\n// === ${moduleName}.controller.ts ===\n${controllerFile}`);
+        if (entityFile)
+            sections.push(`\n// === entities/${moduleName}.entity.ts ===\n${entityFile}`);
+        sections.push(`
+// === Register in app.module.ts ===
+// Add ${pascal}Module to the imports array in src/modules/app/app.module.ts`);
+        return {
+            content: [{ type: 'text', text: sections.join('\n') }],
+        };
+    });
+}
+function toCamelCase(str) {
+    return str.replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+}
+function toPascalCase(str) {
+    const camel = toCamelCase(str);
+    return camel.charAt(0).toUpperCase() + camel.slice(1);
+}
+function toSnakeCase(str) {
+    return str.replace(/-/g, '_');
+}

package/dist/tools/queues.d.ts

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