pocketbase-mcp-server

Implementation Reference

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

  Core handler function in EmailService class that implements the templated email sending logic: retrieves template from PocketBase, compiles with Handlebars using variables, sends via nodemailer, logs success/failure to 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}`);
    }
  }

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

  MCP server.tool registration for 'send_templated_email' including Zod inputSchema, description, and thin wrapper handler that lazy-loads EmailService and delegates to its sendTemplatedEmail method.

  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:743-750 (schema)

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

  {
    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')

• src/services/email.ts:82-91 (helper)

  Supporting helper method to retrieve EmailTemplate from PocketBase by name, used by sendTemplatedEmail.

  async getTemplate(name: string): Promise<EmailTemplate> {
    try {
      const template = await this.pb.collection('email_templates')
        .getFirstListItem(`name="${name}"`);
      
      return template as unknown as EmailTemplate;
    } catch (error: any) {
      throw new Error(`Template not found: ${name}`);
    }
  }