tempmail-sdk 1.0.2 → 1.0.3

package/dist/normalize.js

@@ -3,6 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.normalizeEmail = normalizeEmail;
 /**
  * 将各提供商返回的原始邮件数据标准化为统一的 Email 格式
+ *
+ * 不同渠道的 API 返回字段名各不相同，此函数通过多字段候选策略
+ * 将它们统一映射为标准的 Email 结构，保证 SDK 输出一致性。
+ *
+ * @param raw - 原始邮件数据（来自不同提供商的 API 响应）
+ * @param recipientEmail - 收件人邮箱地址，当原始数据中无收件人字段时用作回退值
+ * @returns 标准化的 Email 对象
  */
 function normalizeEmail(raw, recipientEmail = '') {
     return {
@@ -17,25 +24,54 @@ function normalizeEmail(raw, recipientEmail = '') {
         attachments: normalizeAttachments(raw.attachments),
     };
 }
+/**
+ * 提取邮件 ID
+ * 候选字段: id, eid, _id, mailboxId, messageId, mail_id
+ */
 function normalizeId(raw) {
     const id = raw.id ?? raw.eid ?? raw._id ?? raw.mailboxId ?? raw.messageId ?? raw.mail_id ?? '';
     return String(id);
 }
+/**
+ * 提取发件人地址
+ * 候选字段: from_address, address_from, from, messageFrom, sender
+ */
 function normalizeFrom(raw) {
     return raw.from_address || raw.address_from || raw.from || raw.messageFrom || raw.sender || '';
 }
+/**
+ * 提取收件人地址，无匹配字段时回退为 recipientEmail
+ * 候选字段: to, to_address, name_to, email_address, address
+ */
 function normalizeTo(raw, recipientEmail) {
     return raw.to || raw.to_address || raw.name_to || raw.email_address || raw.address || recipientEmail || '';
 }
+/**
+ * 提取邮件主题
+ * 候选字段: subject, e_subject
+ */
 function normalizeSubject(raw) {
     return raw.subject || raw.e_subject || '';
 }
+/**
+ * 提取纯文本内容
+ * 候选字段: text, body, content, body_text, text_content
+ */
 function normalizeText(raw) {
     return raw.text || raw.body || raw.content || raw.body_text || raw.text_content || '';
 }
+/**
+ * 提取 HTML 内容
+ * 候选字段: html, html_content, body_html
+ */
 function normalizeHtml(raw) {
     return raw.html || raw.html_content || raw.body_html || '';
 }
+/**
+ * 提取并统一日期格式为 ISO 8601
+ * 候选字段: received_at, created_at, createdAt, date, timestamp, e_date
+ * 其中 timestamp 为 Unix 秒级时间戳，需乘以 1000 转为毫秒
+ */
 function normalizeDate(raw) {
     try {
         if (raw.received_at)
@@ -55,10 +91,15 @@ function normalizeDate(raw) {
             return new Date(raw.e_date).toISOString();
     }
     catch {
-        // 日期解析失败，返回空字符串
+        /* 日期解析失败，返回空字符串 */
     }
     return '';
 }
+/**
+ * 提取已读状态
+ * 候选字段: seen, read, isRead, is_read
+ * 支持 boolean / number(0|1) / string('0'|'1') 多种类型
+ */
 function normalizeIsRead(raw) {
     if (typeof raw.seen === 'boolean')
         return raw.seen;
@@ -74,6 +115,10 @@ function normalizeIsRead(raw) {
         return raw.is_read;
     return false;
 }
+/**
+ * 提取并标准化附件列表
+ * 每个附件的字段也采用多候选策略映射
+ */
 function normalizeAttachments(attachments) {
     if (!attachments || !Array.isArray(attachments))
         return [];
@@ -84,4 +129,4 @@ function normalizeAttachments(attachments) {
         url: a.url || a.download_url || a.downloadUrl || undefined,
     }));
 }
-//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"normalize.js","sourceRoot":"","sources":["../src/normalize.ts"],"names":[],"mappings":"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","sourcesContent":["import { Email, EmailAttachment } from './types';\n\n/**\n * 将各提供商返回的原始邮件数据标准化为统一的 Email 格式\n */\nexport function normalizeEmail(raw: any, recipientEmail: string = ''): Email {\n  return {\n    id: normalizeId(raw),\n    from: normalizeFrom(raw),\n    to: normalizeTo(raw, recipientEmail),\n    subject: normalizeSubject(raw),\n    text: normalizeText(raw),\n    html: normalizeHtml(raw),\n    date: normalizeDate(raw),\n    isRead: normalizeIsRead(raw),\n    attachments: normalizeAttachments(raw.attachments),\n  };\n}\n\nfunction normalizeId(raw: any): string {\n  const id = raw.id ?? raw.eid ?? raw._id ?? raw.mailboxId ?? raw.messageId ?? raw.mail_id ?? '';\n  return String(id);\n}\n\nfunction normalizeFrom(raw: any): string {\n  return raw.from_address || raw.address_from || raw.from || raw.messageFrom || raw.sender || '';\n}\n\nfunction normalizeTo(raw: any, recipientEmail: string): string {\n  return raw.to || raw.to_address || raw.name_to || raw.email_address || raw.address || recipientEmail || '';\n}\n\nfunction normalizeSubject(raw: any): string {\n  return raw.subject || raw.e_subject || '';\n}\n\nfunction normalizeText(raw: any): string {\n  return raw.text || raw.body || raw.content || raw.body_text || raw.text_content || '';\n}\n\nfunction normalizeHtml(raw: any): string {\n  return raw.html || raw.html_content || raw.body_html || '';\n}\n\nfunction normalizeDate(raw: any): string {\n  try {\n    if (raw.received_at) return new Date(raw.received_at).toISOString();\n    if (raw.created_at) return new Date(raw.created_at).toISOString();\n    if (raw.createdAt) return new Date(raw.createdAt).toISOString();\n    if (raw.date) {\n      if (typeof raw.date === 'number') return new Date(raw.date).toISOString();\n      return new Date(raw.date).toISOString();\n    }\n    if (raw.timestamp) return new Date(raw.timestamp * 1000).toISOString();\n    if (raw.e_date) return new Date(raw.e_date).toISOString();\n  } catch {\n    // 日期解析失败，返回空字符串\n  }\n  return '';\n}\n\nfunction normalizeIsRead(raw: any): boolean {\n  if (typeof raw.seen === 'boolean') return raw.seen;\n  if (typeof raw.read === 'boolean') return raw.read;\n  if (typeof raw.isRead === 'boolean') return raw.isRead;\n  if (typeof raw.is_read === 'number') return raw.is_read === 1;\n  if (typeof raw.is_read === 'string') return raw.is_read === '1';\n  if (typeof raw.is_read === 'boolean') return raw.is_read;\n  return false;\n}\n\nfunction normalizeAttachments(attachments: any): EmailAttachment[] {\n  if (!attachments || !Array.isArray(attachments)) return [];\n  return attachments.map((a: any) => ({\n    filename: a.filename || a.name || '',\n    size: a.size || a.filesize || undefined,\n    contentType: a.contentType || a.content_type || a.mimeType || a.mime_type || undefined,\n    url: a.url || a.download_url || a.downloadUrl || undefined,\n  }));\n}\n"]}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"normalize.js","sourceRoot":"","sources":["../src/normalize.ts"],"names":[],"mappings":"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","sourcesContent":["import { Email, EmailAttachment } from './types';\n\n/**\n * 将各提供商返回的原始邮件数据标准化为统一的 Email 格式\n *\n * 不同渠道的 API 返回字段名各不相同，此函数通过多字段候选策略\n * 将它们统一映射为标准的 Email 结构，保证 SDK 输出一致性。\n *\n * @param raw - 原始邮件数据（来自不同提供商的 API 响应）\n * @param recipientEmail - 收件人邮箱地址，当原始数据中无收件人字段时用作回退值\n * @returns 标准化的 Email 对象\n */\nexport function normalizeEmail(raw: any, recipientEmail: string = ''): Email {\n  return {\n    id: normalizeId(raw),\n    from: normalizeFrom(raw),\n    to: normalizeTo(raw, recipientEmail),\n    subject: normalizeSubject(raw),\n    text: normalizeText(raw),\n    html: normalizeHtml(raw),\n    date: normalizeDate(raw),\n    isRead: normalizeIsRead(raw),\n    attachments: normalizeAttachments(raw.attachments),\n  };\n}\n\n/**\n * 提取邮件 ID\n * 候选字段: id, eid, _id, mailboxId, messageId, mail_id\n */\nfunction normalizeId(raw: any): string {\n  const id = raw.id ?? raw.eid ?? raw._id ?? raw.mailboxId ?? raw.messageId ?? raw.mail_id ?? '';\n  return String(id);\n}\n\n/**\n * 提取发件人地址\n * 候选字段: from_address, address_from, from, messageFrom, sender\n */\nfunction normalizeFrom(raw: any): string {\n  return raw.from_address || raw.address_from || raw.from || raw.messageFrom || raw.sender || '';\n}\n\n/**\n * 提取收件人地址，无匹配字段时回退为 recipientEmail\n * 候选字段: to, to_address, name_to, email_address, address\n */\nfunction normalizeTo(raw: any, recipientEmail: string): string {\n  return raw.to || raw.to_address || raw.name_to || raw.email_address || raw.address || recipientEmail || '';\n}\n\n/**\n * 提取邮件主题\n * 候选字段: subject, e_subject\n */\nfunction normalizeSubject(raw: any): string {\n  return raw.subject || raw.e_subject || '';\n}\n\n/**\n * 提取纯文本内容\n * 候选字段: text, body, content, body_text, text_content\n */\nfunction normalizeText(raw: any): string {\n  return raw.text || raw.body || raw.content || raw.body_text || raw.text_content || '';\n}\n\n/**\n * 提取 HTML 内容\n * 候选字段: html, html_content, body_html\n */\nfunction normalizeHtml(raw: any): string {\n  return raw.html || raw.html_content || raw.body_html || '';\n}\n\n/**\n * 提取并统一日期格式为 ISO 8601\n * 候选字段: received_at, created_at, createdAt, date, timestamp, e_date\n * 其中 timestamp 为 Unix 秒级时间戳，需乘以 1000 转为毫秒\n */\nfunction normalizeDate(raw: any): string {\n  try {\n    if (raw.received_at) return new Date(raw.received_at).toISOString();\n    if (raw.created_at) return new Date(raw.created_at).toISOString();\n    if (raw.createdAt) return new Date(raw.createdAt).toISOString();\n    if (raw.date) {\n      if (typeof raw.date === 'number') return new Date(raw.date).toISOString();\n      return new Date(raw.date).toISOString();\n    }\n    if (raw.timestamp) return new Date(raw.timestamp * 1000).toISOString();\n    if (raw.e_date) return new Date(raw.e_date).toISOString();\n  } catch {\n    /* 日期解析失败，返回空字符串 */\n  }\n  return '';\n}\n\n/**\n * 提取已读状态\n * 候选字段: seen, read, isRead, is_read\n * 支持 boolean / number(0|1) / string('0'|'1') 多种类型\n */\nfunction normalizeIsRead(raw: any): boolean {\n  if (typeof raw.seen === 'boolean') return raw.seen;\n  if (typeof raw.read === 'boolean') return raw.read;\n  if (typeof raw.isRead === 'boolean') return raw.isRead;\n  if (typeof raw.is_read === 'number') return raw.is_read === 1;\n  if (typeof raw.is_read === 'string') return raw.is_read === '1';\n  if (typeof raw.is_read === 'boolean') return raw.is_read;\n  return false;\n}\n\n/**\n * 提取并标准化附件列表\n * 每个附件的字段也采用多候选策略映射\n */\nfunction normalizeAttachments(attachments: any): EmailAttachment[] {\n  if (!attachments || !Array.isArray(attachments)) return [];\n  return attachments.map((a: any) => ({\n    filename: a.filename || a.name || '',\n    size: a.size || a.filesize || undefined,\n    contentType: a.contentType || a.content_type || a.mimeType || a.mime_type || undefined,\n    url: a.url || a.download_url || a.downloadUrl || undefined,\n  }));\n}\n"]}

package/dist/providers/mail-tm.js

@@ -33,7 +33,11 @@ async function getDomains() {
         throw new Error(`Failed to get domains: ${response.status}`);
     }
     const data = await response.json();
-    const members = data['hydra:member'] || [];
+    /* 兼容两种响应格式：
+     * - Accept: application/ld+json → Hydra 格式 { "hydra:member": [...] }
+     * - Accept: application/json   → 纯数组 [...]
+     */
+    const members = Array.isArray(data) ? data : (data['hydra:member'] || []);
     return members
         .filter((d) => d.isActive)
         .map((d) => d.domain);
@@ -135,7 +139,8 @@ async function getEmails(token, email) {
         throw new Error(`Failed to get emails: ${listResponse.status}`);
     }
     const listData = await listResponse.json();
-    const messages = listData['hydra:member'] || [];
+    /* 兼容 Hydra 格式和纯数组格式 */
+    const messages = Array.isArray(listData) ? listData : (listData['hydra:member'] || []);
     if (messages.length === 0) {
         return [];
     }
@@ -164,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  const members = 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  const messages = 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 { 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"]}

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":"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","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"]}