Advanced PocketBase MCP Server

Implementation Reference

• src/agent-simple.ts:753-787 (handler)

  The async handler function for the 'send_templated_email' MCP tool. It lazy-loads the EmailService, calls sendTemplatedEmail with validated parameters, handles errors, and returns a structured response with the email log details.

  async ({ template, to, from, subject, variables }) => {
    // Lazy load Email service
    await this.ensureEmailService();
    
    if (!this.emailService) {
      throw new Error('Email service not available. Please configure EMAIL_SERVICE or SMTP settings.');
    }
  
    try {
      const result = await this.emailService.sendTemplatedEmail({
        template,
        to,
        from,
        customSubject: subject,
        variables
      });
      return {
        content: [{
          type: 'text',
          text: JSON.stringify({
            success: true,
            emailLog: {
              id: result.id,
              to: result.to,
              subject: result.subject,
              status: result.status,
              sentAt: result.created
            }
          }, null, 2)
        }]
      };
    } catch (error: any) {
      throw new Error(`Failed to send email: ${error.message}`);
    }
  }

• src/agent-simple.ts:741-788 (registration)

  Registers the 'send_templated_email' tool on the MCP server, providing description and Zod-based input schema for validation.

  this.server.tool(
    'send_templated_email',
    {
      description: 'Send a templated email using the configured email service',
      inputSchema: {
        template: z.string().describe('Email template name'),
        to: z.string().email().describe('Recipient email address'),
        from: z.string().email().optional().describe('Sender email address'),
        subject: z.string().optional().describe('Custom email subject'),
        variables: z.record(z.unknown()).optional().describe('Template variables')
      }
    },
    async ({ template, to, from, subject, variables }) => {
      // Lazy load Email service
      await this.ensureEmailService();
      
      if (!this.emailService) {
        throw new Error('Email service not available. Please configure EMAIL_SERVICE or SMTP settings.');
      }
  
      try {
        const result = await this.emailService.sendTemplatedEmail({
          template,
          to,
          from,
          customSubject: subject,
          variables
        });
        return {
          content: [{
            type: 'text',
            text: JSON.stringify({
              success: true,
              emailLog: {
                id: result.id,
                to: result.to,
                subject: result.subject,
                status: result.status,
                sentAt: result.created
              }
            }, null, 2)
          }]
        };
      } catch (error: any) {
        throw new Error(`Failed to send email: ${error.message}`);
      }
    }
  );

• src/agent-simple.ts:746-751 (schema)

  Zod input schema defining parameters for the send_templated_email tool: template name, recipient email, optional sender/from, custom subject, and variables object.

    template: z.string().describe('Email template name'),
    to: z.string().email().describe('Recipient email address'),
    from: z.string().email().optional().describe('Sender email address'),
    subject: z.string().optional().describe('Custom email subject'),
    variables: z.record(z.unknown()).optional().describe('Template variables')
  }

• src/services/email.ts:119-173 (helper)

  Core EmailService method implementing templated email sending: fetches template from PocketBase, compiles Handlebars templates with variables, sends via nodemailer Transporter, creates success/failure log in email_logs collection.

  async sendTemplatedEmail(data: {
    template: string;
    to: string;
    from?: string;
    variables?: Record<string, any>;
    customSubject?: string;
  }): Promise<EmailLog> {
    try {
      // Get template
      const template = await this.getTemplate(data.template);
      
      // Compile templates
      const subjectTemplate = Handlebars.compile(data.customSubject || template.subject);
      const htmlTemplate = Handlebars.compile(template.htmlContent);
      const textTemplate = template.textContent ? Handlebars.compile(template.textContent) : null;
  
      // Apply variables
      const variables = data.variables || {};
      const subject = subjectTemplate(variables);
      const html = htmlTemplate(variables);
      const text = textTemplate ? textTemplate(variables) : undefined;
  
      // Send email
      const info = await this.transporter.sendMail({
        from: data.from || process.env.SMTP_USER || process.env.DEFAULT_FROM_EMAIL,
        to: data.to,
        subject,
        html,
        text,
      });      // Log email
      const emailLog = await this.pb.collection('email_logs').create({
        to: data.to,
        from: data.from || process.env.SMTP_USER || process.env.DEFAULT_FROM_EMAIL,
        subject,
        template: data.template,
        status: 'sent',
        variables: variables,
      });
  
      return emailLog as unknown as EmailLog;
    } catch (error: any) {
      // Log failed email
      const emailLog = await this.pb.collection('email_logs').create({
        to: data.to,
        from: data.from || process.env.SMTP_USER || process.env.DEFAULT_FROM_EMAIL,
        subject: data.customSubject || 'Email send failed',
        template: data.template,
        status: 'failed',
        error: error.message,
        variables: data.variables || {},
      });
  
      throw new Error(`Failed to send email: ${error.message}`);
    }
  }