tempmail-sdk 1.1.3 → 1.1.4

package/src/providers/chatgpt-org-uk.ts

@@ -7,56 +7,90 @@ const BASE_URL = 'https://mail.chatgpt.org.uk/api';
 const HOME_URL = 'https://mail.chatgpt.org.uk/';
 
 const DEFAULT_HEADERS = {
-  'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36',
-  'Accept': '*/*',
-  'Referer': 'https://mail.chatgpt.org.uk/',
-  'Origin': 'https://mail.chatgpt.org.uk',
-  'DNT': '1',
+  'User-Agent':
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36',
+  Accept: '*/*',
+  Referer: 'https://mail.chatgpt.org.uk/',
+  Origin: 'https://mail.chatgpt.org.uk',
+  DNT: '1',
 };
 
+/** 从首页 HTML 解析 window.__BROWSER_AUTH（服务端注入的会话 JWT，供 X-Inbox-Token） */
+function extractBrowserAuthToken(html: string): string {
+  const m = html.match(/__BROWSER_AUTH\s*=\s*(\{[\s\S]*?\})\s*;/);
+  if (!m) {
+    return '';
+  }
+  try {
+    const o = JSON.parse(m[1]) as { token?: string };
+    return typeof o.token === 'string' ? o.token : '';
+  } catch {
+    return '';
+  }
+}
+
 function extractGmSid(response: Response): string {
+  const h = response.headers as Headers & { getSetCookie?: () => string[] };
+  if (typeof h.getSetCookie === 'function') {
+    for (const line of h.getSetCookie()) {
+      const match = line.match(/^gm_sid=([^;]+)/);
+      if (match) {
+        return match[1];
+      }
+    }
+  }
   const setCookie = response.headers.get('set-cookie') || '';
   const match = setCookie.match(/gm_sid=([^;]+)/);
   return match ? match[1] : '';
 }
 
-async function fetchGmSid(): Promise<string> {
+async function fetchHomeSession(): Promise<{ gmSid: string; browserToken: string }> {
   const response = await fetchWithTimeout(HOME_URL, {
     method: 'GET',
     headers: DEFAULT_HEADERS,
   });
 
   if (!response.ok) {
-    throw new Error(`Failed to fetch gm_sid: ${response.status}`);
+    throw new Error(`Failed to load mail.chatgpt.org.uk: ${response.status}`);
   }
 
+  const html = await response.text();
   const gmSid = extractGmSid(response);
+  const browserToken = extractBrowserAuthToken(html);
+
   if (!gmSid) {
     throw new Error('Failed to extract gm_sid cookie');
   }
+  if (!browserToken) {
+    throw new Error('Failed to extract __BROWSER_AUTH from homepage (API now requires browser session)');
+  }
 
-  return gmSid;
+  return { gmSid, browserToken };
 }
 
-async function fetchGmSidWithRetry(): Promise<string> {
+async function fetchHomeSessionWithRetry(): Promise<{ gmSid: string; browserToken: string }> {
   try {
-    return await fetchGmSid();
+    return await fetchHomeSession();
   } catch (error: any) {
     const message = String(error?.message || error || '').toLowerCase();
-    if (message.includes('401') || message.includes('extract gm_sid')) {
-      return await fetchGmSid();
+    if (message.includes('401') || message.includes('429') || message.includes('extract')) {
+      return await fetchHomeSession();
     }
     throw error;
   }
 }
 
+function sleepMs(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
 async function fetchInboxToken(email: string, gmSid: string): Promise<string> {
   const response = await fetchWithTimeout(`${BASE_URL}/inbox-token`, {
     method: 'POST',
     headers: {
       ...DEFAULT_HEADERS,
       'Content-Type': 'application/json',
-      'Cookie': `gm_sid=${gmSid}`,
+      Cookie: `gm_sid=${gmSid}`,
     },
     body: JSON.stringify({ email }),
   });
@@ -74,30 +108,53 @@ async function fetchInboxToken(email: string, gmSid: string): Promise<string> {
   return token;
 }
 
-async function fetchInboxTokenWithRetry(email: string): Promise<string> {
-  const gmSid = await fetchGmSidWithRetry();
+async function fetchInboxTokenWithRetry(email: string, gmSid: string): Promise<string> {
   try {
     return await fetchInboxToken(email, gmSid);
   } catch (error: any) {
     const message = String(error?.message || error || '').toLowerCase();
     if (message.includes('401')) {
-      const refreshedGmSid = await fetchGmSidWithRetry();
-      return await fetchInboxToken(email, refreshedGmSid);
+      const { gmSid: sid } = await fetchHomeSessionWithRetry();
+      return await fetchInboxToken(email, sid);
     }
     throw error;
   }
 }
 
-async function fetchEmails(token: string, email: string): Promise<Email[]> {
-  if (!token) {
+/** 列表接口需同时带 Cookie gm_sid 与 x-inbox-token，否则返回 401 */
+function parseChatgptPackedToken(packed: string): { gmSid: string; inbox: string } {
+  const t = packed.trim();
+  if (t.startsWith('{')) {
+    try {
+      const o = JSON.parse(t) as { gmSid?: string; inbox?: string };
+      if (typeof o.gmSid === 'string' && typeof o.inbox === 'string') {
+        return { gmSid: o.gmSid, inbox: o.inbox };
+      }
+    } catch {
+      /* ignore */
+    }
+  }
+  return { gmSid: '', inbox: packed };
+}
+
+async function fetchEmails(
+  inboxToken: string,
+  email: string,
+  gmSid: string,
+): Promise<Email[]> {
+  if (!inboxToken) {
     throw new Error('internal error: token missing for chatgpt-org-uk');
   }
+  if (!gmSid) {
+    throw new Error('internal error: gm_sid missing for chatgpt-org-uk');
+  }
   const encodedEmail = encodeURIComponent(email);
   const response = await fetchWithTimeout(`${BASE_URL}/emails?email=${encodedEmail}`, {
     method: 'GET',
     headers: {
       ...DEFAULT_HEADERS,
-      'x-inbox-token': token,
+      Cookie: `gm_sid=${gmSid}`,
+      'x-inbox-token': inboxToken,
     },
   });
 
@@ -115,44 +172,58 @@ async function fetchEmails(token: string, email: string): Promise<Email[]> {
   return rawEmails.map((raw: any) => normalizeEmail(raw, email));
 }
 
-async function fetchEmailsWithRetry(email: string): Promise<Email[]> {
-  const token = await fetchInboxTokenWithRetry(email);
-  try {
-    return await fetchEmails(token, email);
-  } catch (error: any) {
-    const message = String(error?.message || error || '').toLowerCase();
-    if (message.includes('401')) {
-      const refreshedToken = await fetchInboxTokenWithRetry(email);
-      return await fetchEmails(refreshedToken, email);
+export async function generateEmail(): Promise<InternalEmailInfo> {
+  /*
+   * generate-email 常返回 429；每次重试前重新拉首页以换新 gm_sid / __BROWSER_AUTH，并做指数退避。
+   */
+  const maxAttempts = 6;
+  let lastStatus = 0;
+
+  for (let attempt = 0; attempt < maxAttempts; attempt++) {
+    const { gmSid, browserToken } = await fetchHomeSessionWithRetry();
+
+    const response = await fetchWithTimeout(`${BASE_URL}/generate-email`, {
+      method: 'GET',
+      headers: {
+        ...DEFAULT_HEADERS,
+        Cookie: `gm_sid=${gmSid}`,
+        'X-Inbox-Token': browserToken,
+      },
+    });
+
+    if (response.status === 429) {
+      lastStatus = 429;
+      if (attempt < maxAttempts - 1) {
+        const wait = Math.min(3000 * 2 ** attempt, 60_000);
+        await sleepMs(wait);
+        continue;
+      }
+      throw new Error('Failed to generate email: 429');
     }
-    throw error;
-  }
-}
 
-export async function generateEmail(): Promise<InternalEmailInfo> {
-  const response = await fetchWithTimeout(`${BASE_URL}/generate-email`, {
-    method: 'GET',
-    headers: DEFAULT_HEADERS,
-  });
+    if (!response.ok) {
+      lastStatus = response.status;
+      throw new Error(`Failed to generate email: ${response.status}`);
+    }
 
-  if (!response.ok) {
-    throw new Error(`Failed to generate email: ${response.status}`);
-  }
+    const data = await response.json();
 
-  const data = await response.json();
+    if (!data.success) {
+      throw new Error('Failed to generate email');
+    }
 
-  if (!data.success) {
-    throw new Error('Failed to generate email');
-  }
+    const email = data.data.email as string;
+    const tokenFromAuth = data.auth?.token as string | undefined;
+    const inboxJwt = tokenFromAuth || (await fetchInboxTokenWithRetry(email, gmSid));
 
-  const email = data.data.email;
-  const token = await fetchInboxTokenWithRetry(email);
+    return {
+      channel: CHANNEL,
+      email,
+      token: JSON.stringify({ gmSid, inbox: inboxJwt }),
+    };
+  }
 
-  return {
-    channel: CHANNEL,
-    email,
-    token,
-  };
+  throw new Error(`Failed to generate email: ${lastStatus || 'unknown'}`);
 }
 
 export async function getEmails(token: string, email: string): Promise<Email[]> {
@@ -160,12 +231,19 @@ export async function getEmails(token: string, email: string): Promise<Email[]>
     throw new Error('internal error: token missing for chatgpt-org-uk');
   }
 
+  let { gmSid, inbox } = parseChatgptPackedToken(token);
+  if (!gmSid) {
+    gmSid = (await fetchHomeSessionWithRetry()).gmSid;
+  }
+
   try {
-    return await fetchEmails(token, email);
+    return await fetchEmails(inbox, email, gmSid);
   } catch (error: any) {
     const message = String(error?.message || error || '').toLowerCase();
     if (message.includes('401')) {
-      return await fetchEmailsWithRetry(email);
+      const sess = await fetchHomeSessionWithRetry();
+      const newInbox = await fetchInboxTokenWithRetry(email, sess.gmSid);
+      return await fetchEmails(newInbox, email, sess.gmSid);
     }
     throw error;
   }

package/src/providers/dropmail.ts

@@ -1,9 +1,168 @@
 import { InternalEmailInfo, Email, Channel } from '../types';
 import { normalizeEmail } from '../normalize';
 import { fetchWithTimeout } from '../retry';
+import { getConfig } from '../config';
 
 const CHANNEL: Channel = 'dropmail';
-const BASE_URL = 'https://dropmail.me/api/graphql/MY_TOKEN';
+
+const TOKEN_GENERATE_URL = 'https://dropmail.me/api/token/generate';
+const TOKEN_RENEW_URL = 'https://dropmail.me/api/token/renew';
+/** 申请 1h 令牌，缓存略短于 1h，避免边界过期 */
+const AUTO_TOKEN_CACHE_MS = 50 * 60 * 1000;
+/** 距缓存过期前多久触发 renew（毫秒） */
+const RENEW_BEFORE_EXPIRY_MS = 10 * 60 * 1000;
+
+function cacheMsForLifetime(lifetime: string): number {
+  const s = lifetime.trim().toLowerCase();
+  if (s === '1h') return 50 * 60 * 1000;
+  if (s === '1d') return 23 * 60 * 60 * 1000;
+  if (s === '7d' || s === '30d' || s === '90d') {
+    const days = parseInt(s, 10);
+    return Math.max(0, days - 1) * 24 * 60 * 60 * 1000;
+  }
+  return AUTO_TOKEN_CACHE_MS;
+}
+
+function dropmailRenewLifetime(): string {
+  const c = getConfig().dropmailRenewLifetime?.trim();
+  if (c) return c;
+  const e =
+    typeof process !== 'undefined' && process.env?.DROPMAIL_RENEW_LIFETIME?.trim();
+  return e || '1d';
+}
+
+const TOKEN_HEADERS: Record<string, string> = {
+  Accept: 'application/json',
+  'Content-Type': 'application/json',
+  Origin: 'https://dropmail.me',
+  Referer: 'https://dropmail.me/api/',
+};
+
+let cachedAfToken: { value: string; expiresAt: number } | null = null;
+let tokenFetchInFlight: Promise<string> | null = null;
+
+function explicitDropmailAuthToken(): string | undefined {
+  const fromConfig = getConfig().dropmailAuthToken?.trim();
+  const fromEnv =
+    typeof process !== 'undefined' && process.env
+      ? process.env.DROPMAIL_AUTH_TOKEN?.trim() || process.env.DROPMAIL_API_TOKEN?.trim()
+      : undefined;
+  return fromConfig || fromEnv;
+}
+
+function dropmailAutoTokenDisabled(): boolean {
+  if (getConfig().dropmailDisableAutoToken) {
+    return true;
+  }
+  const v = typeof process !== 'undefined' && process.env?.DROPMAIL_NO_AUTO_TOKEN?.trim().toLowerCase();
+  return v === '1' || v === 'true' || v === 'yes';
+}
+
+async function fetchAfTokenFromApi(): Promise<string> {
+  const response = await fetchWithTimeout(TOKEN_GENERATE_URL, {
+    method: 'POST',
+    headers: TOKEN_HEADERS,
+    body: JSON.stringify({ type: 'af', lifetime: '1h' }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`DropMail token/generate HTTP ${response.status}`);
+  }
+
+  const body = (await response.json()) as { token?: string; error?: string };
+  const token = typeof body.token === 'string' ? body.token.trim() : '';
+  if (!token || !token.startsWith('af_')) {
+    throw new Error(
+      body.error || 'DropMail token/generate 未返回有效 af_ 令牌',
+    );
+  }
+  return token;
+}
+
+async function renewAfTokenFromApi(currentToken: string, lifetime: string): Promise<string> {
+  const response = await fetchWithTimeout(TOKEN_RENEW_URL, {
+    method: 'POST',
+    headers: TOKEN_HEADERS,
+    body: JSON.stringify({ token: currentToken, lifetime }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`DropMail token/renew HTTP ${response.status}`);
+  }
+
+  const body = (await response.json()) as { token?: string; error?: string };
+  const token = typeof body.token === 'string' ? body.token.trim() : '';
+  if (!token || !token.startsWith('af_')) {
+    throw new Error(body.error || 'DropMail token/renew 未返回有效 af_ 令牌');
+  }
+  return token;
+}
+
+/**
+ * 解析 GraphQL 用的 af_ 令牌：优先配置/环境变量，否则 generate + 缓存，将过期时 renew。
+ */
+async function resolveDropmailAuthToken(): Promise<string> {
+  const explicit = explicitDropmailAuthToken();
+  if (explicit) {
+    return explicit;
+  }
+
+  if (dropmailAutoTokenDisabled()) {
+    throw new Error(
+      'DropMail 已禁用自动令牌：请设置 DROPMAIL_AUTH_TOKEN，或 setConfig({ dropmailAuthToken: "af_..." })，见 https://dropmail.me/api/',
+    );
+  }
+
+  const now = Date.now();
+  if (
+    cachedAfToken &&
+    now < cachedAfToken.expiresAt - RENEW_BEFORE_EXPIRY_MS
+  ) {
+    return cachedAfToken.value;
+  }
+
+  if (tokenFetchInFlight) {
+    return tokenFetchInFlight;
+  }
+
+  const renewLifetime = dropmailRenewLifetime();
+
+  tokenFetchInFlight = (async () => {
+    try {
+      if (cachedAfToken?.value) {
+        try {
+          const renewed = await renewAfTokenFromApi(
+            cachedAfToken.value,
+            renewLifetime,
+          );
+          cachedAfToken = {
+            value: renewed,
+            expiresAt: Date.now() + cacheMsForLifetime(renewLifetime),
+          };
+          return renewed;
+        } catch {
+          /* 续期失败则重新申请 */
+        }
+      }
+
+      const token = await fetchAfTokenFromApi();
+      cachedAfToken = {
+        value: token,
+        expiresAt: Date.now() + AUTO_TOKEN_CACHE_MS,
+      };
+      return token;
+    } finally {
+      tokenFetchInFlight = null;
+    }
+  })();
+
+  return tokenFetchInFlight;
+}
+
+async function dropmailGraphqlUrl(): Promise<string> {
+  const token = await resolveDropmailAuthToken();
+  return `https://dropmail.me/api/graphql/${encodeURIComponent(token)}`;
+}
 
 const DEFAULT_HEADERS: Record<string, string> = {
   'Content-Type': 'application/x-www-form-urlencoded',
@@ -30,7 +189,7 @@ async function graphqlRequest(query: string, variables?: Record<string, any>): P
     params.set('variables', JSON.stringify(variables));
   }
 
-  const response = await fetchWithTimeout(BASE_URL, {
+  const response = await fetchWithTimeout(await dropmailGraphqlUrl(), {
     method: 'POST',
     headers: DEFAULT_HEADERS,
     body: params.toString(),

package/src/providers/linshi-email.ts

@@ -1,10 +1,10 @@
 import { InternalEmailInfo, Email, Channel } from '../types';
 import { normalizeEmail } from '../normalize';
 import { fetchWithTimeout } from '../retry';
+import { randomSyntheticLinshiKey } from './linshi-token';
 
 const CHANNEL: Channel = 'linshi-email';
 const BASE_URL = 'https://www.linshi-email.com/api/v1';
-const API_KEY = '552562b8524879814776e52bc8de5c9f';
 
 const DEFAULT_HEADERS = {
   'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/143.0.0.0 Safari/537.36',
@@ -18,7 +18,8 @@ const DEFAULT_HEADERS = {
 };
 
 export async function generateEmail(): Promise<InternalEmailInfo> {
-  const response = await fetchWithTimeout(`${BASE_URL}/email/${API_KEY}`, {
+  const { apiPathKey } = randomSyntheticLinshiKey();
+  const response = await fetchWithTimeout(`${BASE_URL}/email/${apiPathKey}`, {
     method: 'POST',
     headers: DEFAULT_HEADERS,
     body: JSON.stringify({}),
@@ -29,22 +30,37 @@ export async function generateEmail(): Promise<InternalEmailInfo> {
   }
 
   const data = await response.json();
-  
+
   if (data.status !== 'ok') {
     throw new Error('Failed to generate email');
   }
 
+  const d = data.data;
+  const raw =
+    (typeof d?.email === 'string' && d.email) ||
+    (typeof d?.mail === 'string' && d.mail) ||
+    (typeof d?.address === 'string' && d.address) ||
+    '';
+  const email = String(raw).trim();
+
+  if (!email || !email.includes('@')) {
+    throw new Error(
+      'linshi-email: API 未返回有效邮箱地址（data 为空或缺 email 字段，常见于频率限制：每小时约 10 个 / 每天约 20 个）',
+    );
+  }
+
   return {
     channel: CHANNEL,
-    email: data.data.email,
-    expiresAt: data.data.expired,
+    email,
+    expiresAt: d?.expired,
+    token: apiPathKey,
   };
 }
 
-export async function getEmails(email: string): Promise<Email[]> {
+export async function getEmails(email: string, apiPathKey: string): Promise<Email[]> {
   const encodedEmail = encodeURIComponent(email);
   const timestamp = Date.now();
-  const response = await fetchWithTimeout(`${BASE_URL}/refreshmessage/${API_KEY}/${encodedEmail}?t=${timestamp}`, {
+  const response = await fetchWithTimeout(`${BASE_URL}/refreshmessage/${apiPathKey}/${encodedEmail}?t=${timestamp}`, {
     method: 'GET',
     headers: DEFAULT_HEADERS,
   });

package/src/providers/linshi-token.ts

@@ -0,0 +1,86 @@
+import { createHash, randomBytes, randomInt } from 'crypto';
+export function deriveLinshiApiPathKey(visitorId: string): string {
+  if (visitorId.length < 4) {
+    throw new Error('visitorId 过短，无法套用 u()');
+  }
+  let e = visitorId.substring(0, visitorId.length - 2);
+  let t = 0;
+  for (let i = 0; i < e.length; i++) {
+    t += e.charCodeAt(i) % 5;
+  }
+  if (t < 10) {
+    t = 10;
+  }
+  if (t >= 100) {
+    t = 99;
+  }
+  const ts = t.toString();
+  e = e.slice(0, 3) + ts[0] + e.slice(3);
+  e = e.slice(0, 12) + ts[1] + e.slice(12);
+  return e;
+}
+export interface SyntheticBrowserProfile {
+  userAgent: string;
+  platform: string;
+  language: string;
+  languages: string;
+  hardwareConcurrency: number;
+  deviceMemory: number;
+  timezone: string;
+  colorDepth: number;
+  pixelRatio: number;
+  screen: { width: number; height: number; availWidth: number; availHeight: number };
+}
+
+const UA_POOL = [
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0',
+  'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36',
+  'Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:122.0) Gecko/20100101 Firefox/122.0',
+];
+
+function pick<T>(arr: T[]): T {
+  return arr[randomInt(arr.length)];
+}
+
+export function randomBrowserLikeProfile(): SyntheticBrowserProfile {
+  const w = pick([1920, 2560, 1680, 1536, 1366]) + randomInt(0, 80);
+  const h = pick([1080, 1440, 1050, 864, 768]) + randomInt(0, 40);
+  return {
+    userAgent: pick(UA_POOL),
+    platform: pick(['Win32', 'MacIntel', 'Linux x86_64']),
+    language: pick(['zh-CN', 'en-US', 'en-GB', 'ja-JP']),
+    languages: pick(['zh-CN,zh,en', 'en-US,en', 'ja-JP,ja,en']),
+    hardwareConcurrency: randomInt(4, 33),
+    deviceMemory: pick([4, 8, 16]),
+    timezone: pick(['Asia/Shanghai', 'America/New_York', 'Europe/London', 'UTC']),
+    colorDepth: pick([24, 30]),
+    pixelRatio: pick([1, 1.25, 1.5, 2]),
+    screen: {
+      width: w,
+      height: h,
+      availWidth: w,
+      availHeight: h - randomInt(24, 120),
+    },
+  };
+}
+
+export function syntheticVisitorIdFromProfile(
+  profile: SyntheticBrowserProfile,
+  salt: Buffer = randomBytes(16),
+): string {
+  const payload = JSON.stringify(profile, Object.keys(profile).sort());
+  return createHash('sha256').update(payload).update(salt).digest('hex').slice(0, 32);
+}
+
+export function randomSyntheticLinshiKey(): {
+  profile: SyntheticBrowserProfile;
+  visitorId: string;
+  apiPathKey: string;
+} {
+  const profile = randomBrowserLikeProfile();
+  const visitorId = syntheticVisitorIdFromProfile(profile);
+  const apiPathKey = deriveLinshiApiPathKey(visitorId);
+  return { profile, visitorId, apiPathKey };
+}