tempmail-sdk 1.0.2 → 1.1.0

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 { EmailInfo, 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<EmailInfo> {\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.js

@@ -5,34 +5,64 @@ exports.getEmails = getEmails;
 const normalize_1 = require("../normalize");
 const CHANNEL = 'temp-mail-io';
 const BASE_URL = 'https://api.internal.temp-mail.io/api/v3';
-const DEFAULT_HEADERS = {
-    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0',
-    'Content-Type': 'application/json',
-    'accept-language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',
-    'application-name': 'web',
-    'application-version': '4.0.0',
-    'cache-control': 'no-cache',
-    'dnt': '1',
-    'origin': 'https://temp-mail.io',
-    'pragma': 'no-cache',
-    'referer': 'https://temp-mail.io/',
-    'sec-ch-ua': '"Not(A:Brand";v="8", "Chromium";v="144", "Microsoft Edge";v="144"',
-    'sec-ch-ua-mobile': '?0',
-    'sec-ch-ua-platform': '"Windows"',
-    'sec-fetch-dest': 'empty',
-    'sec-fetch-mode': 'cors',
-    'sec-fetch-site': 'same-site',
-};
+const PAGE_URL = 'https://temp-mail.io/en';
+/**
+ * 缓存从页面动态获取的 mobileTestingHeader 值（用于 X-CORS-Header）
+ */
+let cachedCorsHeader = null;
+/**
+ * 从 temp-mail.io 页面的 __NUXT__ 运行时配置中提取 mobileTestingHeader
+ * 该值用于 API 请求的 X-CORS-Header 头，缺少此头会导致 400 错误
+ */
+async function fetchCorsHeader() {
+    if (cachedCorsHeader)
+        return cachedCorsHeader;
+    try {
+        const response = await fetch(PAGE_URL, {
+            headers: {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36',
+            },
+        });
+        const html = await response.text();
+        const match = html.match(/mobileTestingHeader\s*:\s*"([^"]+)"/);
+        if (match) {
+            cachedCorsHeader = match[1];
+            return cachedCorsHeader;
+        }
+    }
+    catch {
+        /* 提取失败时使用默认值 */
+    }
+    cachedCorsHeader = '1';
+    return cachedCorsHeader;
+}
+/**
+ * 构建 API 请求头
+ * 关键头: Content-Type, Application-Name, Application-Version, X-CORS-Header
+ */
+async function getApiHeaders() {
+    const corsHeader = await fetchCorsHeader();
+    return {
+        'Content-Type': 'application/json',
+        'Application-Name': 'web',
+        'Application-Version': '4.0.0',
+        'X-CORS-Header': corsHeader,
+        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/144.0.0.0 Safari/537.36 Edg/144.0.0.0',
+        'origin': 'https://temp-mail.io',
+        'referer': 'https://temp-mail.io/',
+    };
+}
 /**
  * 创建临时邮箱
  * API: POST /api/v3/email/new
  * 返回: { email, token }
  */
 async function generateEmail() {
+    const headers = await getApiHeaders();
     const response = await fetch(`${BASE_URL}/email/new`, {
         method: 'POST',
-        headers: DEFAULT_HEADERS,
-        body: JSON.stringify({ min_name_length: 100, max_name_length: 100 }),
+        headers,
+        body: JSON.stringify({ min_name_length: 10, max_name_length: 10 }),
     });
     if (!response.ok) {
         throw new Error(`Failed to generate email: ${response.status}`);
@@ -53,10 +83,10 @@ async function generateEmail() {
  * 返回: [ { id, from, to, cc, subject, body_text, body_html, created_at, attachments } ]
  */
 async function getEmails(email) {
-    const encodedEmail = encodeURIComponent(email);
-    const response = await fetch(`${BASE_URL}/email/${encodedEmail}/messages`, {
+    const headers = await getApiHeaders();
+    const response = await fetch(`${BASE_URL}/email/${email}/messages`, {
         method: 'GET',
-        headers: DEFAULT_HEADERS,
+        headers,
     });
     if (!response.ok) {
         throw new Error(`Failed to get emails: ${response.status}`);
@@ -66,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/retry.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 通用重试工具
+ * 提供请求重试、超时控制、指数退避等错误恢复机制
+ */
+/**
+ * 重试配置选项
+ */
+export interface RetryOptions {
+    /** 最大重试次数（不含首次请求），默认 2 */
+    maxRetries?: number;
+    /** 初始重试延迟（毫秒），默认 1000 */
+    initialDelay?: number;
+    /** 最大重试延迟（毫秒），默认 5000 */
+    maxDelay?: number;
+    /** 请求超时时间（毫秒），默认 15000 */
+    timeout?: number;
+    /** 是否对该错误进行重试的判断函数 */
+    shouldRetry?: (error: any) => boolean;
+}
+/**
+ * 带重试的异步操作执行器
+ * - 自动重试可恢复的错误（网络错误、超时、5xx）
+ * - 指数退避避免过度请求
+ * - 不可恢复的错误（4xx 参数错误等）直接抛出不重试
+ *
+ * @param fn 要执行的异步操作
+ * @param options 重试配置
+ */
+export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
+/**
+ * 带超时控制的 fetch 包装
+ * 在原生 fetch 基础上添加超时中断能力
+ *
+ * @param url 请求 URL
+ * @param init fetch 选项
+ * @param timeoutMs 超时时间（毫秒）
+ */
+export declare function fetchWithTimeout(url: string, init?: RequestInit, timeoutMs?: number): Promise<Response>;

package/dist/retry.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * 通用重试工具
+ * 提供请求重试、超时控制、指数退避等错误恢复机制
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRetry = withRetry;
+exports.fetchWithTimeout = fetchWithTimeout;
+const logger_1 = require("./logger");
+const DEFAULT_RETRY_OPTIONS = {
+    maxRetries: 2,
+    initialDelay: 1000,
+    maxDelay: 5000,
+    timeout: 15000,
+    shouldRetry: defaultShouldRetry,
+};
+/**
+ * 默认重试判断
+ * 网络错误、超时、HTTP 4xx/5xx 错误均可重试
+ * 仅参数校验类错误（由 SDK 内部抛出）不重试
+ */
+function defaultShouldRetry(error) {
+    if (!error)
+        return false;
+    const message = String(error.message || error || '').toLowerCase();
+    /* 网络级别错误 → 重试 */
+    if (message.includes('fetch failed') ||
+        message.includes('network') ||
+        message.includes('econnrefused') ||
+        message.includes('econnreset') ||
+        message.includes('etimedout') ||
+        message.includes('timeout') ||
+        message.includes('socket hang up') ||
+        message.includes('dns') ||
+        message.includes('abort')) {
+        return true;
+    }
+    /* HTTP 4xx/5xx 错误 → 重试 */
+    const statusMatch = message.match(/:\s*(\d{3})/);
+    if (statusMatch) {
+        const status = parseInt(statusMatch[1], 10);
+        return status >= 400;
+    }
+    return false;
+}
+/**
+ * 休眠指定毫秒
+ */
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+/**
+ * 带重试的异步操作执行器
+ * - 自动重试可恢复的错误（网络错误、超时、5xx）
+ * - 指数退避避免过度请求
+ * - 不可恢复的错误（4xx 参数错误等）直接抛出不重试
+ *
+ * @param fn 要执行的异步操作
+ * @param options 重试配置
+ */
+async function withRetry(fn, options) {
+    const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
+    let lastError;
+    for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+        try {
+            const result = await fn();
+            if (attempt > 0) {
+                logger_1.logger.info(`第 ${attempt + 1} 次尝试成功`);
+            }
+            return result;
+        }
+        catch (error) {
+            lastError = error;
+            const errorMsg = error.message || String(error);
+            /* 最后一次尝试失败或不可重试的错误 → 直接抛出 */
+            if (attempt >= opts.maxRetries || !opts.shouldRetry(error)) {
+                if (attempt >= opts.maxRetries && opts.maxRetries > 0) {
+                    logger_1.logger.error(`重试 ${opts.maxRetries} 次后仍失败: ${errorMsg}`);
+                }
+                else if (!opts.shouldRetry(error)) {
+                    logger_1.logger.debug(`不可重试的错误: ${errorMsg}`);
+                }
+                throw error;
+            }
+            /* 指数退避等待 */
+            const delay = Math.min(opts.initialDelay * Math.pow(2, attempt), opts.maxDelay);
+            logger_1.logger.warn(`请求失败 (${errorMsg})，${delay}ms 后第 ${attempt + 2} 次重试...`);
+            await sleep(delay);
+        }
+    }
+    throw lastError;
+}
+/**
+ * 带超时控制的 fetch 包装
+ * 在原生 fetch 基础上添加超时中断能力
+ *
+ * @param url 请求 URL
+ * @param init fetch 选项
+ * @param timeoutMs 超时时间（毫秒）
+ */
+async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_RETRY_OPTIONS.timeout) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const response = await fetch(url, {
+            ...init,
+            signal: controller.signal,
+        });
+        return response;
+    }
+    catch (error) {
+        if (error.name === 'AbortError') {
+            throw new Error(`Request timeout after ${timeoutMs}ms: ${url}`);
+        }
+        throw error;
+    }
+    finally {
+        clearTimeout(timeoutId);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"retry.js","sourceRoot":"","sources":["../src/retry.ts"],"names":[],"mappings":";AAAA;;;GAGG;;AA6EH,8BAiCC;AAUD,4CAsBC;AA5ID,qCAAkC;AAkBlC,MAAM,qBAAqB,GAA2B;IACpD,UAAU,EAAE,CAAC;IACb,YAAY,EAAE,IAAI;IAClB,QAAQ,EAAE,IAAI;IACd,OAAO,EAAE,KAAK;IACd,WAAW,EAAE,kBAAkB;CAChC,CAAC;AAEF;;;;GAIG;AACH,SAAS,kBAAkB,CAAC,KAAU;IACpC,IAAI,CAAC,KAAK;QAAE,OAAO,KAAK,CAAC;IAEzB,MAAM,OAAO,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,IAAI,KAAK,IAAI,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC;IAEnE,iBAAiB;IACjB,IAAI,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;QAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;QAC3B,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAC;QAChC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAC;QAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAC;QAC7B,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAC;QAC3B,OAAO,CAAC,QAAQ,CAAC,gBAAgB,CAAC;QAClC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAC;QACvB,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QAC9B,OAAO,IAAI,CAAC;IACd,CAAC;IAED,0BAA0B;IAC1B,MAAM,WAAW,GAAG,OAAO,CAAC,KAAK,CAAC,aAAa,CAAC,CAAC;IACjD,IAAI,WAAW,EAAE,CAAC;QAChB,MAAM,MAAM,GAAG,QAAQ,CAAC,WAAW,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;QAC5C,OAAO,MAAM,IAAI,GAAG,CAAC;IACvB,CAAC;IAED,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;GAEG;AACH,SAAS,KAAK,CAAC,EAAU;IACvB,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAC,CAAC;AACzD,CAAC;AAED;;;;;;;;GAQG;AACI,KAAK,UAAU,SAAS,CAAI,EAAoB,EAAE,OAAsB;IAC7E,MAAM,IAAI,GAAG,EAAE,GAAG,qBAAqB,EAAE,GAAG,OAAO,EAAE,CAAC;IACtD,IAAI,SAAc,CAAC;IAEnB,KAAK,IAAI,OAAO,GAAG,CAAC,EAAE,OAAO,IAAI,IAAI,CAAC,UAAU,EAAE,OAAO,EAAE,EAAE,CAAC;QAC5D,IAAI,CAAC;YACH,MAAM,MAAM,GAAG,MAAM,EAAE,EAAE,CAAC;YAC1B,IAAI,OAAO,GAAG,CAAC,EAAE,CAAC;gBAChB,eAAM,CAAC,IAAI,CAAC,KAAK,OAAO,GAAG,CAAC,QAAQ,CAAC,CAAC;YACxC,CAAC;YACD,OAAO,MAAM,CAAC;QAChB,CAAC;QAAC,OAAO,KAAU,EAAE,CAAC;YACpB,SAAS,GAAG,KAAK,CAAC;YAClB,MAAM,QAAQ,GAAG,KAAK,CAAC,OAAO,IAAI,MAAM,CAAC,KAAK,CAAC,CAAC;YAEhD,6BAA6B;YAC7B,IAAI,OAAO,IAAI,IAAI,CAAC,UAAU,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3D,IAAI,OAAO,IAAI,IAAI,CAAC,UAAU,IAAI,IAAI,CAAC,UAAU,GAAG,CAAC,EAAE,CAAC;oBACtD,eAAM,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,UAAU,WAAW,QAAQ,EAAE,CAAC,CAAC;gBAC3D,CAAC;qBAAM,IAAI,CAAC,IAAI,CAAC,WAAW,CAAC,KAAK,CAAC,EAAE,CAAC;oBACpC,eAAM,CAAC,KAAK,CAAC,YAAY,QAAQ,EAAE,CAAC,CAAC;gBACvC,CAAC;gBACD,MAAM,KAAK,CAAC;YACd,CAAC;YAED,YAAY;YACZ,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,YAAY,GAAG,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,QAAQ,CAAC,CAAC;YAChF,eAAM,CAAC,IAAI,CAAC,SAAS,QAAQ,KAAK,KAAK,SAAS,OAAO,GAAG,CAAC,SAAS,CAAC,CAAC;YACtE,MAAM,KAAK,CAAC,KAAK,CAAC,CAAC;QACrB,CAAC;IACH,CAAC;IAED,MAAM,SAAS,CAAC;AAClB,CAAC;AAED;;;;;;;GAOG;AACI,KAAK,UAAU,gBAAgB,CACpC,GAAW,EACX,IAAkB,EAClB,YAAoB,qBAAqB,CAAC,OAAO;IAEjD,MAAM,UAAU,GAAG,IAAI,eAAe,EAAE,CAAC;IACzC,MAAM,SAAS,GAAG,UAAU,CAAC,GAAG,EAAE,CAAC,UAAU,CAAC,KAAK,EAAE,EAAE,SAAS,CAAC,CAAC;IAElE,IAAI,CAAC;QACH,MAAM,QAAQ,GAAG,MAAM,KAAK,CAAC,GAAG,EAAE;YAChC,GAAG,IAAI;YACP,MAAM,EAAE,UAAU,CAAC,MAAM;SAC1B,CAAC,CAAC;QACH,OAAO,QAAQ,CAAC;IAClB,CAAC;IAAC,OAAO,KAAU,EAAE,CAAC;QACpB,IAAI,KAAK,CAAC,IAAI,KAAK,YAAY,EAAE,CAAC;YAChC,MAAM,IAAI,KAAK,CAAC,yBAAyB,SAAS,OAAO,GAAG,EAAE,CAAC,CAAC;QAClE,CAAC;QACD,MAAM,KAAK,CAAC;IACd,CAAC;YAAS,CAAC;QACT,YAAY,CAAC,SAAS,CAAC,CAAC;IAC1B,CAAC;AACH,CAAC","sourcesContent":["/**\n * 通用重试工具\n * 提供请求重试、超时控制、指数退避等错误恢复机制\n */\n\nimport { logger } from './logger';\n\n/**\n * 重试配置选项\n */\nexport interface RetryOptions {\n  /** 最大重试次数（不含首次请求），默认 2 */\n  maxRetries?: number;\n  /** 初始重试延迟（毫秒），默认 1000 */\n  initialDelay?: number;\n  /** 最大重试延迟（毫秒），默认 5000 */\n  maxDelay?: number;\n  /** 请求超时时间（毫秒），默认 15000 */\n  timeout?: number;\n  /** 是否对该错误进行重试的判断函数 */\n  shouldRetry?: (error: any) => boolean;\n}\n\nconst DEFAULT_RETRY_OPTIONS: Required<RetryOptions> = {\n  maxRetries: 2,\n  initialDelay: 1000,\n  maxDelay: 5000,\n  timeout: 15000,\n  shouldRetry: defaultShouldRetry,\n};\n\n/**\n * 默认重试判断\n * 网络错误、超时、HTTP 4xx/5xx 错误均可重试\n * 仅参数校验类错误（由 SDK 内部抛出）不重试\n */\nfunction defaultShouldRetry(error: any): boolean {\n  if (!error) return false;\n\n  const message = String(error.message || error || '').toLowerCase();\n\n  /* 网络级别错误 → 重试 */\n  if (message.includes('fetch failed') ||\n      message.includes('network') ||\n      message.includes('econnrefused') ||\n      message.includes('econnreset') ||\n      message.includes('etimedout') ||\n      message.includes('timeout') ||\n      message.includes('socket hang up') ||\n      message.includes('dns') ||\n      message.includes('abort')) {\n    return true;\n  }\n\n  /* HTTP 4xx/5xx 错误 → 重试 */\n  const statusMatch = message.match(/:\\s*(\\d{3})/);\n  if (statusMatch) {\n    const status = parseInt(statusMatch[1], 10);\n    return status >= 400;\n  }\n\n  return false;\n}\n\n/**\n * 休眠指定毫秒\n */\nfunction sleep(ms: number): Promise<void> {\n  return new Promise(resolve => setTimeout(resolve, ms));\n}\n\n/**\n * 带重试的异步操作执行器\n * - 自动重试可恢复的错误（网络错误、超时、5xx）\n * - 指数退避避免过度请求\n * - 不可恢复的错误（4xx 参数错误等）直接抛出不重试\n *\n * @param fn 要执行的异步操作\n * @param options 重试配置\n */\nexport async function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T> {\n  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };\n  let lastError: any;\n\n  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {\n    try {\n      const result = await fn();\n      if (attempt > 0) {\n        logger.info(`第 ${attempt + 1} 次尝试成功`);\n      }\n      return result;\n    } catch (error: any) {\n      lastError = error;\n      const errorMsg = error.message || String(error);\n\n      /* 最后一次尝试失败或不可重试的错误 → 直接抛出 */\n      if (attempt >= opts.maxRetries || !opts.shouldRetry(error)) {\n        if (attempt >= opts.maxRetries && opts.maxRetries > 0) {\n          logger.error(`重试 ${opts.maxRetries} 次后仍失败: ${errorMsg}`);\n        } else if (!opts.shouldRetry(error)) {\n          logger.debug(`不可重试的错误: ${errorMsg}`);\n        }\n        throw error;\n      }\n\n      /* 指数退避等待 */\n      const delay = Math.min(opts.initialDelay * Math.pow(2, attempt), opts.maxDelay);\n      logger.warn(`请求失败 (${errorMsg})，${delay}ms 后第 ${attempt + 2} 次重试...`);\n      await sleep(delay);\n    }\n  }\n\n  throw lastError;\n}\n\n/**\n * 带超时控制的 fetch 包装\n * 在原生 fetch 基础上添加超时中断能力\n *\n * @param url 请求 URL\n * @param init fetch 选项\n * @param timeoutMs 超时时间（毫秒）\n */\nexport async function fetchWithTimeout(\n  url: string,\n  init?: RequestInit,\n  timeoutMs: number = DEFAULT_RETRY_OPTIONS.timeout,\n): Promise<Response> {\n  const controller = new AbortController();\n  const timeoutId = setTimeout(() => controller.abort(), timeoutMs);\n\n  try {\n    const response = await fetch(url, {\n      ...init,\n      signal: controller.signal,\n    });\n    return response;\n  } catch (error: any) {\n    if (error.name === 'AbortError') {\n      throw new Error(`Request timeout after ${timeoutMs}ms: ${url}`);\n    }\n    throw error;\n  } finally {\n    clearTimeout(timeoutId);\n  }\n}\n"]}

package/dist/types.d.ts

@@ -1,18 +1,36 @@
-export type Channel = 'tempmail' | 'linshi-email' | 'tempmail-lol' | 'chatgpt-org-uk' | 'tempmail-la' | 'temp-mail-io' | 'awamail' | 'mail-tm' | 'dropmail';
+/**
+ * 支持的临时邮箱渠道标识
+ * 每个渠道对应一个第三方临时邮箱服务商
+ */
+export type Channel = 'tempmail' | 'linshi-email' | 'tempmail-lol' | 'chatgpt-org-uk' | 'tempmail-la' | 'temp-mail-io' | 'awamail' | 'mail-tm' | 'dropmail' | 'guerrillamail' | 'maildrop';
+/**
+ * 创建临时邮箱后返回的邮箱信息
+ * 包含邮箱地址、认证令牌和生命周期信息
+ */
 export interface EmailInfo {
+    /** 创建该邮箱所使用的渠道 */
     channel: Channel;
+    /** 临时邮箱地址 */
     email: string;
+    /** 认证令牌，部分渠道在获取邮件时需要此令牌 */
     token?: string;
+    /** 邮箱过期时间（ISO 8601 字符串或 Unix 时间戳） */
     expiresAt?: string | number;
+    /** 邮箱创建时间（ISO 8601 字符串） */
     createdAt?: string;
 }
 /**
  * 标准化邮件附件
+ * 不同渠道的附件字段名不同，SDK 统一归一化为此结构
  */
 export interface EmailAttachment {
+    /** 附件文件名 */
     filename: string;
+    /** 附件大小（字节） */
     size?: number;
+    /** MIME 类型，如 application/pdf */
     contentType?: string;
+    /** 附件下载地址 */
     url?: string;
 }
 /**
@@ -38,19 +56,88 @@ export interface Email {
     /** 附件列表 */
     attachments: EmailAttachment[];
 }
+/**
+ * 获取邮件列表的返回结果
+ * success 为 false 时表示请求失败（重试耗尽），emails 为空数组
+ */
 export interface GetEmailsResult {
+    /** 所使用的渠道 */
     channel: Channel;
+    /** 查询的邮箱地址 */
     email: string;
+    /** 邮件列表，失败时为空数组 */
     emails: Email[];
+    /** 请求是否成功，false 表示重试耗尽后仍失败 */
     success: boolean;
 }
+/**
+ * 重试配置
+ * SDK 内部对网络错误、超时、5xx 服务端错误自动重试
+ * 4xx 客户端错误（如参数错误）不会重试
+ *
+ * @example
+ * ```ts
+ * // 自定义重试策略：最多重试 3 次，首次延迟 2 秒
+ * const email = await generateEmail({
+ *   channel: 'mail-tm',
+ *   retry: { maxRetries: 3, initialDelay: 2000 },
+ * });
+ * ```
+ */
+export interface RetryConfig {
+    /** 最大重试次数（不含首次请求），默认 2 */
+    maxRetries?: number;
+    /** 初始重试延迟（毫秒），采用指数退避策略，默认 1000 */
+    initialDelay?: number;
+    /** 最大重试延迟上限（毫秒），默认 5000 */
+    maxDelay?: number;
+    /** 单次请求超时时间（毫秒），默认 15000 */
+    timeout?: number;
+}
+/**
+ * 创建临时邮箱的选项
+ *
+ * @example
+ * ```ts
+ * // 使用指定渠道创建邮箱
+ * const email = await generateEmail({ channel: 'mail-tm' });
+ *
+ * // 随机选择渠道
+ * const email = await generateEmail();
+ * ```
+ */
 export interface GenerateEmailOptions {
+    /** 指定渠道，不传则随机选择 */
     channel?: Channel;
+    /** 邮箱有效时长 */
     duration?: number;
+    /** 指定邮箱域名 */
     domain?: string | null;
+    /** 重试配置，不传则使用默认值（最多重试 2 次） */
+    retry?: RetryConfig;
 }
+/**
+ * 获取邮件列表的选项
+ *
+ * @example
+ * ```ts
+ * const result = await getEmails({
+ *   channel: emailInfo.channel,
+ *   email: emailInfo.email,
+ *   token: emailInfo.token,
+ * });
+ * if (result.success && result.emails.length > 0) {
+ *   console.log('收到邮件:', result.emails);
+ * }
+ * ```
+ */
 export interface GetEmailsOptions {
+    /** 渠道标识，必填 */
     channel: Channel;
+    /** 邮箱地址，必填 */
     email: string;
+    /** 认证令牌 */
     token?: string;
+    /** 重试配置，不传则使用默认值（最多重试 2 次） */
+    retry?: RetryConfig;
 }