tempmail-sdk 1.0.3 → 1.1.1

package/dist/providers/guerrillamail.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Guerrilla Mail 渠道实现
+ * API 文档: https://www.guerrillamail.com/GuerrillaMailAPI.html
+ *
+ * 特点:
+ * - 无需认证，公开 JSON API
+ * - 通过 sid_token 维持会话
+ * - 邮箱有效期 60 分钟
+ */
+import { InternalEmailInfo, Email } from '../types';
+/**
+ * 创建临时邮箱
+ * API: GET ajax.php?f=get_email_address
+ * 返回 email_addr + sid_token（用于后续获取邮件）
+ */
+export declare function generateEmail(): Promise<InternalEmailInfo>;
+/**
+ * 获取邮件列表
+ * API: GET ajax.php?f=check_email&seq=0&sid_token=xxx
+ * 返回 list 数组，每个元素包含 mail_id, mail_from, mail_subject, mail_body 等
+ */
+export declare function getEmails(token: string, email: string): Promise<Email[]>;

package/dist/providers/guerrillamail.js

@@ -0,0 +1,71 @@
+"use strict";
+/**
+ * Guerrilla Mail 渠道实现
+ * API 文档: https://www.guerrillamail.com/GuerrillaMailAPI.html
+ *
+ * 特点:
+ * - 无需认证，公开 JSON API
+ * - 通过 sid_token 维持会话
+ * - 邮箱有效期 60 分钟
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEmail = generateEmail;
+exports.getEmails = getEmails;
+const normalize_1 = require("../normalize");
+const CHANNEL = 'guerrillamail';
+const BASE_URL = 'https://api.guerrillamail.com/ajax.php';
+/**
+ * 创建临时邮箱
+ * API: GET ajax.php?f=get_email_address
+ * 返回 email_addr + sid_token（用于后续获取邮件）
+ */
+async function generateEmail() {
+    const response = await fetch(`${BASE_URL}?f=get_email_address&lang=en`, {
+        method: 'GET',
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to generate email: ${response.status}`);
+    }
+    const data = await response.json();
+    if (!data.email_addr || !data.sid_token) {
+        throw new Error('Failed to generate email: missing email_addr or sid_token');
+    }
+    return {
+        channel: CHANNEL,
+        email: data.email_addr,
+        token: data.sid_token,
+        expiresAt: data.email_timestamp ? (data.email_timestamp + 3600) * 1000 : undefined,
+    };
+}
+/**
+ * 获取邮件列表
+ * API: GET ajax.php?f=check_email&seq=0&sid_token=xxx
+ * 返回 list 数组，每个元素包含 mail_id, mail_from, mail_subject, mail_body 等
+ */
+async function getEmails(token, email) {
+    const response = await fetch(`${BASE_URL}?f=check_email&seq=0&sid_token=${encodeURIComponent(token)}`, {
+        method: 'GET',
+        headers: {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to get emails: ${response.status}`);
+    }
+    const data = await response.json();
+    const list = Array.isArray(data.list) ? data.list : [];
+    return list.map((item) => (0, normalize_1.normalizeEmail)({
+        id: item.mail_id,
+        from: item.mail_from,
+        to: email,
+        subject: item.mail_subject,
+        text: item.mail_body || item.mail_excerpt || '',
+        html: item.mail_body || '',
+        date: item.mail_date || '',
+        isRead: item.mail_read === 1,
+    }, email));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/linshi-email.d.ts

@@ -1,3 +1,3 @@
-import { EmailInfo, Email } from '../types';
-export declare function generateEmail(): Promise<EmailInfo>;
+import { InternalEmailInfo, Email } from '../types';
+export declare function generateEmail(): Promise<InternalEmailInfo>;
 export declare function getEmails(email: string): Promise<Email[]>;

package/dist/providers/linshi-email.js

@@ -52,4 +52,4 @@ async function getEmails(email) {
     const rawEmails = data.list || [];
     return rawEmails.map((raw) => (0, normalize_1.normalizeEmail)(raw, email));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/mail-tm.d.ts

@@ -1,9 +1,9 @@
-import { EmailInfo, Email } from '../types';
+import { InternalEmailInfo, Email } from '../types';
 /**
  * 创建临时邮箱
  * 流程: 获取域名 → 生成随机邮箱/密码 → 创建账号 → 获取 Token
  */
-export declare function generateEmail(): Promise<EmailInfo>;
+export declare function generateEmail(): Promise<InternalEmailInfo>;
 /**
  * 获取邮件列表
  * 流程: GET /messages 获取列表 → 对每封邮件 GET /messages/{id} 获取详情（含 text/html）

package/dist/providers/mail-tm.js

@@ -169,4 +169,4 @@ async function getEmails(token, email) {
     const flatMessages = await Promise.all(detailPromises);
     return flatMessages.map((raw) => (0, normalize_1.normalizeEmail)(raw, email));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mail-tm.js","sourceRoot":"","sources":["../../src/providers/mail-tm.ts"],"names":[],"mappings":"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","sourcesContent":["import { EmailInfo, Email, Channel } from '../types';\nimport { normalizeEmail } from '../normalize';\n\nconst CHANNEL: Channel = 'mail-tm';\nconst BASE_URL = 'https://api.mail.tm';\n\nconst DEFAULT_HEADERS: Record<string, string> = {\n  'Content-Type': 'application/json',\n  'Accept': 'application/json',\n};\n\n/**\n * 生成随机字符串\n */\nfunction randomString(length: number): string {\n  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';\n  let result = '';\n  for (let i = 0; i < length; i++) {\n    result += chars[Math.floor(Math.random() * chars.length)];\n  }\n  return result;\n}\n\n/**\n * 获取可用域名列表\n * API: GET /domains\n */\nasync function getDomains(): Promise<string[]> {\n  const response = await fetch(`${BASE_URL}/domains`, {\n    method: 'GET',\n    headers: DEFAULT_HEADERS,\n  });\n\n  if (!response.ok) {\n    throw new Error(`Failed to get domains: ${response.status}`);\n  }\n\n  const data = await response.json();\n  /* 兼容两种响应格式：\n   * - Accept: application/ld+json → Hydra 格式 { \"hydra:member\": [...] }\n   * - Accept: application/json   → 纯数组 [...]\n   */\n  const members = Array.isArray(data) ? data : (data['hydra:member'] || []);\n  return members\n    .filter((d: any) => d.isActive)\n    .map((d: any) => d.domain);\n}\n\n/**\n * 创建账号\n * API: POST /accounts\n */\nasync function createAccount(address: string, password: string): Promise<any> {\n  const response = await fetch(`${BASE_URL}/accounts`, {\n    method: 'POST',\n    headers: { ...DEFAULT_HEADERS, 'Content-Type': 'application/ld+json' },\n    body: JSON.stringify({ address, password }),\n  });\n\n  if (!response.ok) {\n    const text = await response.text();\n    throw new Error(`Failed to create account: ${response.status} ${text}`);\n  }\n\n  return response.json();\n}\n\n/**\n * 获取 Bearer Token\n * API: POST /token\n */\nasync function getToken(address: string, password: string): Promise<string> {\n  const response = await fetch(`${BASE_URL}/token`, {\n    method: 'POST',\n    headers: DEFAULT_HEADERS,\n    body: JSON.stringify({ address, password }),\n  });\n\n  if (!response.ok) {\n    throw new Error(`Failed to get token: ${response.status}`);\n  }\n\n  const data = await response.json();\n  return data.token;\n}\n\n/**\n * 创建临时邮箱\n * 流程: 获取域名 → 生成随机邮箱/密码 → 创建账号 → 获取 Token\n */\nexport async function generateEmail(): Promise<EmailInfo> {\n  // 1. 获取可用域名\n  const domains = await getDomains();\n  if (domains.length === 0) {\n    throw new Error('No available domains');\n  }\n\n  // 2. 生成随机邮箱和密码\n  const domain = domains[Math.floor(Math.random() * domains.length)];\n  const username = randomString(12);\n  const address = `${username}@${domain}`;\n  const password = randomString(16);\n\n  // 3. 创建账号\n  const account = await createAccount(address, password);\n\n  // 4. 获取 Bearer Token\n  const token = await getToken(address, password);\n\n  return {\n    channel: CHANNEL,\n    email: address,\n    token: token,\n    createdAt: account.createdAt,\n  };\n}\n\n/**\n * 将 mail.tm 的消息格式扁平化为 normalizeEmail 可处理的格式\n * mail.tm 的 from 是 {name, address} 对象，to 是数组，html 是字符串数组\n */\nfunction flattenMessage(msg: any, recipientEmail: string): any {\n  return {\n    id: msg.id || '',\n    from: msg.from?.address || '',\n    to: msg.to?.[0]?.address || recipientEmail,\n    subject: msg.subject || '',\n    text: msg.text || '',\n    html: Array.isArray(msg.html) ? msg.html.join('') : (msg.html || ''),\n    createdAt: msg.createdAt || '',\n    seen: msg.seen ?? false,\n    attachments: (msg.attachments || []).map((a: any) => ({\n      filename: a.filename || '',\n      size: a.size || undefined,\n      contentType: a.contentType || undefined,\n      downloadUrl: a.downloadUrl ? `${BASE_URL}${a.downloadUrl}` : undefined,\n    })),\n  };\n}\n\n/**\n * 获取邮件列表\n * 流程: GET /messages 获取列表 → 对每封邮件 GET /messages/{id} 获取详情（含 text/html）\n */\nexport async function getEmails(token: string, email: string): Promise<Email[]> {\n  // 1. 获取邮件列表\n  const listResponse = await fetch(`${BASE_URL}/messages`, {\n    method: 'GET',\n    headers: {\n      ...DEFAULT_HEADERS,\n      'Authorization': `Bearer ${token}`,\n    },\n  });\n\n  if (!listResponse.ok) {\n    throw new Error(`Failed to get emails: ${listResponse.status}`);\n  }\n\n  const listData = await listResponse.json();\n  /* 兼容 Hydra 格式和纯数组格式 */\n  const messages = Array.isArray(listData) ? listData : (listData['hydra:member'] || []);\n\n  if (messages.length === 0) {\n    return [];\n  }\n\n  // 2. 并行获取每封邮件的详情（含 text/html/attachments）\n  const detailPromises = messages.map(async (msg: any) => {\n    try {\n      const detailResponse = await fetch(`${BASE_URL}/messages/${msg.id}`, {\n        method: 'GET',\n        headers: {\n          ...DEFAULT_HEADERS,\n          'Authorization': `Bearer ${token}`,\n        },\n      });\n\n      if (!detailResponse.ok) {\n        // 如果详情获取失败，退回使用列表数据\n        return flattenMessage(msg, email);\n      }\n\n      const detail = await detailResponse.json();\n      return flattenMessage(detail, email);\n    } catch {\n      // 出错时退回使用列表数据\n      return flattenMessage(msg, email);\n    }\n  });\n\n  const flatMessages = await Promise.all(detailPromises);\n  return flatMessages.map((raw: any) => normalizeEmail(raw, email));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"mail-tm.js","sourceRoot":"","sources":["../../src/providers/mail-tm.ts"],"names":[],"mappings":"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","sourcesContent":["import { InternalEmailInfo, Email, Channel } from '../types';\nimport { normalizeEmail } from '../normalize';\n\nconst CHANNEL: Channel = 'mail-tm';\nconst BASE_URL = 'https://api.mail.tm';\n\nconst DEFAULT_HEADERS: Record<string, string> = {\n  'Content-Type': 'application/json',\n  'Accept': 'application/json',\n};\n\n/**\n * 生成随机字符串\n */\nfunction randomString(length: number): string {\n  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';\n  let result = '';\n  for (let i = 0; i < length; i++) {\n    result += chars[Math.floor(Math.random() * chars.length)];\n  }\n  return result;\n}\n\n/**\n * 获取可用域名列表\n * API: GET /domains\n */\nasync function getDomains(): Promise<string[]> {\n  const response = await fetch(`${BASE_URL}/domains`, {\n    method: 'GET',\n    headers: DEFAULT_HEADERS,\n  });\n\n  if (!response.ok) {\n    throw new Error(`Failed to get domains: ${response.status}`);\n  }\n\n  const data = await response.json();\n  /* 兼容两种响应格式：\n   * - Accept: application/ld+json → Hydra 格式 { \"hydra:member\": [...] }\n   * - Accept: application/json   → 纯数组 [...]\n   */\n  const members = Array.isArray(data) ? data : (data['hydra:member'] || []);\n  return members\n    .filter((d: any) => d.isActive)\n    .map((d: any) => d.domain);\n}\n\n/**\n * 创建账号\n * API: POST /accounts\n */\nasync function createAccount(address: string, password: string): Promise<any> {\n  const response = await fetch(`${BASE_URL}/accounts`, {\n    method: 'POST',\n    headers: { ...DEFAULT_HEADERS, 'Content-Type': 'application/ld+json' },\n    body: JSON.stringify({ address, password }),\n  });\n\n  if (!response.ok) {\n    const text = await response.text();\n    throw new Error(`Failed to create account: ${response.status} ${text}`);\n  }\n\n  return response.json();\n}\n\n/**\n * 获取 Bearer Token\n * API: POST /token\n */\nasync function getToken(address: string, password: string): Promise<string> {\n  const response = await fetch(`${BASE_URL}/token`, {\n    method: 'POST',\n    headers: DEFAULT_HEADERS,\n    body: JSON.stringify({ address, password }),\n  });\n\n  if (!response.ok) {\n    throw new Error(`Failed to get token: ${response.status}`);\n  }\n\n  const data = await response.json();\n  return data.token;\n}\n\n/**\n * 创建临时邮箱\n * 流程: 获取域名 → 生成随机邮箱/密码 → 创建账号 → 获取 Token\n */\nexport async function generateEmail(): Promise<InternalEmailInfo> {\n  // 1. 获取可用域名\n  const domains = await getDomains();\n  if (domains.length === 0) {\n    throw new Error('No available domains');\n  }\n\n  // 2. 生成随机邮箱和密码\n  const domain = domains[Math.floor(Math.random() * domains.length)];\n  const username = randomString(12);\n  const address = `${username}@${domain}`;\n  const password = randomString(16);\n\n  // 3. 创建账号\n  const account = await createAccount(address, password);\n\n  // 4. 获取 Bearer Token\n  const token = await getToken(address, password);\n\n  return {\n    channel: CHANNEL,\n    email: address,\n    token: token,\n    createdAt: account.createdAt,\n  };\n}\n\n/**\n * 将 mail.tm 的消息格式扁平化为 normalizeEmail 可处理的格式\n * mail.tm 的 from 是 {name, address} 对象，to 是数组，html 是字符串数组\n */\nfunction flattenMessage(msg: any, recipientEmail: string): any {\n  return {\n    id: msg.id || '',\n    from: msg.from?.address || '',\n    to: msg.to?.[0]?.address || recipientEmail,\n    subject: msg.subject || '',\n    text: msg.text || '',\n    html: Array.isArray(msg.html) ? msg.html.join('') : (msg.html || ''),\n    createdAt: msg.createdAt || '',\n    seen: msg.seen ?? false,\n    attachments: (msg.attachments || []).map((a: any) => ({\n      filename: a.filename || '',\n      size: a.size || undefined,\n      contentType: a.contentType || undefined,\n      downloadUrl: a.downloadUrl ? `${BASE_URL}${a.downloadUrl}` : undefined,\n    })),\n  };\n}\n\n/**\n * 获取邮件列表\n * 流程: GET /messages 获取列表 → 对每封邮件 GET /messages/{id} 获取详情（含 text/html）\n */\nexport async function getEmails(token: string, email: string): Promise<Email[]> {\n  // 1. 获取邮件列表\n  const listResponse = await fetch(`${BASE_URL}/messages`, {\n    method: 'GET',\n    headers: {\n      ...DEFAULT_HEADERS,\n      'Authorization': `Bearer ${token}`,\n    },\n  });\n\n  if (!listResponse.ok) {\n    throw new Error(`Failed to get emails: ${listResponse.status}`);\n  }\n\n  const listData = await listResponse.json();\n  /* 兼容 Hydra 格式和纯数组格式 */\n  const messages = Array.isArray(listData) ? listData : (listData['hydra:member'] || []);\n\n  if (messages.length === 0) {\n    return [];\n  }\n\n  // 2. 并行获取每封邮件的详情（含 text/html/attachments）\n  const detailPromises = messages.map(async (msg: any) => {\n    try {\n      const detailResponse = await fetch(`${BASE_URL}/messages/${msg.id}`, {\n        method: 'GET',\n        headers: {\n          ...DEFAULT_HEADERS,\n          'Authorization': `Bearer ${token}`,\n        },\n      });\n\n      if (!detailResponse.ok) {\n        // 如果详情获取失败，退回使用列表数据\n        return flattenMessage(msg, email);\n      }\n\n      const detail = await detailResponse.json();\n      return flattenMessage(detail, email);\n    } catch {\n      // 出错时退回使用列表数据\n      return flattenMessage(msg, email);\n    }\n  });\n\n  const flatMessages = await Promise.all(detailPromises);\n  return flatMessages.map((raw: any) => normalizeEmail(raw, email));\n}\n"]}

package/dist/providers/maildrop.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Maildrop 渠道实现
+ * API: GraphQL endpoint https://api.maildrop.cc/graphql
+ *
+ * 特点:
+ * - 无需认证，公开 GraphQL API
+ * - 自带反垃圾过滤
+ * - 邮箱名即用户名（任意字符串@maildrop.cc）
+ * - 无过期时间限制
+ */
+import { InternalEmailInfo, Email } from '../types';
+/**
+ * 创建临时邮箱
+ * Maildrop 无需注册，任意用户名即可接收邮件
+ */
+export declare function generateEmail(): Promise<InternalEmailInfo>;
+/**
+ * 获取邮件列表
+ * 先查 inbox 获取邮件 ID 列表，再逐封获取完整内容
+ */
+export declare function getEmails(token: string, email: string): Promise<Email[]>;

package/dist/providers/maildrop.js

@@ -0,0 +1,180 @@
+"use strict";
+/**
+ * Maildrop 渠道实现
+ * API: GraphQL endpoint https://api.maildrop.cc/graphql
+ *
+ * 特点:
+ * - 无需认证，公开 GraphQL API
+ * - 自带反垃圾过滤
+ * - 邮箱名即用户名（任意字符串@maildrop.cc）
+ * - 无过期时间限制
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEmail = generateEmail;
+exports.getEmails = getEmails;
+const CHANNEL = 'maildrop';
+const GRAPHQL_URL = 'https://api.maildrop.cc/graphql';
+const DOMAIN = 'maildrop.cc';
+/**
+ * 解码 RFC 2047 编码的邮件头（如发件人、主题）
+ * 支持 Base64 (B) 和 Quoted-Printable (Q) 编码
+ */
+function decodeRfc2047(str) {
+    if (!str)
+        return '';
+    return str.replace(/=\?([^?]+)\?(B|Q)\?([^?]*)\?=/gi, (_, charset, encoding, encoded) => {
+        try {
+            if (encoding.toUpperCase() === 'B') {
+                return Buffer.from(encoded, 'base64').toString('utf-8');
+            }
+            /* Quoted-Printable: _=空格，=XX=十六进制字节 */
+            const decoded = encoded
+                .replace(/_/g, ' ')
+                .replace(/=([0-9A-Fa-f]{2})/g, (_m, hex) => String.fromCharCode(parseInt(hex, 16)));
+            return decoded;
+        }
+        catch {
+            return encoded;
+        }
+    });
+}
+/**
+ * 从原始 MIME 邮件源码中提取纯文本正文
+ * maildrop 的 data 字段返回完整 MIME 源码，需要解析出 text/plain 部分
+ */
+function extractTextFromMime(raw) {
+    if (!raw)
+        return '';
+    /* 分离邮件头和正文（双换行分隔） */
+    const headerBodySplit = raw.indexOf('\r\n\r\n');
+    if (headerBodySplit === -1)
+        return raw;
+    const headers = raw.substring(0, headerBodySplit);
+    const body = raw.substring(headerBodySplit + 4);
+    /* 检查是否为 multipart 邮件 */
+    const boundaryMatch = headers.match(/boundary="?([^";\r\n]+)"?/i);
+    if (boundaryMatch) {
+        const boundary = boundaryMatch[1];
+        const parts = body.split('--' + boundary);
+        for (const part of parts) {
+            /* 查找 text/plain 部分 */
+            if (part.match(/Content-Type:\s*text\/plain/i)) {
+                const partHeaderEnd = part.indexOf('\r\n\r\n');
+                if (partHeaderEnd === -1)
+                    continue;
+                const partHeaders = part.substring(0, partHeaderEnd);
+                let content = part.substring(partHeaderEnd + 4).replace(/\r\n$/, '').replace(/--$/, '').trim();
+                /* 处理 Content-Transfer-Encoding */
+                if (partHeaders.match(/Content-Transfer-Encoding:\s*base64/i)) {
+                    try {
+                        content = Buffer.from(content.replace(/\s/g, ''), 'base64').toString('utf-8');
+                    }
+                    catch { /* 解码失败则保留原文 */ }
+                }
+                else if (partHeaders.match(/Content-Transfer-Encoding:\s*quoted-printable/i)) {
+                    content = content
+                        .replace(/=\r?\n/g, '')
+                        .replace(/=([0-9A-Fa-f]{2})/g, (_, hex) => String.fromCharCode(parseInt(hex, 16)));
+                }
+                return content.trim();
+            }
+        }
+    }
+    /* 非 multipart：检查整体编码 */
+    if (headers.match(/Content-Transfer-Encoding:\s*base64/i)) {
+        try {
+            return Buffer.from(body.replace(/\s/g, ''), 'base64').toString('utf-8').trim();
+        }
+        catch { /* 解码失败 */ }
+    }
+    return body.trim();
+}
+/**
+ * 生成随机用户名
+ */
+function randomUsername(length = 10) {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+}
+/**
+ * 发送 GraphQL 请求
+ * 使用 operationName + variables 的标准 GraphQL 格式
+ */
+async function graphqlRequest(operationName, query, variables = {}) {
+    const response = await fetch(GRAPHQL_URL, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'Origin': 'https://maildrop.cc',
+            'Referer': 'https://maildrop.cc/',
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',
+        },
+        body: JSON.stringify({ operationName, variables, query }),
+    });
+    if (!response.ok) {
+        throw new Error(`Maildrop GraphQL request failed: ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.errors && data.errors.length > 0) {
+        throw new Error(`Maildrop GraphQL error: ${data.errors[0].message}`);
+    }
+    return data.data;
+}
+/**
+ * 创建临时邮箱
+ * Maildrop 无需注册，任意用户名即可接收邮件
+ */
+async function generateEmail() {
+    const username = randomUsername();
+    const email = `${username}@${DOMAIN}`;
+    /* 验证邮箱可用：查询一次 inbox 确认 API 正常 */
+    await graphqlRequest('GetInbox', 'query GetInbox($mailbox: String!) { inbox(mailbox: $mailbox) { id } }', { mailbox: username });
+    return {
+        channel: CHANNEL,
+        email,
+        token: username,
+    };
+}
+/**
+ * 获取邮件列表
+ * 先查 inbox 获取邮件 ID 列表，再逐封获取完整内容
+ */
+async function getEmails(token, email) {
+    const mailbox = token || email.split('@')[0];
+    /* 查询收件箱列表 */
+    const inboxData = await graphqlRequest('GetInbox', 'query GetInbox($mailbox: String!) { inbox(mailbox: $mailbox) { id headerfrom subject date } }', { mailbox });
+    const inbox = inboxData?.inbox;
+    if (!Array.isArray(inbox) || inbox.length === 0) {
+        return [];
+    }
+    /* 逐封获取完整邮件内容 */
+    const emails = [];
+    for (const item of inbox) {
+        try {
+            const msgData = await graphqlRequest('GetMessage', 'query GetMessage($mailbox: String!, $id: String!) { message(mailbox: $mailbox, id: $id) { id headerfrom subject date data html } }', { mailbox, id: item.id });
+            const msg = msgData?.message;
+            if (msg) {
+                emails.push({
+                    id: msg.id || item.id,
+                    from: decodeRfc2047(msg.headerfrom || item.headerfrom || ''),
+                    to: email,
+                    subject: decodeRfc2047(msg.subject || item.subject || ''),
+                    text: extractTextFromMime(msg.data || ''),
+                    html: msg.html || '',
+                    date: msg.date || item.date || '',
+                    isRead: false,
+                    attachments: [],
+                });
+            }
+        }
+        catch {
+            /* 单封邮件获取失败不影响整体 */
+        }
+    }
+    return emails;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"maildrop.js","sourceRoot":"","sources":["../../src/providers/maildrop.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Maildrop 渠道实现\n * API: GraphQL endpoint https://api.maildrop.cc/graphql\n * \n * 特点:\n * - 无需认证，公开 GraphQL API\n * - 自带反垃圾过滤\n * - 邮箱名即用户名（任意字符串@maildrop.cc）\n * - 无过期时间限制\n */\n\nimport { InternalEmailInfo, Email, Channel } from '../types';\n\nconst CHANNEL: Channel = 'maildrop';\nconst GRAPHQL_URL = 'https://api.maildrop.cc/graphql';\nconst DOMAIN = 'maildrop.cc';\n\n/**\n * 解码 RFC 2047 编码的邮件头（如发件人、主题）\n * 支持 Base64 (B) 和 Quoted-Printable (Q) 编码\n */\nfunction decodeRfc2047(str: string): string {\n  if (!str) return '';\n  return str.replace(/=\\?([^?]+)\\?(B|Q)\\?([^?]*)\\?=/gi, (_, charset, encoding, encoded) => {\n    try {\n      if (encoding.toUpperCase() === 'B') {\n        return Buffer.from(encoded, 'base64').toString('utf-8');\n      }\n      /* Quoted-Printable: _=空格，=XX=十六进制字节 */\n      const decoded = encoded\n        .replace(/_/g, ' ')\n        .replace(/=([0-9A-Fa-f]{2})/g, (_m: string, hex: string) => String.fromCharCode(parseInt(hex, 16)));\n      return decoded;\n    } catch {\n      return encoded;\n    }\n  });\n}\n\n/**\n * 从原始 MIME 邮件源码中提取纯文本正文\n * maildrop 的 data 字段返回完整 MIME 源码，需要解析出 text/plain 部分\n */\nfunction extractTextFromMime(raw: string): string {\n  if (!raw) return '';\n\n  /* 分离邮件头和正文（双换行分隔） */\n  const headerBodySplit = raw.indexOf('\\r\\n\\r\\n');\n  if (headerBodySplit === -1) return raw;\n\n  const headers = raw.substring(0, headerBodySplit);\n  const body = raw.substring(headerBodySplit + 4);\n\n  /* 检查是否为 multipart 邮件 */\n  const boundaryMatch = headers.match(/boundary=\"?([^\";\\r\\n]+)\"?/i);\n  if (boundaryMatch) {\n    const boundary = boundaryMatch[1];\n    const parts = body.split('--' + boundary);\n\n    for (const part of parts) {\n      /* 查找 text/plain 部分 */\n      if (part.match(/Content-Type:\\s*text\\/plain/i)) {\n        const partHeaderEnd = part.indexOf('\\r\\n\\r\\n');\n        if (partHeaderEnd === -1) continue;\n\n        const partHeaders = part.substring(0, partHeaderEnd);\n        let content = part.substring(partHeaderEnd + 4).replace(/\\r\\n$/, '').replace(/--$/, '').trim();\n\n        /* 处理 Content-Transfer-Encoding */\n        if (partHeaders.match(/Content-Transfer-Encoding:\\s*base64/i)) {\n          try {\n            content = Buffer.from(content.replace(/\\s/g, ''), 'base64').toString('utf-8');\n          } catch { /* 解码失败则保留原文 */ }\n        } else if (partHeaders.match(/Content-Transfer-Encoding:\\s*quoted-printable/i)) {\n          content = content\n            .replace(/=\\r?\\n/g, '')\n            .replace(/=([0-9A-Fa-f]{2})/g, (_, hex: string) => String.fromCharCode(parseInt(hex, 16)));\n        }\n\n        return content.trim();\n      }\n    }\n  }\n\n  /* 非 multipart：检查整体编码 */\n  if (headers.match(/Content-Transfer-Encoding:\\s*base64/i)) {\n    try {\n      return Buffer.from(body.replace(/\\s/g, ''), 'base64').toString('utf-8').trim();\n    } catch { /* 解码失败 */ }\n  }\n\n  return body.trim();\n}\n\n/**\n * 生成随机用户名\n */\nfunction randomUsername(length: number = 10): string {\n  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';\n  let result = '';\n  for (let i = 0; i < length; i++) {\n    result += chars.charAt(Math.floor(Math.random() * chars.length));\n  }\n  return result;\n}\n\n/**\n * 发送 GraphQL 请求\n * 使用 operationName + variables 的标准 GraphQL 格式\n */\nasync function graphqlRequest(\n  operationName: string,\n  query: string,\n  variables: Record<string, string> = {},\n): Promise<any> {\n  const response = await fetch(GRAPHQL_URL, {\n    method: 'POST',\n    headers: {\n      'Content-Type': 'application/json',\n      'Origin': 'https://maildrop.cc',\n      'Referer': 'https://maildrop.cc/',\n      'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36',\n    },\n    body: JSON.stringify({ operationName, variables, query }),\n  });\n\n  if (!response.ok) {\n    throw new Error(`Maildrop GraphQL request failed: ${response.status}`);\n  }\n\n  const data = await response.json();\n  if (data.errors && data.errors.length > 0) {\n    throw new Error(`Maildrop GraphQL error: ${data.errors[0].message}`);\n  }\n\n  return data.data;\n}\n\n/**\n * 创建临时邮箱\n * Maildrop 无需注册，任意用户名即可接收邮件\n */\nexport async function generateEmail(): Promise<InternalEmailInfo> {\n  const username = randomUsername();\n  const email = `${username}@${DOMAIN}`;\n\n  /* 验证邮箱可用：查询一次 inbox 确认 API 正常 */\n  await graphqlRequest(\n    'GetInbox',\n    'query GetInbox($mailbox: String!) { inbox(mailbox: $mailbox) { id } }',\n    { mailbox: username },\n  );\n\n  return {\n    channel: CHANNEL,\n    email,\n    token: username,\n  };\n}\n\n/**\n * 获取邮件列表\n * 先查 inbox 获取邮件 ID 列表，再逐封获取完整内容\n */\nexport async function getEmails(token: string, email: string): Promise<Email[]> {\n  const mailbox = token || email.split('@')[0];\n\n  /* 查询收件箱列表 */\n  const inboxData = await graphqlRequest(\n    'GetInbox',\n    'query GetInbox($mailbox: String!) { inbox(mailbox: $mailbox) { id headerfrom subject date } }',\n    { mailbox },\n  );\n\n  const inbox = inboxData?.inbox;\n  if (!Array.isArray(inbox) || inbox.length === 0) {\n    return [];\n  }\n\n  /* 逐封获取完整邮件内容 */\n  const emails: Email[] = [];\n  for (const item of inbox) {\n    try {\n      const msgData = await graphqlRequest(\n        'GetMessage',\n        'query GetMessage($mailbox: String!, $id: String!) { message(mailbox: $mailbox, id: $id) { id headerfrom subject date data html } }',\n        { mailbox, id: item.id },\n      );\n\n      const msg = msgData?.message;\n      if (msg) {\n        emails.push({\n          id: msg.id || item.id,\n          from: decodeRfc2047(msg.headerfrom || item.headerfrom || ''),\n          to: email,\n          subject: decodeRfc2047(msg.subject || item.subject || ''),\n          text: extractTextFromMime(msg.data || ''),\n          html: msg.html || '',\n          date: msg.date || item.date || '',\n          isRead: false,\n          attachments: [],\n        });\n      }\n    } catch {\n      /* 单封邮件获取失败不影响整体 */\n    }\n  }\n\n  return emails;\n}\n"]}

package/dist/providers/temp-mail-io.d.ts

@@ -1,10 +1,10 @@
-import { EmailInfo, Email } from '../types';
+import { InternalEmailInfo, Email } from '../types';
 /**
  * 创建临时邮箱
  * API: POST /api/v3/email/new
  * 返回: { email, token }
  */
-export declare function generateEmail(): Promise<EmailInfo>;
+export declare function generateEmail(): Promise<InternalEmailInfo>;
 /**
  * 获取邮件列表
  * API: GET /api/v3/email/{email}/messages

package/dist/providers/temp-mail-io.js

@@ -96,4 +96,4 @@ async function getEmails(email) {
     const rawEmails = Array.isArray(data) ? data : [];
     return rawEmails.map((raw) => (0, normalize_1.normalizeEmail)(raw, email));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/tempmail-la.d.ts

@@ -1,10 +1,10 @@
-import { EmailInfo, Email } from '../types';
+import { InternalEmailInfo, Email } from '../types';
 /**
  * 创建临时邮箱
  * API: POST /api/mail/create
  * 返回: { code: 0, data: { mailId, address, type, startAt, endAt } }
  */
-export declare function generateEmail(): Promise<EmailInfo>;
+export declare function generateEmail(): Promise<InternalEmailInfo>;
 /**
  * 获取邮件列表
  * API: POST /api/mail/box

package/dist/providers/tempmail-la.js

@@ -86,4 +86,4 @@ async function getEmails(email) {
     }
     return allEmails.map((raw) => (0, normalize_1.normalizeEmail)(raw, email));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/tempmail-lol.d.ts

@@ -1,3 +1,3 @@
-import { EmailInfo, Email } from '../types';
-export declare function generateEmail(domain?: string | null): Promise<EmailInfo>;
+import { InternalEmailInfo, Email } from '../types';
+export declare function generateEmail(domain?: string | null): Promise<InternalEmailInfo>;
 export declare function getEmails(token: string, recipientEmail?: string): Promise<Email[]>;

package/dist/providers/tempmail-lol.js

@@ -45,4 +45,4 @@ async function getEmails(token, recipientEmail = '') {
     const rawEmails = data.emails || [];
     return rawEmails.map((raw) => (0, normalize_1.normalizeEmail)(raw, recipientEmail));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/tempmail.d.ts

@@ -1,3 +1,3 @@
-import { EmailInfo, Email } from '../types';
-export declare function generateEmail(duration?: number): Promise<EmailInfo>;
+import { InternalEmailInfo, Email } from '../types';
+export declare function generateEmail(duration?: number): Promise<InternalEmailInfo>;
 export declare function getEmails(email: string): Promise<Email[]>;