Email flow test agent

import OpenAI from 'openai';
import { Client } from '@modelcontextprotocol/sdk/client/index.js';
import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';

/* ── your provider: this block is the only part that changes ── */
const client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

const MODEL = process.env.MODEL;
if (!MODEL) throw new Error('Set MODEL to the model name your provider expects, e.g. export MODEL=gpt-4o-mini');

/** The only provider-specific code in any of these examples. */
async function ask({ system, user, schema }: {
  system: string;
  user: string;
  schema?: object;
}) {
  const res = await client.chat.completions.create({
    model: MODEL,
    messages: [
      { role: 'system', content: system },
      { role: 'user', content: user }
    ],
    // A schema turns the answer into an object instead of prose, which is what
    // the branching examples want. Without one you get the text back.
    ...(schema
      ? { response_format: { type: 'json_schema', json_schema: { name: 'out', schema, strict: true } } }
      : {})
  });

  const text = res.choices[0].message.content ?? '';
  return schema ? JSON.parse(text) : text;
}

/* ── the agent ── */

const BASE_URL = process.env.BASE_URL!;

const mcp = new Client({ name: 'email-tests', version: '1.0.0' });
await mcp.connect(
  new StreamableHTTPClientTransport(new URL('https://connect.mcpmailer.com/mcp'), {
    requestInit: { headers: { Authorization: `Bearer ${process.env.MCPMAILER_API_KEY}` } }
  })
);

const call = async (name: string, args: object) => {
  const res = await mcp.callTool({ name, arguments: args });
  return JSON.parse((res.content as { text: string }[])[0].text);
};

const failures: string[] = [];

async function testFlow(flow: string, trigger: (email: string) => Promise<void>, expect: {
  subject: RegExp;
  code?: RegExp;
}) {
  const { address } = await call('create_temp_address', {
    ttl_seconds: 600,
    label: `${flow}-${process.env.GITHUB_RUN_ID ?? 'local'}`
  });

  try {
    await trigger(address);
    const mail = await call('wait_for_message', { address, timeout_seconds: 120 });

    if (mail.timed_out) return void failures.push(`${flow}: nothing arrived in 120s`);
    if (!expect.subject.test(mail.subject))
      failures.push(`${flow}: subject was "${mail.subject}"`);

    // The bug this exists to catch: staging mailing production links.
    for (const link of mail.body_text.match(/https?:\/\/\S+/g) ?? []) {
      if (!link.startsWith(BASE_URL)) failures.push(`${flow}: link off-environment: ${link}`);
    }
    // Every assertion runs, so one failure never hides three others.
    for (const leak of mail.body_text.match(/\{\{[^}]+\}\}|%[a-z_]+%|\bundefined\b/gi) ?? []) {
      failures.push(`${flow}: unreplaced template variable: ${leak}`);
    }
    if (expect.code && !expect.code.test(mail.body_text))
      failures.push(`${flow}: no code matching ${expect.code}`);
    if (!mail.body_text.trim()) failures.push(`${flow}: empty text part`);
  } finally {
    // Pass or fail: a leaked address costs the next run.
    await call('release_temp_address', { address });
  }
}

await testFlow('signup', (email) => post('/api/signup', { email }), { subject: /confirm/i, code: /\b\d{6}\b/ });
await testFlow('reset', (email) => post('/api/reset', { email }), { subject: /reset/i });

if (failures.length) {
  console.error(failures.join('\n'));
  process.exit(1);
}
console.log('email flows ok');