tempmail-sdk 1.0.1 → 1.0.2

package/dist/normalize.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizeEmail = normalizeEmail;
+/**
+ * 将各提供商返回的原始邮件数据标准化为统一的 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),
+    };
+}
+function normalizeId(raw) {
+    const id = raw.id ?? raw.eid ?? raw._id ?? raw.mailboxId ?? raw.messageId ?? raw.mail_id ?? '';
+    return String(id);
+}
+function normalizeFrom(raw) {
+    return raw.from_address || raw.address_from || raw.from || raw.messageFrom || raw.sender || '';
+}
+function normalizeTo(raw, recipientEmail) {
+    return raw.to || raw.to_address || raw.name_to || raw.email_address || raw.address || recipientEmail || '';
+}
+function normalizeSubject(raw) {
+    return raw.subject || raw.e_subject || '';
+}
+function normalizeText(raw) {
+    return raw.text || raw.body || raw.content || raw.body_text || raw.text_content || '';
+}
+function normalizeHtml(raw) {
+    return raw.html || raw.html_content || raw.body_html || '';
+}
+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 '';
+}
+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":"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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"]}

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,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
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2hhdGdwdC1vcmctdWsuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvcHJvdmlkZXJzL2NoYXRncHQtb3JnLXVrLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7O0FBaUJBLHNDQW9CQztBQUVELDhCQW1CQztBQXpERCw0Q0FBOEM7QUFFOUMsTUFBTSxPQUFPLEdBQVksZ0JBQWdCLENBQUM7QUFDMUMsTUFBTSxRQUFRLEdBQUcsaUNBQWlDLENBQUM7QUFFbkQsTUFBTSxlQUFlLEdBQUc7SUFDdEIsWUFBWSxFQUFFLGlIQUFpSDtJQUMvSCxjQUFjLEVBQUUsa0JBQWtCO0lBQ2xDLFFBQVEsRUFBRSxLQUFLO0lBQ2YsU0FBUyxFQUFFLDhCQUE4QjtJQUN6QyxXQUFXLEVBQUUsb0VBQW9FO0lBQ2pGLGtCQUFrQixFQUFFLElBQUk7SUFDeEIsb0JBQW9CLEVBQUUsV0FBVztJQUNqQyxLQUFLLEVBQUUsR0FBRztDQUNYLENBQUM7QUFFSyxLQUFLLFVBQVUsYUFBYTtJQUNqQyxNQUFNLFFBQVEsR0FBRyxNQUFNLEtBQUssQ0FBQyxHQUFHLFFBQVEsaUJBQWlCLEVBQUU7UUFDekQsTUFBTSxFQUFFLEtBQUs7UUFDYixPQUFPLEVBQUUsZUFBZTtLQUN6QixDQUFDLENBQUM7SUFFSCxJQUFJLENBQUMsUUFBUSxDQUFDLEVBQUUsRUFBRSxDQUFDO1FBQ2pCLE1BQU0sSUFBSSxLQUFLLENBQUMsNkJBQTZCLFFBQVEsQ0FBQyxNQUFNLEVBQUUsQ0FBQyxDQUFDO0lBQ2xFLENBQUM7SUFFRCxNQUFNLElBQUksR0FBRyxNQUFNLFFBQVEsQ0FBQyxJQUFJLEVBQUUsQ0FBQztJQUVuQyxJQUFJLENBQUMsSUFBSSxDQUFDLE9BQU8sRUFBRSxDQUFDO1FBQ2xCLE1BQU0sSUFBSSxLQUFLLENBQUMsMEJBQTBCLENBQUMsQ0FBQztJQUM5QyxDQUFDO0lBRUQsT0FBTztRQUNMLE9BQU8sRUFBRSxPQUFPO1FBQ2hCLEtBQUssRUFBRSxJQUFJLENBQUMsSUFBSSxDQUFDLEtBQUs7S0FDdkIsQ0FBQztBQUNKLENBQUM7QUFFTSxLQUFLLFVBQVUsU0FBUyxDQUFDLEtBQWE7SUFDM0MsTUFBTSxZQUFZLEdBQUcsa0JBQWtCLENBQUMsS0FBSyxDQUFDLENBQUM7SUFDL0MsTUFBTSxRQUFRLEdBQUcsTUFBTSxLQUFLLENBQUMsR0FBRyxRQUFRLGlCQUFpQixZQUFZLEVBQUUsRUFBRTtRQUN2RSxNQUFNLEVBQUUsS0FBSztRQUNiLE9BQU8sRUFBRSxlQUFlO0tBQ3pCLENBQUMsQ0FBQztJQUVILElBQUksQ0FBQyxRQUFRLENBQUMsRUFBRSxFQUFFLENBQUM7UUFDakIsTUFBTSxJQUFJLEtBQUssQ0FBQyx5QkFBeUIsUUFBUSxDQUFDLE1BQU0sRUFBRSxDQUFDLENBQUM7SUFDOUQsQ0FBQztJQUVELE1BQU0sSUFBSSxHQUFHLE1BQU0sUUFBUSxDQUFDLElBQUksRUFBRSxDQUFDO0lBRW5DLElBQUksQ0FBQyxJQUFJLENBQUMsT0FBTyxFQUFFLENBQUM7UUFDbEIsTUFBTSxJQUFJLEtBQUssQ0FBQyxzQkFBc0IsQ0FBQyxDQUFDO0lBQzFDLENBQUM7SUFFRCxNQUFNLFNBQVMsR0FBRyxJQUFJLENBQUMsSUFBSSxFQUFFLE1BQU0sSUFBSSxFQUFFLENBQUM7SUFDMUMsT0FBTyxTQUFTLENBQUMsR0FBRyxDQUFDLENBQUMsR0FBUSxFQUFFLEVBQUUsQ0FBQyxJQUFBLDBCQUFjLEVBQUMsR0FBRyxFQUFFLEtBQUssQ0FBQyxDQUFDLENBQUM7QUFDakUsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEVtYWlsSW5mbywgRW1haWwsIENoYW5uZWwgfSBmcm9tICcuLi90eXBlcyc7XG5pbXBvcnQgeyBub3JtYWxpemVFbWFpbCB9IGZyb20gJy4uL25vcm1hbGl6ZSc7XG5cbmNvbnN0IENIQU5ORUw6IENoYW5uZWwgPSAnY2hhdGdwdC1vcmctdWsnO1xuY29uc3QgQkFTRV9VUkwgPSAnaHR0cHM6Ly9tYWlsLmNoYXRncHQub3JnLnVrL2FwaSc7XG5cbmNvbnN0IERFRkFVTFRfSEVBREVSUyA9IHtcbiAgJ1VzZXItQWdlbnQnOiAnTW96aWxsYS81LjAgKFdpbmRvd3MgTlQgMTAuMDsgV2luNjQ7IHg2NCkgQXBwbGVXZWJLaXQvNTM3LjM2IChLSFRNTCwgbGlrZSBHZWNrbykgQ2hyb21lLzE0My4wLjAuMCBTYWZhcmkvNTM3LjM2JyxcbiAgJ0NvbnRlbnQtVHlwZSc6ICdhcHBsaWNhdGlvbi9qc29uJyxcbiAgJ0FjY2VwdCc6ICcqLyonLFxuICAnUmVmZXJlcic6ICdodHRwczovL21haWwuY2hhdGdwdC5vcmcudWsvJyxcbiAgJ3NlYy1jaC11YSc6ICdcIk1pY3Jvc29mdCBFZGdlXCI7dj1cIjE0M1wiLCBcIkNocm9taXVtXCI7dj1cIjE0M1wiLCBcIk5vdCBBKEJyYW5kXCI7dj1cIjI0XCInLFxuICAnc2VjLWNoLXVhLW1vYmlsZSc6ICc/MCcsXG4gICdzZWMtY2gtdWEtcGxhdGZvcm0nOiAnXCJXaW5kb3dzXCInLFxuICAnRE5UJzogJzEnLFxufTtcblxuZXhwb3J0IGFzeW5jIGZ1bmN0aW9uIGdlbmVyYXRlRW1haWwoKTogUHJvbWlzZTxFbWFpbEluZm8+IHtcbiAgY29uc3QgcmVzcG9uc2UgPSBhd2FpdCBmZXRjaChgJHtCQVNFX1VSTH0vZ2VuZXJhdGUtZW1haWxgLCB7XG4gICAgbWV0aG9kOiAnR0VUJyxcbiAgICBoZWFkZXJzOiBERUZBVUxUX0hFQURFUlMsXG4gIH0pO1xuXG4gIGlmICghcmVzcG9uc2Uub2spIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYEZhaWxlZCB0byBnZW5lcmF0ZSBlbWFpbDogJHtyZXNwb25zZS5zdGF0dXN9YCk7XG4gIH1cblxuICBjb25zdCBkYXRhID0gYXdhaXQgcmVzcG9uc2UuanNvbigpO1xuICBcbiAgaWYgKCFkYXRhLnN1Y2Nlc3MpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ0ZhaWxlZCB0byBnZW5lcmF0ZSBlbWFpbCcpO1xuICB9XG5cbiAgcmV0dXJuIHtcbiAgICBjaGFubmVsOiBDSEFOTkVMLFxuICAgIGVtYWlsOiBkYXRhLmRhdGEuZW1haWwsXG4gIH07XG59XG5cbmV4cG9ydCBhc3luYyBmdW5jdGlvbiBnZXRFbWFpbHMoZW1haWw6IHN0cmluZyk6IFByb21pc2U8RW1haWxbXT4ge1xuICBjb25zdCBlbmNvZGVkRW1haWwgPSBlbmNvZGVVUklDb21wb25lbnQoZW1haWwpO1xuICBjb25zdCByZXNwb25zZSA9IGF3YWl0IGZldGNoKGAke0JBU0VfVVJMfS9lbWFpbHM/ZW1haWw9JHtlbmNvZGVkRW1haWx9YCwge1xuICAgIG1ldGhvZDogJ0dFVCcsXG4gICAgaGVhZGVyczogREVGQVVMVF9IRUFERVJTLFxuICB9KTtcblxuICBpZiAoIXJlc3BvbnNlLm9rKSB7XG4gICAgdGhyb3cgbmV3IEVycm9yKGBGYWlsZWQgdG8gZ2V0IGVtYWlsczogJHtyZXNwb25zZS5zdGF0dXN9YCk7XG4gIH1cblxuICBjb25zdCBkYXRhID0gYXdhaXQgcmVzcG9uc2UuanNvbigpO1xuICBcbiAgaWYgKCFkYXRhLnN1Y2Nlc3MpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoJ0ZhaWxlZCB0byBnZXQgZW1haWxzJyk7XG4gIH1cblxuICBjb25zdCByYXdFbWFpbHMgPSBkYXRhLmRhdGE/LmVtYWlscyB8fCBbXTtcbiAgcmV0dXJuIHJhd0VtYWlscy5tYXAoKHJhdzogYW55KSA9PiBub3JtYWxpemVFbWFpbChyYXcsIGVtYWlsKSk7XG59XG4iXX0=

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[]>;

package/dist/providers/mail-tm.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEmail = generateEmail;
+exports.getEmails = getEmails;
+const normalize_1 = require("../normalize");
+const CHANNEL = 'mail-tm';
+const BASE_URL = 'https://api.mail.tm';
+const DEFAULT_HEADERS = {
+    'Content-Type': 'application/json',
+    'Accept': 'application/json',
+};
+/**
+ * 生成随机字符串
+ */
+function randomString(length) {
+    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+        result += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return result;
+}
+/**
+ * 获取可用域名列表
+ * API: GET /domains
+ */
+async function getDomains() {
+    const response = await fetch(`${BASE_URL}/domains`, {
+        method: 'GET',
+        headers: DEFAULT_HEADERS,
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to get domains: ${response.status}`);
+    }
+    const data = await response.json();
+    const members = data['hydra:member'] || [];
+    return members
+        .filter((d) => d.isActive)
+        .map((d) => d.domain);
+}
+/**
+ * 创建账号
+ * API: POST /accounts
+ */
+async function createAccount(address, password) {
+    const response = await fetch(`${BASE_URL}/accounts`, {
+        method: 'POST',
+        headers: { ...DEFAULT_HEADERS, 'Content-Type': 'application/ld+json' },
+        body: JSON.stringify({ address, password }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Failed to create account: ${response.status} ${text}`);
+    }
+    return response.json();
+}
+/**
+ * 获取 Bearer Token
+ * API: POST /token
+ */
+async function getToken(address, password) {
+    const response = await fetch(`${BASE_URL}/token`, {
+        method: 'POST',
+        headers: DEFAULT_HEADERS,
+        body: JSON.stringify({ address, password }),
+    });
+    if (!response.ok) {
+        throw new Error(`Failed to get token: ${response.status}`);
+    }
+    const data = await response.json();
+    return data.token;
+}
+/**
+ * 创建临时邮箱
+ * 流程: 获取域名 → 生成随机邮箱/密码 → 创建账号 → 获取 Token
+ */
+async function generateEmail() {
+    // 1. 获取可用域名
+    const domains = await getDomains();
+    if (domains.length === 0) {
+        throw new Error('No available domains');
+    }
+    // 2. 生成随机邮箱和密码
+    const domain = domains[Math.floor(Math.random() * domains.length)];
+    const username = randomString(12);
+    const address = `${username}@${domain}`;
+    const password = randomString(16);
+    // 3. 创建账号
+    const account = await createAccount(address, password);
+    // 4. 获取 Bearer Token
+    const token = await getToken(address, password);
+    return {
+        channel: CHANNEL,
+        email: address,
+        token: token,
+        createdAt: account.createdAt,
+    };
+}
+/**
+ * 将 mail.tm 的消息格式扁平化为 normalizeEmail 可处理的格式
+ * mail.tm 的 from 是 {name, address} 对象，to 是数组，html 是字符串数组
+ */
+function flattenMessage(msg, recipientEmail) {
+    return {
+        id: msg.id || '',
+        from: msg.from?.address || '',
+        to: msg.to?.[0]?.address || recipientEmail,
+        subject: msg.subject || '',
+        text: msg.text || '',
+        html: Array.isArray(msg.html) ? msg.html.join('') : (msg.html || ''),
+        createdAt: msg.createdAt || '',
+        seen: msg.seen ?? false,
+        attachments: (msg.attachments || []).map((a) => ({
+            filename: a.filename || '',
+            size: a.size || undefined,
+            contentType: a.contentType || undefined,
+            downloadUrl: a.downloadUrl ? `${BASE_URL}${a.downloadUrl}` : undefined,
+        })),
+    };
+}
+/**
+ * 获取邮件列表
+ * 流程: GET /messages 获取列表 → 对每封邮件 GET /messages/{id} 获取详情（含 text/html）
+ */
+async function getEmails(token, email) {
+    // 1. 获取邮件列表
+    const listResponse = await fetch(`${BASE_URL}/messages`, {
+        method: 'GET',
+        headers: {
+            ...DEFAULT_HEADERS,
+            'Authorization': `Bearer ${token}`,
+        },
+    });
+    if (!listResponse.ok) {
+        throw new Error(`Failed to get emails: ${listResponse.status}`);
+    }
+    const listData = await listResponse.json();
+    const messages = listData['hydra:member'] || [];
+    if (messages.length === 0) {
+        return [];
+    }
+    // 2. 并行获取每封邮件的详情（含 text/html/attachments）
+    const detailPromises = messages.map(async (msg) => {
+        try {
+            const detailResponse = await fetch(`${BASE_URL}/messages/${msg.id}`, {
+                method: 'GET',
+                headers: {
+                    ...DEFAULT_HEADERS,
+                    'Authorization': `Bearer ${token}`,
+                },
+            });
+            if (!detailResponse.ok) {
+                // 如果详情获取失败，退回使用列表数据
+                return flattenMessage(msg, email);
+            }
+            const detail = await detailResponse.json();
+            return flattenMessage(detail, email);
+        }
+        catch {
+            // 出错时退回使用列表数据
+            return flattenMessage(msg, 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"]}

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

@@ -0,0 +1,13 @@
+import { EmailInfo, Email } from '../types';
+/**
+ * 创建临时邮箱
+ * API: POST /api/v3/email/new
+ * 返回: { email, token }
+ */
+export declare function generateEmail(): Promise<EmailInfo>;
+/**
+ * 获取邮件列表
+ * API: GET /api/v3/email/{email}/messages
+ * 返回: [ { id, from, to, cc, subject, body_text, body_html, created_at, attachments } ]
+ */
+export declare function getEmails(email: string): Promise<Email[]>;