tempmail-sdk 1.0.3 → 1.1.1

package/dist/providers/tempmail.js

@@ -50,4 +50,4 @@ async function getEmails(email) {
     const rawEmails = data.emails || [];
     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.js

@@ -7,6 +7,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.withRetry = withRetry;
 exports.fetchWithTimeout = fetchWithTimeout;
 const logger_1 = require("./logger");
+const config_1 = require("./config");
 const DEFAULT_RETRY_OPTIONS = {
     maxRetries: 2,
     initialDelay: 1000,
@@ -35,6 +36,10 @@ function defaultShouldRetry(error) {
         message.includes('abort')) {
         return true;
     }
+    /* HTTP 429 限流 → 重试 */
+    if (message.includes('429') || message.includes('too many requests') || message.includes('rate limit')) {
+        return true;
+    }
     /* HTTP 4xx/5xx 错误 → 重试 */
     const statusMatch = message.match(/:\s*(\d{3})/);
     if (statusMatch) {
@@ -98,11 +103,15 @@ async function withRetry(fn, options) {
  * @param init fetch 选项
  * @param timeoutMs 超时时间（毫秒）
  */
-async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_RETRY_OPTIONS.timeout) {
+async function fetchWithTimeout(url, init, timeoutMs) {
+    const config = (0, config_1.getConfig)();
+    const effectiveTimeout = timeoutMs ?? config.timeout ?? DEFAULT_RETRY_OPTIONS.timeout;
     const controller = new AbortController();
-    const timeoutId = setTimeout(() => controller.abort(), timeoutMs);
+    const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);
+    /* 使用自定义 fetch 或原生 fetch */
+    const fetchFn = config.customFetch || fetch;
     try {
-        const response = await fetch(url, {
+        const response = await fetchFn(url, {
             ...init,
             signal: controller.signal,
         });
@@ -110,7 +119,7 @@ async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_RETRY_OPTIONS.tim
     }
     catch (error) {
         if (error.name === 'AbortError') {
-            throw new Error(`Request timeout after ${timeoutMs}ms: ${url}`);
+            throw new Error(`Request timeout after ${effectiveTimeout}ms: ${url}`);
         }
         throw error;
     }
@@ -118,4 +127,4 @@ async function fetchWithTimeout(url, init, timeoutMs = DEFAULT_RETRY_OPTIONS.tim
         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"]}
+//# 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';\nimport { getConfig } from './config';\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 429 限流 → 重试 */\n  if (message.includes('429') || message.includes('too many requests') || message.includes('rate limit')) {\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,\n): Promise<Response> {\n  const config = getConfig();\n  const effectiveTimeout = timeoutMs ?? config.timeout ?? DEFAULT_RETRY_OPTIONS.timeout;\n  const controller = new AbortController();\n  const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);\n\n  /* 使用自定义 fetch 或原生 fetch */\n  const fetchFn = config.customFetch || fetch;\n\n  try {\n    const response = await fetchFn(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 ${effectiveTimeout}ms: ${url}`);\n    }\n    throw error;\n  } finally {\n    clearTimeout(timeoutId);\n  }\n}\n"]}

package/dist/types.d.ts

@@ -2,23 +2,30 @@
  * 支持的临时邮箱渠道标识
  * 每个渠道对应一个第三方临时邮箱服务商
  */
-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';
 /**
  * 创建临时邮箱后返回的邮箱信息
- * 包含邮箱地址、认证令牌和生命周期信息
+ * Token 等认证信息由 SDK 内部维护，不对外暴露
  */
 export interface EmailInfo {
     /** 创建该邮箱所使用的渠道 */
     channel: Channel;
     /** 临时邮箱地址 */
     email: string;
-    /** 认证令牌，部分渠道在获取邮件时需要此令牌 */
-    token?: string;
     /** 邮箱过期时间（ISO 8601 字符串或 Unix 时间戳） */
     expiresAt?: string | number;
     /** 邮箱创建时间（ISO 8601 字符串） */
     createdAt?: string;
 }
+/**
+ * SDK 内部使用的邮箱信息，包含 token 等认证数据
+ * 不对外导出，用户无法访问
+ * @internal
+ */
+export interface InternalEmailInfo extends EmailInfo {
+    /** 认证令牌，由 SDK 内部维护 */
+    token?: string;
+}
 /**
  * 标准化邮件附件
  * 不同渠道的附件字段名不同，SDK 统一归一化为此结构
@@ -118,26 +125,18 @@ export interface GenerateEmailOptions {
 }
 /**
  * 获取邮件列表的选项
+ * Channel/Email/Token 等由 SDK 从 EmailInfo 中自动获取，用户无需手动传递
  *
  * @example
  * ```ts
- * const result = await getEmails({
- *   channel: emailInfo.channel,
- *   email: emailInfo.email,
- *   token: emailInfo.token,
- * });
+ * const info = await generateEmail({ channel: 'mail-tm' });
+ * const result = await getEmails(info);
  * if (result.success && result.emails.length > 0) {
  *   console.log('收到邮件:', result.emails);
  * }
  * ```
  */
 export interface GetEmailsOptions {
-    /** 渠道标识，必填 */
-    channel: Channel;
-    /** 邮箱地址，必填 */
-    email: string;
-    /** 认证令牌 */
-    token?: string;
     /** 重试配置，不传则使用默认值（最多重试 2 次） */
     retry?: RetryConfig;
 }

package/dist/types.js

@@ -1,3 +1,3 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tempmail-sdk",
-  "version": "1.0.3",
+  "version": "1.1.1",
   "description": "临时邮箱 SDK - 支持多个临时邮箱服务商",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/config.ts

@@ -0,0 +1,82 @@
+/**
+ * SDK 全局配置
+ * 包含代理、超时、SSL 等设置，作用于所有 HTTP 请求
+ *
+ * 支持环境变量自动读取（优先级低于代码设置）：
+ *   TEMPMAIL_PROXY    - 代理 URL
+ *   TEMPMAIL_TIMEOUT  - 超时毫秒数
+ *   TEMPMAIL_INSECURE - 设为 "1" 或 "true" 跳过 SSL 验证
+ *
+ * Node.js 环境下设置 insecure 会自动设置 NODE_TLS_REJECT_UNAUTHORIZED=0
+ */
+
+/**
+ * SDK 全局配置接口
+ */
+export interface SDKConfig {
+  /** 代理 URL，支持 http/https/socks5，如 "http://127.0.0.1:7890" */
+  proxy?: string;
+  /** 全局默认超时（毫秒），默认 15000 */
+  timeout?: number;
+  /** 跳过 SSL 证书验证（调试用） */
+  insecure?: boolean;
+  /**
+   * 自定义 fetch 函数，用于完全控制 HTTP 请求行为
+   * 当设置了 proxy 但环境不支持 undici 时，可通过此选项传入支持代理的 fetch 实现
+   */
+  customFetch?: typeof fetch;
+}
+
+/** 从环境变量读取默认配置 */
+function loadEnvConfig(): SDKConfig {
+  const config: SDKConfig = {};
+  if (typeof process !== 'undefined' && process.env) {
+    if (process.env.TEMPMAIL_PROXY) {
+      config.proxy = process.env.TEMPMAIL_PROXY;
+    }
+    if (process.env.TEMPMAIL_TIMEOUT) {
+      const t = parseInt(process.env.TEMPMAIL_TIMEOUT, 10);
+      if (!isNaN(t) && t > 0) config.timeout = t;
+    }
+    if (process.env.TEMPMAIL_INSECURE === '1' || process.env.TEMPMAIL_INSECURE?.toLowerCase() === 'true') {
+      config.insecure = true;
+    }
+  }
+  return config;
+}
+
+let globalConfig: SDKConfig = loadEnvConfig();
+
+/**
+ * 设置 SDK 全局配置
+ *
+ * @example
+ * ```ts
+ * // 一行跳过 SSL 验证
+ * setConfig({ insecure: true });
+ *
+ * // 设置代理和超时
+ * setConfig({ proxy: 'http://127.0.0.1:7890', timeout: 30000 });
+ *
+ * // 使用自定义 fetch（如支持代理的 undici）
+ * import { ProxyAgent, fetch as undiciFetch } from 'undici';
+ * const agent = new ProxyAgent('http://127.0.0.1:7890');
+ * setConfig({ customFetch: (url, init) => undiciFetch(url, { ...init, dispatcher: agent }) });
+ * ```
+ */
+export function setConfig(config: SDKConfig): void {
+  globalConfig = { ...config };
+  /* Node.js 环境下 insecure 自动设置环境变量 */
+  if (typeof process !== 'undefined' && process.env) {
+    if (config.insecure) {
+      process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+    } else {
+      delete process.env.NODE_TLS_REJECT_UNAUTHORIZED;
+    }
+  }
+}
+
+/** 获取当前 SDK 全局配置 */
+export function getConfig(): SDKConfig {
+  return globalConfig;
+}

package/src/index.ts

@@ -7,14 +7,26 @@ import * as tempMailIO from './providers/temp-mail-io';
 import * as awamail from './providers/awamail';
 import * as mailTm from './providers/mail-tm';
 import * as dropmail from './providers/dropmail';
-import { Channel, EmailInfo, Email, EmailAttachment, GetEmailsResult, GenerateEmailOptions, GetEmailsOptions } from './types';
+import * as guerrillamail from './providers/guerrillamail';
+import * as maildropProvider from './providers/maildrop';
+import { Channel, EmailInfo, InternalEmailInfo, Email, EmailAttachment, GetEmailsResult, GenerateEmailOptions, GetEmailsOptions } from './types';
 import { withRetry, RetryOptions } from './retry';
 import { logger } from './logger';
+import { setConfig, getConfig } from './config';
 
 export { Channel, EmailInfo, Email, EmailAttachment, GetEmailsResult, GenerateEmailOptions, GetEmailsOptions } from './types';
+
+/**
+ * SDK 内部 token 存储
+ * 使用 WeakMap 将 EmailInfo 对象映射到对应的 token
+ * 用户无法直接访问 token，由 SDK 自动管理
+ * @internal
+ */
+const tokenStore = new WeakMap<EmailInfo, string>();
 export { normalizeEmail } from './normalize';
 export { withRetry, fetchWithTimeout, RetryOptions } from './retry';
 export { LogLevel, LogHandler, setLogLevel, getLogLevel, setLogger, logger } from './logger';
+export { SDKConfig, setConfig, getConfig } from './config';
 
 /** 渠道名称到 provider 实现的映射表 */
 const providers = {
@@ -27,10 +39,12 @@ const providers = {
   'awamail': awamail,
   'mail-tm': mailTm,
   'dropmail': dropmail,
+  'guerrillamail': guerrillamail,
+  'maildrop': maildropProvider,
 };
 
 /** 所有支持的渠道列表，用于随机选择和遍历 */
-const allChannels: Channel[] = ['tempmail', 'linshi-email', 'tempmail-lol', 'chatgpt-org-uk', 'tempmail-la', 'temp-mail-io', 'awamail', 'mail-tm', 'dropmail'];
+const allChannels: Channel[] = ['tempmail', 'linshi-email', 'tempmail-lol', 'chatgpt-org-uk', 'tempmail-la', 'temp-mail-io', 'awamail', 'mail-tm', 'dropmail', 'guerrillamail', 'maildrop'];
 
 /**
  * 渠道信息，包含渠道标识、显示名称和对应网站
@@ -55,6 +69,8 @@ const channelInfoMap: Record<Channel, ChannelInfo> = {
   'awamail': { channel: 'awamail', name: 'AwaMail', website: 'awamail.com' },
   'mail-tm': { channel: 'mail-tm', name: 'Mail.tm', website: 'mail.tm' },
   'dropmail': { channel: 'dropmail', name: 'DropMail', website: 'dropmail.me' },
+  'guerrillamail': { channel: 'guerrillamail', name: 'Guerrilla Mail', website: 'guerrillamail.com' },
+  'maildrop': { channel: 'maildrop', name: 'Maildrop', website: 'maildrop.cc' },
 };
 
 /**
@@ -86,33 +102,70 @@ export function getChannelInfo(channel: Channel): ChannelInfo | undefined {
  * 创建临时邮箱
  *
  * 错误处理策略：
- * - 网络错误、超时、服务端 5xx 错误 → 自动重试（默认 2 次，指数退避）
- * - 4xx 客户端错误、参数错误 → 直接抛出异常
+ * - 指定渠道失败时，自动尝试其他可用渠道（打乱顺序逐个尝试）
+ * - 未指定渠道时，打乱全部渠道逐个尝试，直到成功
+ * - 所有渠道均不可用时返回 null（不抛出异常）
  *
  * @param options - 创建选项，可指定渠道、有效时长、域名等
- * @returns 邮箱信息，包含地址、令牌等
- * @throws 重试耗尽后仍失败时抛出异常
+ * @returns 邮箱信息，所有渠道均不可用时返回 null
  *
  * @example
  * ```ts
  * const emailInfo = await generateEmail({ channel: 'temp-mail-io' });
- * console.log(emailInfo.email); // 临时邮箱地址
+ * if (emailInfo) console.log(emailInfo.email);
  * ```
  */
-export async function generateEmail(options: GenerateEmailOptions = {}): Promise<EmailInfo> {
-  const channel = options.channel || allChannels[Math.floor(Math.random() * allChannels.length)];
+export async function generateEmail(options: GenerateEmailOptions = {}): Promise<EmailInfo | null> {
+  /*
+   * 构建尝试顺序：
+   * - 指定渠道 → 优先尝试该渠道，失败后随机尝试其他渠道
+   * - 未指定 → 打乱全部渠道逐个尝试
+   */
+  const tryOrder = buildChannelOrder(options.channel);
+
+  for (const ch of tryOrder) {
+    logger.info(`创建临时邮箱, 渠道: ${ch}`);
+    try {
+      const internal: InternalEmailInfo = await withRetry(() => generateEmailOnce(ch, options), options.retry);
+      logger.info(`邮箱创建成功: ${internal.email} (渠道: ${ch})`);
+
+      /* 将 token 存入内部存储，不暴露给用户 */
+      const publicInfo: EmailInfo = {
+        channel: internal.channel,
+        email: internal.email,
+        expiresAt: internal.expiresAt,
+        createdAt: internal.createdAt,
+      };
+      if (internal.token) {
+        tokenStore.set(publicInfo, internal.token);
+      }
+      return publicInfo;
+    } catch (err: any) {
+      logger.warn(`渠道 ${ch} 不可用: ${err.message || err}，尝试下一个渠道`);
+    }
+  }
 
-  logger.info(`创建临时邮箱, 渠道: ${channel}`);
-  const result = await withRetry(() => generateEmailOnce(channel, options), options.retry);
-  logger.info(`邮箱创建成功: ${result.email}`);
-  return result;
+  logger.error('所有渠道均不可用，创建邮箱失败');
+  return null;
+}
+
+/**
+ * 构建渠道尝试顺序
+ * 指定渠道时优先尝试该渠道，其余渠道打乱追加
+ * 未指定时打乱全部渠道
+ */
+function buildChannelOrder(preferred?: Channel): Channel[] {
+  const shuffled = [...allChannels].sort(() => Math.random() - 0.5);
+  if (!preferred) return shuffled;
+  const rest = shuffled.filter(ch => ch !== preferred);
+  return [preferred, ...rest];
 }
 
 /**
  * 单次创建邮箱（不含重试逻辑）
  * 根据渠道类型分发到对应的 provider 实现
  */
-async function generateEmailOnce(channel: Channel, options: GenerateEmailOptions): Promise<EmailInfo> {
+async function generateEmailOnce(channel: Channel, options: GenerateEmailOptions): Promise<InternalEmailInfo> {
   switch (channel) {
     case 'tempmail':
       return tempmail.generateEmail(options.duration || 30);
@@ -132,6 +185,10 @@ async function generateEmailOnce(channel: Channel, options: GenerateEmailOptions
       return mailTm.generateEmail();
     case 'dropmail':
       return dropmail.generateEmail();
+    case 'guerrillamail':
+      return guerrillamail.generateEmail();
+    case 'maildrop':
+      return maildropProvider.generateEmail();
     default:
       throw new Error(`Unknown channel: ${channel}`);
   }
@@ -139,32 +196,33 @@ async function generateEmailOnce(channel: Channel, options: GenerateEmailOptions
 
 /**
  * 获取邮件列表
+ * Channel/Email/Token 等由 SDK 从 EmailInfo 中自动获取，用户无需手动传递
  *
  * 错误处理策略：
- * - 网络错误、超时、服务端 5xx 错误 → 自动重试（默认 2 次）
+ * - 网络错误、超时、429、服务端 5xx 错误 → 自动重试（默认 2 次）
  * - 重试耗尽后返回 { success: false, emails: [] }，不抛异常
- * - 参数校验错误（缺少 channel / token）直接抛出
+ * - 参数校验错误（缺少 EmailInfo）直接抛出
  *
- * 这种设计让调用方在轮询场景下不会因网络波动而中断整个流程，
- * 只需检查 success 字段即可判断本次请求是否成功。
- *
- * @param options - 获取选项，包含渠道、邮箱地址、令牌
+ * @param info - GenerateEmail() 返回的邮箱信息
+ * @param options - 可选配置（重试等）
  * @returns 邮件结果，包含 success 标记和邮件列表
  *
  * @example
  * ```ts
- * const result = await getEmails({
- *   channel: emailInfo.channel,
- *   email: emailInfo.email,
- *   token: emailInfo.token,
- * });
+ * const info = await generateEmail({ channel: 'mail-tm' });
+ * const result = await getEmails(info);
  * if (result.success && result.emails.length > 0) {
  *   console.log('收到邮件:', result.emails[0].subject);
  * }
  * ```
  */
-export async function getEmails(options: GetEmailsOptions): Promise<GetEmailsResult> {
-  const { channel, email, token } = options;
+export async function getEmails(info: EmailInfo, options?: GetEmailsOptions): Promise<GetEmailsResult> {
+  if (!info) {
+    throw new Error('EmailInfo is required, call generateEmail() first');
+  }
+
+  const { channel, email } = info;
+  const token = tokenStore.get(info);
 
   if (!channel) {
     throw new Error('Channel is required');
@@ -175,7 +233,7 @@ export async function getEmails(options: GetEmailsOptions): Promise<GetEmailsRes
 
   logger.debug(`获取邮件, 渠道: ${channel}, 邮箱: ${email}`);
   try {
-    const emails = await withRetry(() => getEmailsOnce(channel, email, token), options.retry);
+    const emails = await withRetry(() => getEmailsOnce(channel, email, token), options?.retry);
     if (emails.length > 0) {
       logger.info(`获取到 ${emails.length} 封邮件, 渠道: ${channel}`);
     } else {
@@ -203,7 +261,7 @@ async function getEmailsOnce(channel: Channel, email: string, token?: string): P
     case 'linshi-email':
       return linshiEmail.getEmails(email);
     case 'tempmail-lol':
-      if (!token) throw new Error('Token is required for tempmail-lol channel');
+      if (!token) throw new Error('internal error: token missing for tempmail-lol');
       return tempmailLol.getEmails(token, email);
     case 'chatgpt-org-uk':
       return chatgptOrgUk.getEmails(email);
@@ -212,14 +270,20 @@ async function getEmailsOnce(channel: Channel, email: string, token?: string): P
     case 'temp-mail-io':
       return tempMailIO.getEmails(email);
     case 'awamail':
-      if (!token) throw new Error('Token is required for awamail channel');
+      if (!token) throw new Error('internal error: token missing for awamail');
       return awamail.getEmails(token, email);
     case 'mail-tm':
-      if (!token) throw new Error('Token is required for mail-tm channel');
+      if (!token) throw new Error('internal error: token missing for mail-tm');
       return mailTm.getEmails(token, email);
     case 'dropmail':
-      if (!token) throw new Error('Token is required for dropmail channel');
+      if (!token) throw new Error('internal error: token missing for dropmail');
       return dropmail.getEmails(token, email);
+    case 'guerrillamail':
+      if (!token) throw new Error('internal error: token missing for guerrillamail');
+      return guerrillamail.getEmails(token, email);
+    case 'maildrop':
+      if (!token) throw new Error('internal error: token missing for maildrop');
+      return maildropProvider.getEmails(token, email);
     default:
       throw new Error(`Unknown channel: ${channel}`);
   }
@@ -248,8 +312,9 @@ export class TempEmailClient {
   /**
    * 创建临时邮箱并缓存邮箱信息
    * 后续调用 getEmails() 时自动使用此邮箱的渠道、地址和令牌
+   * 所有渠道均不可用时返回 null
    */
-  async generate(options: GenerateEmailOptions = {}): Promise<EmailInfo> {
+  async generate(options: GenerateEmailOptions = {}): Promise<EmailInfo | null> {
     this.emailInfo = await generateEmail(options);
     return this.emailInfo;
   }
@@ -260,16 +325,12 @@ export class TempEmailClient {
    *
    * @throws 未调用 generate() 时抛出异常
    */
-  async getEmails(): Promise<GetEmailsResult> {
+  async getEmails(options?: GetEmailsOptions): Promise<GetEmailsResult> {
     if (!this.emailInfo) {
       throw new Error('No email generated. Call generate() first.');
     }
 
-    return getEmails({
-      channel: this.emailInfo.channel,
-      email: this.emailInfo.email,
-      token: this.emailInfo.token,
-    });
+    return getEmails(this.emailInfo, options);
   }
 
   /**
@@ -287,4 +348,6 @@ export default {
   generateEmail,
   getEmails,
   TempEmailClient,
+  setConfig,
+  getConfig,
 };

package/src/normalize.ts

@@ -11,19 +11,47 @@ import { Email, EmailAttachment } from './types';
  * @returns 标准化的 Email 对象
  */
 export function normalizeEmail(raw: any, recipientEmail: string = ''): Email {
+  let text = normalizeText(raw);
+  let html = normalizeHtml(raw);
+
+  /*
+   * 修正 text/html 错配：
+   * 部分渠道将 HTML 内容放在 body/text 等字段中，
+   * 导致 normalizeText 提取到 HTML 内容而 normalizeHtml 为空。
+   * 检测 text 中是否包含 HTML 标签，如果是则移动到 html 字段。
+   */
+  if (text && !html && isHtmlContent(text)) {
+    html = text;
+    text = '';
+  }
+
   return {
     id: normalizeId(raw),
     from: normalizeFrom(raw),
     to: normalizeTo(raw, recipientEmail),
     subject: normalizeSubject(raw),
-    text: normalizeText(raw),
-    html: normalizeHtml(raw),
+    text,
+    html,
     date: normalizeDate(raw),
     isRead: normalizeIsRead(raw),
     attachments: normalizeAttachments(raw.attachments),
   };
 }
 
+/**
+ * 检测内容是否为 HTML
+ * 通过检查是否包含常见的 HTML 标签来判断
+ */
+function isHtmlContent(content: string): boolean {
+  const trimmed = content.trim().toLowerCase();
+  return trimmed.startsWith('<!doctype html') ||
+    trimmed.startsWith('<html') ||
+    trimmed.startsWith('<body') ||
+    (trimmed.includes('<div') && trimmed.includes('</div>')) ||
+    (trimmed.includes('<table') && trimmed.includes('</table>')) ||
+    (trimmed.includes('<p') && trimmed.includes('</p>') && trimmed.includes('<'));
+}
+
 /**
  * 提取邮件 ID
  * 候选字段: id, eid, _id, mailboxId, messageId, mail_id

package/src/providers/awamail.ts

@@ -1,4 +1,4 @@
-import { EmailInfo, Email, Channel } from '../types';
+import { InternalEmailInfo, Email, Channel } from '../types';
 import { normalizeEmail } from '../normalize';
 
 const CHANNEL: Channel = 'awamail';
@@ -36,7 +36,7 @@ function extractSessionCookie(response: Response): string {
  * 返回: { success, data: { email_address, expired_at, created_at, ... } }
  * 需要保存响应中的 Set-Cookie (awamail_session) 用于后续获取邮件
  */
-export async function generateEmail(): Promise<EmailInfo> {
+export async function generateEmail(): Promise<InternalEmailInfo> {
   const response = await fetch(`${BASE_URL}/change_mailbox`, {
     method: 'POST',
     headers: {