tempmail-sdk 1.0.1 → 1.0.3

package/dist/normalize.js

@@ -0,0 +1,132 @@
+"use strict";
+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 {
+        id: normalizeId(raw),
+        from: normalizeFrom(raw),
+        to: normalizeTo(raw, recipientEmail),
+        subject: normalizeSubject(raw),
+        text: normalizeText(raw),
+        html: normalizeHtml(raw),
+        date: normalizeDate(raw),
+        isRead: normalizeIsRead(raw),
+        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)
+            return new Date(raw.received_at).toISOString();
+        if (raw.created_at)
+            return new Date(raw.created_at).toISOString();
+        if (raw.createdAt)
+            return new Date(raw.createdAt).toISOString();
+        if (raw.date) {
+            if (typeof raw.date === 'number')
+                return new Date(raw.date).toISOString();
+            return new Date(raw.date).toISOString();
+        }
+        if (raw.timestamp)
+            return new Date(raw.timestamp * 1000).toISOString();
+        if (raw.e_date)
+            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;
+    if (typeof raw.read === 'boolean')
+        return raw.read;
+    if (typeof raw.isRead === 'boolean')
+        return raw.isRead;
+    if (typeof raw.is_read === 'number')
+        return raw.is_read === 1;
+    if (typeof raw.is_read === 'string')
+        return raw.is_read === '1';
+    if (typeof raw.is_read === 'boolean')
+        return raw.is_read;
+    return false;
+}
+/**
+ * 提取并标准化附件列表
+ * 每个附件的字段也采用多候选策略映射
+ */
+function normalizeAttachments(attachments) {
+    if (!attachments || !Array.isArray(attachments))
+        return [];
+    return attachments.map((a) => ({
+        filename: a.filename || a.name || '',
+        size: a.size || a.filesize || undefined,
+        contentType: a.contentType || a.content_type || a.mimeType || a.mime_type || undefined,
+        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":";;AAYA,wCAYC;AAtBD;;;;;;;;;GASG;AACH,SAAgB,cAAc,CAAC,GAAQ,EAAE,iBAAyB,EAAE;IAClE,OAAO;QACL,EAAE,EAAE,WAAW,CAAC,GAAG,CAAC;QACpB,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC;QACxB,EAAE,EAAE,WAAW,CAAC,GAAG,EAAE,cAAc,CAAC;QACpC,OAAO,EAAE,gBAAgB,CAAC,GAAG,CAAC;QAC9B,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC;QACxB,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC;QACxB,IAAI,EAAE,aAAa,CAAC,GAAG,CAAC;QACxB,MAAM,EAAE,eAAe,CAAC,GAAG,CAAC;QAC5B,WAAW,EAAE,oBAAoB,CAAC,GAAG,CAAC,WAAW,CAAC;KACnD,CAAC;AACJ,CAAC;AAED;;;GAGG;AACH,SAAS,WAAW,CAAC,GAAQ;IAC3B,MAAM,EAAE,GAAG,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,GAAG,IAAI,GAAG,CAAC,SAAS,IAAI,GAAG,CAAC,SAAS,IAAI,GAAG,CAAC,OAAO,IAAI,EAAE,CAAC;IAC/F,OAAO,MAAM,CAAC,EAAE,CAAC,CAAC;AACpB,CAAC;AAED;;;GAGG;AACH,SAAS,aAAa,CAAC,GAAQ;IAC7B,OAAO,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,WAAW,IAAI,GAAG,CAAC,MAAM,IAAI,EAAE,CAAC;AACjG,CAAC;AAED;;;GAGG;AACH,SAAS,WAAW,CAAC,GAAQ,EAAE,cAAsB;IACnD,OAAO,GAAG,CAAC,EAAE,IAAI,GAAG,CAAC,UAAU,IAAI,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC,aAAa,IAAI,GAAG,CAAC,OAAO,IAAI,cAAc,IAAI,EAAE,CAAC;AAC7G,CAAC;AAED;;;GAGG;AACH,SAAS,gBAAgB,CAAC,GAAQ;IAChC,OAAO,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC;AAC5C,CAAC;AAED;;;GAGG;AACH,SAAS,aAAa,CAAC,GAAQ;IAC7B,OAAO,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,OAAO,IAAI,GAAG,CAAC,SAAS,IAAI,GAAG,CAAC,YAAY,IAAI,EAAE,CAAC;AACxF,CAAC;AAED;;;GAGG;AACH,SAAS,aAAa,CAAC,GAAQ;IAC7B,OAAO,GAAG,CAAC,IAAI,IAAI,GAAG,CAAC,YAAY,IAAI,GAAG,CAAC,SAAS,IAAI,EAAE,CAAC;AAC7D,CAAC;AAED;;;;GAIG;AACH,SAAS,aAAa,CAAC,GAAQ;IAC7B,IAAI,CAAC;QACH,IAAI,GAAG,CAAC,WAAW;YAAE,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,WAAW,CAAC,CAAC,WAAW,EAAE,CAAC;QACpE,IAAI,GAAG,CAAC,UAAU;YAAE,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE,CAAC;QAClE,IAAI,GAAG,CAAC,SAAS;YAAE,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,WAAW,EAAE,CAAC;QAChE,IAAI,GAAG,CAAC,IAAI,EAAE,CAAC;YACb,IAAI,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ;gBAAE,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;YAC1E,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;QAC1C,CAAC;QACD,IAAI,GAAG,CAAC,SAAS;YAAE,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,SAAS,GAAG,IAAI,CAAC,CAAC,WAAW,EAAE,CAAC;QACvE,IAAI,GAAG,CAAC,MAAM;YAAE,OAAO,IAAI,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,WAAW,EAAE,CAAC;IAC5D,CAAC;IAAC,MAAM,CAAC;QACP,mBAAmB;IACrB,CAAC;IACD,OAAO,EAAE,CAAC;AACZ,CAAC;AAED;;;;GAIG;AACH,SAAS,eAAe,CAAC,GAAQ;IAC/B,IAAI,OAAO,GAAG,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,GAAG,CAAC,IAAI,CAAC;IACnD,IAAI,OAAO,GAAG,CAAC,IAAI,KAAK,SAAS;QAAE,OAAO,GAAG,CAAC,IAAI,CAAC;IACnD,IAAI,OAAO,GAAG,CAAC,MAAM,KAAK,SAAS;QAAE,OAAO,GAAG,CAAC,MAAM,CAAC;IACvD,IAAI,OAAO,GAAG,CAAC,OAAO,KAAK,QAAQ;QAAE,OAAO,GAAG,CAAC,OAAO,KAAK,CAAC,CAAC;IAC9D,IAAI,OAAO,GAAG,CAAC,OAAO,KAAK,QAAQ;QAAE,OAAO,GAAG,CAAC,OAAO,KAAK,GAAG,CAAC;IAChE,IAAI,OAAO,GAAG,CAAC,OAAO,KAAK,SAAS;QAAE,OAAO,GAAG,CAAC,OAAO,CAAC;IACzD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,SAAS,oBAAoB,CAAC,WAAgB;IAC5C,IAAI,CAAC,WAAW,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,WAAW,CAAC;QAAE,OAAO,EAAE,CAAC;IAC3D,OAAO,WAAW,CAAC,GAAG,CAAC,CAAC,CAAM,EAAE,EAAE,CAAC,CAAC;QAClC,QAAQ,EAAE,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,IAAI,IAAI,EAAE;QACpC,IAAI,EAAE,CAAC,CAAC,IAAI,IAAI,CAAC,CAAC,QAAQ,IAAI,SAAS;QACvC,WAAW,EAAE,CAAC,CAAC,WAAW,IAAI,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC,QAAQ,IAAI,CAAC,CAAC,SAAS,IAAI,SAAS;QACtF,GAAG,EAAE,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC,YAAY,IAAI,CAAC,CAAC,WAAW,IAAI,SAAS;KAC3D,CAAC,CAAC,CAAC;AACN,CAAC","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/awamail.d.ts

@@ -0,0 +1,15 @@
+import { EmailInfo, Email } from '../types';
+/**
+ * 创建临时邮箱
+ * API: POST /welcome/change_mailbox (空 body)
+ * 返回: { success, data: { email_address, expired_at, created_at, ... } }
+ * 需要保存响应中的 Set-Cookie (awamail_session) 用于后续获取邮件
+ */
+export declare function generateEmail(): Promise<EmailInfo>;
+/**
+ * 获取邮件列表
+ * API: GET /welcome/get_emails
+ * 需要传入 Cookie (awamail_session) 和 x-requested-with 头
+ * 返回: { success, data: { emails: [...], latest: {...} } }
+ */
+export declare function getEmails(token: string, email: string): Promise<Email[]>;

package/dist/providers/awamail.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEmail = generateEmail;
+exports.getEmails = getEmails;
+const normalize_1 = require("../normalize");
+const CHANNEL = 'awamail';
+const BASE_URL = 'https://awamail.com/welcome';
+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',
+    'Accept': 'application/json, text/javascript, */*; q=0.01',
+    'accept-language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',
+    'cache-control': 'no-cache',
+    'dnt': '1',
+    'origin': 'https://awamail.com',
+    'pragma': 'no-cache',
+    'referer': 'https://awamail.com/?lang=zh',
+    '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-origin',
+};
+/**
+ * 从 Set-Cookie 响应头中提取 awamail_session 值
+ */
+function extractSessionCookie(response) {
+    const setCookie = response.headers.get('set-cookie') || '';
+    const match = setCookie.match(/awamail_session=([^;]+)/);
+    return match ? `awamail_session=${match[1]}` : '';
+}
+/**
+ * 创建临时邮箱
+ * API: POST /welcome/change_mailbox (空 body)
+ * 返回: { success, data: { email_address, expired_at, created_at, ... } }
+ * 需要保存响应中的 Set-Cookie (awamail_session) 用于后续获取邮件
+ */
+async function generateEmail() {
+    const response = await fetch(`${BASE_URL}/change_mailbox`, {
+        method: 'POST',
+        headers: {
+            ...DEFAULT_HEADERS,
+            'Content-Length': '0',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to generate email: ${response.status}`);
+    }
+    // 提取 session cookie
+    const sessionCookie = extractSessionCookie(response);
+    if (!sessionCookie) {
+        throw new Error('Failed to extract session cookie');
+    }
+    const data = await response.json();
+    if (!data.success || !data.data) {
+        throw new Error('Failed to generate email');
+    }
+    return {
+        channel: CHANNEL,
+        email: data.data.email_address,
+        token: sessionCookie,
+        expiresAt: data.data.expired_at,
+        createdAt: data.data.created_at,
+    };
+}
+/**
+ * 获取邮件列表
+ * API: GET /welcome/get_emails
+ * 需要传入 Cookie (awamail_session) 和 x-requested-with 头
+ * 返回: { success, data: { emails: [...], latest: {...} } }
+ */
+async function getEmails(token, email) {
+    const response = await fetch(`${BASE_URL}/get_emails`, {
+        method: 'GET',
+        headers: {
+            ...DEFAULT_HEADERS,
+            'Cookie': token,
+            'x-requested-with': 'XMLHttpRequest',
+        },
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to get emails: ${response.status}`);
+    }
+    const data = await response.json();
+    if (!data.success || !data.data) {
+        throw new Error('Failed to get emails');
+    }
+    const rawEmails = data.data.emails || [];
+    return rawEmails.map((raw) => (0, normalize_1.normalizeEmail)(raw, email));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/chatgpt-org-uk.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateEmail = generateEmail;
 exports.getEmails = getEmails;
+const normalize_1 = require("../normalize");
 const CHANNEL = 'chatgpt-org-uk';
 const BASE_URL = 'https://mail.chatgpt.org.uk/api';
 const DEFAULT_HEADERS = {
@@ -44,6 +45,7 @@ async function getEmails(email) {
     if (!data.success) {
         throw new Error('Failed to get emails');
     }
-    return data.data?.emails || [];
+    const rawEmails = data.data?.emails || [];
+    return rawEmails.map((raw) => (0, normalize_1.normalizeEmail)(raw, email));
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhdGdwdC1vcmctdWsuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmlkZXJzL2NoYXRncHQtb3JnLXVrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBZ0JBLHNDQW9CQztBQUVELDhCQWtCQztBQXRERCxNQUFNLE9BQU8sR0FBWSxnQkFBZ0IsQ0FBQztBQUMxQyxNQUFNLFFBQVEsR0FBRyxpQ0FBaUMsQ0FBQztBQUVuRCxNQUFNLGVBQWUsR0FBRztJQUN0QixZQUFZLEVBQUUsaUhBQWlIO0lBQy9ILGNBQWMsRUFBRSxrQkFBa0I7SUFDbEMsUUFBUSxFQUFFLEtBQUs7SUFDZixTQUFTLEVBQUUsOEJBQThCO0lBQ3pDLFdBQVcsRUFBRSxvRUFBb0U7SUFDakYsa0JBQWtCLEVBQUUsSUFBSTtJQUN4QixvQkFBb0IsRUFBRSxXQUFXO0lBQ2pDLEtBQUssRUFBRSxHQUFHO0NBQ1gsQ0FBQztBQUVLLEtBQUssVUFBVSxhQUFhO0lBQ2pDLE1BQU0sUUFBUSxHQUFHLE1BQU0sS0FBSyxDQUFDLEdBQUcsUUFBUSxpQkFBaUIsRUFBRTtRQUN6RCxNQUFNLEVBQUUsS0FBSztRQUNiLE9BQU8sRUFBRSxlQUFlO0tBQ3pCLENBQUMsQ0FBQztJQUVILElBQUksQ0FBQyxRQUFRLENBQUMsRUFBRSxFQUFFLENBQUM7UUFDakIsTUFBTSxJQUFJLEtBQUssQ0FBQyw2QkFBNkIsUUFBUSxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7SUFDbEUsQ0FBQztJQUVELE1BQU0sSUFBSSxHQUFHLE1BQU0sUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO0lBRW5DLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDbEIsTUFBTSxJQUFJLEtBQUssQ0FBQywwQkFBMEIsQ0FBQyxDQUFDO0lBQzlDLENBQUM7SUFFRCxPQUFPO1FBQ0wsT0FBTyxFQUFFLE9BQU87UUFDaEIsS0FBSyxFQUFFLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSztLQUN2QixDQUFDO0FBQ0osQ0FBQztBQUVNLEtBQUssVUFBVSxTQUFTLENBQUMsS0FBYTtJQUMzQyxNQUFNLFlBQVksR0FBRyxrQkFBa0IsQ0FBQyxLQUFLLENBQUMsQ0FBQztJQUMvQyxNQUFNLFFBQVEsR0FBRyxNQUFNLEtBQUssQ0FBQyxHQUFHLFFBQVEsaUJBQWlCLFlBQVksRUFBRSxFQUFFO1FBQ3ZFLE1BQU0sRUFBRSxLQUFLO1FBQ2IsT0FBTyxFQUFFLGVBQWU7S0FDekIsQ0FBQyxDQUFDO0lBRUgsSUFBSSxDQUFDLFFBQVEsQ0FBQyxFQUFFLEVBQUUsQ0FBQztRQUNqQixNQUFNLElBQUksS0FBSyxDQUFDLHlCQUF5QixRQUFRLENBQUMsTUFBTSxFQUFFLENBQUMsQ0FBQztJQUM5RCxDQUFDO0lBRUQsTUFBTSxJQUFJLEdBQUcsTUFBTSxRQUFRLENBQUMsSUFBSSxFQUFFLENBQUM7SUFFbkMsSUFBSSxDQUFDLElBQUksQ0FBQyxPQUFPLEVBQUUsQ0FBQztRQUNsQixNQUFNLElBQUksS0FBSyxDQUFDLHNCQUFzQixDQUFDLENBQUM7SUFDMUMsQ0FBQztJQUVELE9BQU8sSUFBSSxDQUFDLElBQUksRUFBRSxNQUFNLElBQUksRUFBRSxDQUFDO0FBQ2pDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBFbWFpbEluZm8sIEVtYWlsLCBDaGFubmVsIH0gZnJvbSAnLi4vdHlwZXMnO1xuXG5jb25zdCBDSEFOTkVMOiBDaGFubmVsID0gJ2NoYXRncHQtb3JnLXVrJztcbmNvbnN0IEJBU0VfVVJMID0gJ2h0dHBzOi8vbWFpbC5jaGF0Z3B0Lm9yZy51ay9hcGknO1xuXG5jb25zdCBERUZBVUxUX0hFQURFUlMgPSB7XG4gICdVc2VyLUFnZW50JzogJ01vemlsbGEvNS4wIChXaW5kb3dzIE5UIDEwLjA7IFdpbjY0OyB4NjQpIEFwcGxlV2ViS2l0LzUzNy4zNiAoS0hUTUwsIGxpa2UgR2Vja28pIENocm9tZS8xNDMuMC4wLjAgU2FmYXJpLzUzNy4zNicsXG4gICdDb250ZW50LVR5cGUnOiAnYXBwbGljYXRpb24vanNvbicsXG4gICdBY2NlcHQnOiAnKi8qJyxcbiAgJ1JlZmVyZXInOiAnaHR0cHM6Ly9tYWlsLmNoYXRncHQub3JnLnVrLycsXG4gICdzZWMtY2gtdWEnOiAnXCJNaWNyb3NvZnQgRWRnZVwiO3Y9XCIxNDNcIiwgXCJDaHJvbWl1bVwiO3Y9XCIxNDNcIiwgXCJOb3QgQShCcmFuZFwiO3Y9XCIyNFwiJyxcbiAgJ3NlYy1jaC11YS1tb2JpbGUnOiAnPzAnLFxuICAnc2VjLWNoLXVhLXBsYXRmb3JtJzogJ1wiV2luZG93c1wiJyxcbiAgJ0ROVCc6ICcxJyxcbn07XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBnZW5lcmF0ZUVtYWlsKCk6IFByb21pc2U8RW1haWxJbmZvPiB7XG4gIGNvbnN0IHJlc3BvbnNlID0gYXdhaXQgZmV0Y2goYCR7QkFTRV9VUkx9L2dlbmVyYXRlLWVtYWlsYCwge1xuICAgIG1ldGhvZDogJ0dFVCcsXG4gICAgaGVhZGVyczogREVGQVVMVF9IRUFERVJTLFxuICB9KTtcblxuICBpZiAoIXJlc3BvbnNlLm9rKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKGBGYWlsZWQgdG8gZ2VuZXJhdGUgZW1haWw6ICR7cmVzcG9uc2Uuc3RhdHVzfWApO1xuICB9XG5cbiAgY29uc3QgZGF0YSA9IGF3YWl0IHJlc3BvbnNlLmpzb24oKTtcbiAgXG4gIGlmICghZGF0YS5zdWNjZXNzKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKCdGYWlsZWQgdG8gZ2VuZXJhdGUgZW1haWwnKTtcbiAgfVxuXG4gIHJldHVybiB7XG4gICAgY2hhbm5lbDogQ0hBTk5FTCxcbiAgICBlbWFpbDogZGF0YS5kYXRhLmVtYWlsLFxuICB9O1xufVxuXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gZ2V0RW1haWxzKGVtYWlsOiBzdHJpbmcpOiBQcm9taXNlPEVtYWlsW10+IHtcbiAgY29uc3QgZW5jb2RlZEVtYWlsID0gZW5jb2RlVVJJQ29tcG9uZW50KGVtYWlsKTtcbiAgY29uc3QgcmVzcG9uc2UgPSBhd2FpdCBmZXRjaChgJHtCQVNFX1VSTH0vZW1haWxzP2VtYWlsPSR7ZW5jb2RlZEVtYWlsfWAsIHtcbiAgICBtZXRob2Q6ICdHRVQnLFxuICAgIGhlYWRlcnM6IERFRkFVTFRfSEVBREVSUyxcbiAgfSk7XG5cbiAgaWYgKCFyZXNwb25zZS5vaykge1xuICAgIHRocm93IG5ldyBFcnJvcihgRmFpbGVkIHRvIGdldCBlbWFpbHM6ICR7cmVzcG9uc2Uuc3RhdHVzfWApO1xuICB9XG5cbiAgY29uc3QgZGF0YSA9IGF3YWl0IHJlc3BvbnNlLmpzb24oKTtcbiAgXG4gIGlmICghZGF0YS5zdWNjZXNzKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKCdGYWlsZWQgdG8gZ2V0IGVtYWlscycpO1xuICB9XG5cbiAgcmV0dXJuIGRhdGEuZGF0YT8uZW1haWxzIHx8IFtdO1xufVxuIl19
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/dropmail.d.ts

@@ -0,0 +1,13 @@
+import { EmailInfo, Email } from '../types';
+/**
+ * 创建临时邮箱
+ * GraphQL mutation: introduceSession
+ * 返回 session ID (存入 token) 和邮箱地址
+ */
+export declare function generateEmail(): Promise<EmailInfo>;
+/**
+ * 获取邮件列表
+ * GraphQL query: session(id) { mails {...} }
+ * token 中存储的是 session ID
+ */
+export declare function getEmails(token: string, email: string): Promise<Email[]>;

package/dist/providers/dropmail.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEmail = generateEmail;
+exports.getEmails = getEmails;
+const normalize_1 = require("../normalize");
+const CHANNEL = 'dropmail';
+const BASE_URL = 'https://dropmail.me/api/graphql/MY_TOKEN';
+const DEFAULT_HEADERS = {
+    'Content-Type': 'application/x-www-form-urlencoded',
+};
+const CREATE_SESSION_QUERY = 'mutation {introduceSession {id, expiresAt, addresses{id, address}}}';
+const GET_MAILS_QUERY = `query ($id: ID!) {
+  session(id:$id) {
+    mails {
+      id, rawSize, fromAddr, toAddr, receivedAt,
+      text, headerFrom, headerSubject, html
+    }
+  }
+}`;
+/**
+ * 执行 GraphQL 请求
+ */
+async function graphqlRequest(query, variables) {
+    const params = new URLSearchParams();
+    params.set('query', query);
+    if (variables) {
+        params.set('variables', JSON.stringify(variables));
+    }
+    const response = await fetch(BASE_URL, {
+        method: 'POST',
+        headers: DEFAULT_HEADERS,
+        body: params.toString(),
+    });
+    if (!response.ok) {
+        throw new Error(`GraphQL request failed: ${response.status}`);
+    }
+    const data = await response.json();
+    if (data.errors) {
+        throw new Error(`GraphQL error: ${data.errors[0]?.message || 'Unknown error'}`);
+    }
+    return data.data;
+}
+/**
+ * 创建临时邮箱
+ * GraphQL mutation: introduceSession
+ * 返回 session ID (存入 token) 和邮箱地址
+ */
+async function generateEmail() {
+    const data = await graphqlRequest(CREATE_SESSION_QUERY);
+    const session = data?.introduceSession;
+    if (!session || !session.addresses || session.addresses.length === 0) {
+        throw new Error('Failed to generate email');
+    }
+    return {
+        channel: CHANNEL,
+        email: session.addresses[0].address,
+        token: session.id,
+        expiresAt: session.expiresAt,
+    };
+}
+/**
+ * 将 dropmail 的邮件格式扁平化为 normalizeEmail 可处理的格式
+ */
+function flattenMessage(mail, recipientEmail) {
+    return {
+        id: mail.id || '',
+        from: mail.fromAddr || '',
+        to: mail.toAddr || recipientEmail,
+        subject: mail.headerSubject || '',
+        text: mail.text || '',
+        html: mail.html || '',
+        received_at: mail.receivedAt || '',
+        attachments: [],
+    };
+}
+/**
+ * 获取邮件列表
+ * GraphQL query: session(id) { mails {...} }
+ * token 中存储的是 session ID
+ */
+async function getEmails(token, email) {
+    const data = await graphqlRequest(GET_MAILS_QUERY, { id: token });
+    const mails = data?.session?.mails || [];
+    return mails.map((mail) => (0, normalize_1.normalizeEmail)(flattenMessage(mail, email), email));
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/providers/linshi-email.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.generateEmail = generateEmail;
 exports.getEmails = getEmails;
+const normalize_1 = require("../normalize");
 const CHANNEL = 'linshi-email';
 const BASE_URL = 'https://www.linshi-email.com/api/v1';
 const API_KEY = '552562b8524879814776e52bc8de5c9f';
@@ -48,6 +49,7 @@ async function getEmails(email) {
     if (data.status !== 'ok') {
         throw new Error('Failed to get emails');
     }
-    return data.list || [];
+    const rawEmails = data.list || [];
+    return rawEmails.map((raw) => (0, normalize_1.normalizeEmail)(raw, email));
 }
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

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

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