pocketbase-mcp-server

Implementation Reference

• src/agent-simple.ts:693-734 (handler)

  Primary handler and registration for the 'create_stripe_product' MCP tool. Defines input schema with Zod validation, lazy-initializes StripeService, delegates to its createProduct method, handles errors, and returns standardized MCP response.

  this.server.tool(
    'create_stripe_product',
    {
      description: 'Create a new product in Stripe',
      inputSchema: {
        name: z.string().describe('Product name'),
        description: z.string().optional().describe('Product description'),
        price: z.number().int().positive().describe('Price in cents'),
        currency: z.string().length(3).optional().describe('Currency code (default: USD)'),
        interval: z.enum(['month', 'year', 'week', 'day']).optional().describe('Billing interval for subscriptions')
      }
    },
    async ({ name, description, price, currency, interval }) => {
      // Lazy load Stripe service
      await this.ensureStripeService();
      
      if (!this.stripeService) {
        throw new Error('Stripe service not available. Please set STRIPE_SECRET_KEY environment variable.');
      }
  
      try {
        const product = await this.stripeService.createProduct({
          name,
          description,
          price,
          currency: currency || 'usd',
          interval
        });
        return {
          content: [{
            type: 'text',
            text: JSON.stringify({
              success: true,
              product
            }, null, 2)
          }]
        };
      } catch (error: any) {
        throw new Error(`Failed to create product: ${error.message}`);
      }
    }
  );

• src/services/stripe.ts:20-66 (helper)

  Core helper method in StripeService class that implements Stripe product creation: creates product and price via Stripe API, persists combined data to PocketBase 'stripe_products' collection, returns typed PocketBase record.

  // Product Management
  async createProduct(data: {
    name: string;
    description?: string;
    price: number;
    currency?: string;
    recurring?: boolean;
    interval?: 'month' | 'year' | 'week' | 'day';
    metadata?: Record<string, any>;
  }): Promise<StripeProduct> {
    try {
      // Create product in Stripe
      const stripeProduct = await this.stripe.products.create({
        name: data.name,
        description: data.description,
        metadata: data.metadata || {},
      });
  
      // Create price in Stripe
      const stripePrice = await this.stripe.prices.create({
        unit_amount: data.price,
        currency: data.currency || 'usd',
        product: stripeProduct.id,
        recurring: data.recurring ? {
          interval: data.interval || 'month',
        } : undefined,
      });
  
      // Save to PocketBase
      const productRecord = await this.pb.collection('stripe_products').create({
        name: data.name,
        description: data.description,
        price: data.price,
        currency: data.currency || 'usd',
        recurring: data.recurring || false,
        interval: data.interval,
        stripeProductId: stripeProduct.id,
        stripePriceId: stripePrice.id,
        active: true,
        metadata: data.metadata || {},
      });
  
      return productRecord as unknown as StripeProduct;
    } catch (error: any) {
      throw new Error(`Failed to create product: ${error.message}`);
    }
  }

• src/types/stripe.d.ts:2-16 (schema)

  TypeScript interface defining the structure of StripeProduct records used for input validation and return type casting in the createProduct helper.

  export interface StripeProduct {
    id: string;
    name: string;
    description?: string;
    price?: number;
    currency?: string;
    recurring?: boolean;
    interval?: 'month' | 'year' | 'week' | 'day';
    stripeProductId: string;
    stripePriceId?: string;
    active: boolean;
    metadata?: Record<string, any>;
    created: string;
    updated: string;
  }