tempmail-sdk 1.1.8 → 1.2.0

package/dist/providers/tempmail-cn.js

@@ -0,0 +1,341 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateEmail = generateEmail;
+exports.getEmails = getEmails;
+const ws_1 = __importDefault(require("ws"));
+const normalize_1 = require("../normalize");
+const CHANNEL = 'tempmail-cn';
+const DEFAULT_HOST = 'tempmail.cn';
+const CONNECT_TIMEOUT_MS = 15000;
+const HANDSHAKE_WAIT_MS = 1000;
+const INITIAL_SYNC_WAIT_MS = 80;
+const SOCKET_IO_VERSIONS = [4, 3];
+const DEFAULT_HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0',
+    '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',
+    Pragma: 'no-cache',
+};
+const mailboxes = new Map();
+function getState(email) {
+    const key = email.trim().toLowerCase();
+    let st = mailboxes.get(key);
+    if (!st) {
+        st = { emails: [], seenIds: new Set(), ws: null };
+        mailboxes.set(key, st);
+    }
+    return st;
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function normalizeHost(domain) {
+    const raw = String(domain || '').trim();
+    if (!raw) {
+        return DEFAULT_HOST;
+    }
+    let host = raw;
+    if (/^https?:\/\//i.test(host)) {
+        try {
+            host = new URL(host).host;
+        }
+        catch {
+            host = raw;
+        }
+    }
+    else if (host.includes('/')) {
+        try {
+            host = new URL(`https://${host}`).host;
+        }
+        catch {
+            host = host.split('/')[0];
+        }
+    }
+    host = host.replace(/^\.+|\.+$/g, '');
+    const at = host.lastIndexOf('@');
+    if (at >= 0) {
+        host = host.slice(at + 1);
+    }
+    return host || DEFAULT_HOST;
+}
+function splitAddress(email) {
+    const trimmed = email.trim();
+    const at = trimmed.indexOf('@');
+    if (at <= 0 || at === trimmed.length - 1) {
+        throw new Error('tempmail-cn: invalid email address');
+    }
+    return {
+        local: trimmed.slice(0, at),
+        host: normalizeHost(trimmed.slice(at + 1)),
+    };
+}
+function socketUrl(host, eio) {
+    return `wss://${host}/socket.io/?EIO=${eio}&transport=websocket`;
+}
+function socketHeaders(host) {
+    return {
+        ...DEFAULT_HEADERS,
+        Origin: `https://${host}`,
+        Referer: `https://${host}/`,
+    };
+}
+function sendEvent(ws, event, payload) {
+    ws.send(`42${JSON.stringify([event, payload])}`);
+}
+function parseEventPacket(packet) {
+    if (!packet.startsWith('42')) {
+        return null;
+    }
+    try {
+        const decoded = JSON.parse(packet.slice(2));
+        if (!Array.isArray(decoded) || typeof decoded[0] !== 'string') {
+            return null;
+        }
+        return { event: decoded[0], payload: decoded[1] };
+    }
+    catch {
+        return null;
+    }
+}
+function stableMessageId(raw, recipientEmail) {
+    const headers = raw?.headers || {};
+    return String(raw?.id ??
+        raw?.messageId ??
+        headers['message-id'] ??
+        headers.messageId ??
+        `${headers.from || raw?.from || ''}\n${headers.subject || raw?.subject || ''}\n${headers.date || raw?.date || ''}\n${recipientEmail}`);
+}
+function flattenMail(raw, recipientEmail) {
+    const headers = raw?.headers || {};
+    return {
+        id: stableMessageId(raw, recipientEmail),
+        from: headers.from || raw?.from || '',
+        to: recipientEmail,
+        subject: headers.subject || raw?.subject || '',
+        text: raw?.text || raw?.body || '',
+        html: raw?.html || '',
+        date: headers.date || raw?.date || '',
+        isRead: false,
+        attachments: Array.isArray(raw?.attachments) ? raw.attachments : [],
+    };
+}
+async function connectSocket(host) {
+    let lastError = null;
+    for (const version of SOCKET_IO_VERSIONS) {
+        try {
+            return await new Promise((resolve, reject) => {
+                const ws = new ws_1.default(socketUrl(host, version), {
+                    handshakeTimeout: CONNECT_TIMEOUT_MS,
+                    headers: socketHeaders(host),
+                });
+                let timer;
+                let sentConnect = false;
+                let settled = false;
+                const cleanup = () => {
+                    if (timer) {
+                        clearTimeout(timer);
+                        timer = undefined;
+                    }
+                    ws.off('message', onMessage);
+                    ws.off('error', onError);
+                    ws.off('close', onClose);
+                };
+                const resolveOnce = () => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    resolve(ws);
+                };
+                const rejectOnce = (err) => {
+                    if (settled)
+                        return;
+                    settled = true;
+                    cleanup();
+                    try {
+                        ws.close();
+                    }
+                    catch {
+                        /* ignore close errors */
+                    }
+                    reject(err);
+                };
+                const armHandshakeFallback = () => {
+                    if (timer)
+                        return;
+                    timer = setTimeout(resolveOnce, HANDSHAKE_WAIT_MS);
+                };
+                const onMessage = (data) => {
+                    const packet = data.toString();
+                    if (packet === '2') {
+                        try {
+                            ws.send('3');
+                        }
+                        catch {
+                            /* ignore send errors during probing */
+                        }
+                        return;
+                    }
+                    if (!sentConnect) {
+                        if (!packet.startsWith('0')) {
+                            rejectOnce(new Error(`tempmail-cn: unexpected open packet for EIO=${version}`));
+                            return;
+                        }
+                        sentConnect = true;
+                        try {
+                            ws.send('40');
+                        }
+                        catch (error) {
+                            rejectOnce(error instanceof Error ? error : new Error(String(error)));
+                            return;
+                        }
+                        armHandshakeFallback();
+                        return;
+                    }
+                    if (packet.startsWith('40')) {
+                        resolveOnce();
+                    }
+                };
+                const onError = (error) => rejectOnce(error);
+                const onClose = () => rejectOnce(new Error(`tempmail-cn: websocket closed during EIO=${version} handshake`));
+                ws.on('message', onMessage);
+                ws.once('error', onError);
+                ws.once('close', onClose);
+            });
+        }
+        catch (error) {
+            lastError = error instanceof Error ? error : new Error(String(error));
+        }
+    }
+    throw lastError || new Error('tempmail-cn: websocket handshake failed');
+}
+async function requestShortId(host) {
+    const ws = await connectSocket(host);
+    return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+            cleanup();
+            try {
+                ws.close();
+            }
+            catch {
+                /* ignore close errors */
+            }
+            reject(new Error('tempmail-cn: timed out waiting for shortid'));
+        }, CONNECT_TIMEOUT_MS);
+        const cleanup = () => {
+            clearTimeout(timer);
+            ws.off('message', onMessage);
+            ws.off('error', onError);
+            ws.off('close', onClose);
+        };
+        const finish = (value) => {
+            cleanup();
+            try {
+                ws.close();
+            }
+            catch {
+                /* ignore close errors */
+            }
+            resolve(value);
+        };
+        const fail = (error) => {
+            cleanup();
+            try {
+                ws.close();
+            }
+            catch {
+                /* ignore close errors */
+            }
+            reject(error);
+        };
+        const onMessage = (data) => {
+            const packet = data.toString();
+            if (packet === '2') {
+                ws.send('3');
+                return;
+            }
+            const decoded = parseEventPacket(packet);
+            if (!decoded || decoded.event !== 'shortid' || typeof decoded.payload !== 'string') {
+                return;
+            }
+            finish(decoded.payload);
+        };
+        const onError = (error) => fail(error);
+        const onClose = () => fail(new Error('tempmail-cn: websocket closed before shortid arrived'));
+        ws.on('message', onMessage);
+        ws.once('error', onError);
+        ws.once('close', onClose);
+        sendEvent(ws, 'request shortid', true);
+    });
+}
+async function ensureMailbox(email) {
+    const st = getState(email);
+    if (st.ws?.readyState === ws_1.default.OPEN) {
+        return;
+    }
+    if (st.connectPromise) {
+        return st.connectPromise;
+    }
+    const { local, host } = splitAddress(email);
+    st.connectPromise = (async () => {
+        try {
+            const ws = await connectSocket(host);
+            st.ws = ws;
+            const detach = () => {
+                if (st.ws === ws) {
+                    st.ws = null;
+                }
+                st.connectPromise = undefined;
+            };
+            ws.on('message', (data) => {
+                const packet = data.toString();
+                if (packet === '2') {
+                    try {
+                        ws.send('3');
+                    }
+                    catch {
+                        /* ignore late pong failures */
+                    }
+                    return;
+                }
+                const decoded = parseEventPacket(packet);
+                if (!decoded || decoded.event !== 'mail' || !decoded.payload) {
+                    return;
+                }
+                const normalized = (0, normalize_1.normalizeEmail)(flattenMail(decoded.payload, email), email);
+                if (!normalized.id || st.seenIds.has(normalized.id)) {
+                    return;
+                }
+                st.seenIds.add(normalized.id);
+                st.emails.push(normalized);
+            });
+            ws.on('close', detach);
+            ws.on('error', detach);
+            sendEvent(ws, 'set shortid', local);
+            await sleep(INITIAL_SYNC_WAIT_MS);
+        }
+        catch (error) {
+            st.connectPromise = undefined;
+            throw error;
+        }
+    })();
+    return st.connectPromise;
+}
+async function generateEmail(domain) {
+    const host = normalizeHost(domain);
+    const shortid = await requestShortId(host);
+    return {
+        channel: CHANNEL,
+        email: `${shortid}@${host}`,
+    };
+}
+async function getEmails(email) {
+    await ensureMailbox(email);
+    const st = getState(email);
+    return [...st.emails];
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tempmail-cn.js","sourceRoot":"","sources":["../../src/providers/tempmail-cn.ts"],"names":[],"mappings":"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","sourcesContent":["import WebSocket from 'ws';\nimport { InternalEmailInfo, Email, Channel } from '../types';\nimport { normalizeEmail } from '../normalize';\n\nconst CHANNEL: Channel = 'tempmail-cn';\nconst DEFAULT_HOST = 'tempmail.cn';\nconst CONNECT_TIMEOUT_MS = 15000;\nconst HANDSHAKE_WAIT_MS = 1000;\nconst INITIAL_SYNC_WAIT_MS = 80;\nconst SOCKET_IO_VERSIONS = [4, 3];\n\nconst DEFAULT_HEADERS: Record<string, string> = {\n  'User-Agent':\n    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36 Edg/146.0.0.0',\n  'Accept-Language': 'zh-CN,zh;q=0.9,en;q=0.8,en-GB;q=0.7,en-US;q=0.6',\n  'Cache-Control': 'no-cache',\n  DNT: '1',\n  Pragma: 'no-cache',\n};\n\ntype BoxState = {\n  emails: Email[];\n  seenIds: Set<string>;\n  ws: WebSocket | null;\n  connectPromise?: Promise<void>;\n};\n\nconst mailboxes = new Map<string, BoxState>();\n\nfunction getState(email: string): BoxState {\n  const key = email.trim().toLowerCase();\n  let st = mailboxes.get(key);\n  if (!st) {\n    st = { emails: [], seenIds: new Set(), ws: null };\n    mailboxes.set(key, st);\n  }\n  return st;\n}\n\nfunction sleep(ms: number): Promise<void> {\n  return new Promise((resolve) => setTimeout(resolve, ms));\n}\n\nfunction normalizeHost(domain?: string | null): string {\n  const raw = String(domain || '').trim();\n  if (!raw) {\n    return DEFAULT_HOST;\n  }\n\n  let host = raw;\n  if (/^https?:\\/\\//i.test(host)) {\n    try {\n      host = new URL(host).host;\n    } catch {\n      host = raw;\n    }\n  } else if (host.includes('/')) {\n    try {\n      host = new URL(`https://${host}`).host;\n    } catch {\n      host = host.split('/')[0];\n    }\n  }\n\n  host = host.replace(/^\\.+|\\.+$/g, '');\n  const at = host.lastIndexOf('@');\n  if (at >= 0) {\n    host = host.slice(at + 1);\n  }\n  return host || DEFAULT_HOST;\n}\n\nfunction splitAddress(email: string): { local: string; host: string } {\n  const trimmed = email.trim();\n  const at = trimmed.indexOf('@');\n  if (at <= 0 || at === trimmed.length - 1) {\n    throw new Error('tempmail-cn: invalid email address');\n  }\n  return {\n    local: trimmed.slice(0, at),\n    host: normalizeHost(trimmed.slice(at + 1)),\n  };\n}\n\nfunction socketUrl(host: string, eio: number): string {\n  return `wss://${host}/socket.io/?EIO=${eio}&transport=websocket`;\n}\n\nfunction socketHeaders(host: string): Record<string, string> {\n  return {\n    ...DEFAULT_HEADERS,\n    Origin: `https://${host}`,\n    Referer: `https://${host}/`,\n  };\n}\n\nfunction sendEvent(ws: WebSocket, event: string, payload: unknown): void {\n  ws.send(`42${JSON.stringify([event, payload])}`);\n}\n\nfunction parseEventPacket(packet: string): { event: string; payload: any } | null {\n  if (!packet.startsWith('42')) {\n    return null;\n  }\n  try {\n    const decoded = JSON.parse(packet.slice(2));\n    if (!Array.isArray(decoded) || typeof decoded[0] !== 'string') {\n      return null;\n    }\n    return { event: decoded[0], payload: decoded[1] };\n  } catch {\n    return null;\n  }\n}\n\nfunction stableMessageId(raw: any, recipientEmail: string): string {\n  const headers = raw?.headers || {};\n  return String(\n    raw?.id ??\n      raw?.messageId ??\n      headers['message-id'] ??\n      headers.messageId ??\n      `${headers.from || raw?.from || ''}\\n${headers.subject || raw?.subject || ''}\\n${headers.date || raw?.date || ''}\\n${recipientEmail}`,\n  );\n}\n\nfunction flattenMail(raw: any, recipientEmail: string): any {\n  const headers = raw?.headers || {};\n  return {\n    id: stableMessageId(raw, recipientEmail),\n    from: headers.from || raw?.from || '',\n    to: recipientEmail,\n    subject: headers.subject || raw?.subject || '',\n    text: raw?.text || raw?.body || '',\n    html: raw?.html || '',\n    date: headers.date || raw?.date || '',\n    isRead: false,\n    attachments: Array.isArray(raw?.attachments) ? raw.attachments : [],\n  };\n}\n\nasync function connectSocket(host: string): Promise<WebSocket> {\n  let lastError: Error | null = null;\n\n  for (const version of SOCKET_IO_VERSIONS) {\n    try {\n      return await new Promise<WebSocket>((resolve, reject) => {\n        const ws = new WebSocket(socketUrl(host, version), {\n          handshakeTimeout: CONNECT_TIMEOUT_MS,\n          headers: socketHeaders(host),\n        });\n\n        let timer: NodeJS.Timeout | undefined;\n        let sentConnect = false;\n        let settled = false;\n\n        const cleanup = () => {\n          if (timer) {\n            clearTimeout(timer);\n            timer = undefined;\n          }\n          ws.off('message', onMessage);\n          ws.off('error', onError);\n          ws.off('close', onClose);\n        };\n\n        const resolveOnce = () => {\n          if (settled) return;\n          settled = true;\n          cleanup();\n          resolve(ws);\n        };\n\n        const rejectOnce = (err: Error) => {\n          if (settled) return;\n          settled = true;\n          cleanup();\n          try {\n            ws.close();\n          } catch {\n            /* ignore close errors */\n          }\n          reject(err);\n        };\n\n        const armHandshakeFallback = () => {\n          if (timer) return;\n          timer = setTimeout(resolveOnce, HANDSHAKE_WAIT_MS);\n        };\n\n        const onMessage = (data: WebSocket.RawData) => {\n          const packet = data.toString();\n          if (packet === '2') {\n            try {\n              ws.send('3');\n            } catch {\n              /* ignore send errors during probing */\n            }\n            return;\n          }\n          if (!sentConnect) {\n            if (!packet.startsWith('0')) {\n              rejectOnce(new Error(`tempmail-cn: unexpected open packet for EIO=${version}`));\n              return;\n            }\n            sentConnect = true;\n            try {\n              ws.send('40');\n            } catch (error) {\n              rejectOnce(error instanceof Error ? error : new Error(String(error)));\n              return;\n            }\n            armHandshakeFallback();\n            return;\n          }\n          if (packet.startsWith('40')) {\n            resolveOnce();\n          }\n        };\n\n        const onError = (error: Error) => rejectOnce(error);\n        const onClose = () => rejectOnce(new Error(`tempmail-cn: websocket closed during EIO=${version} handshake`));\n\n        ws.on('message', onMessage);\n        ws.once('error', onError);\n        ws.once('close', onClose);\n      });\n    } catch (error) {\n      lastError = error instanceof Error ? error : new Error(String(error));\n    }\n  }\n\n  throw lastError || new Error('tempmail-cn: websocket handshake failed');\n}\n\nasync function requestShortId(host: string): Promise<string> {\n  const ws = await connectSocket(host);\n\n  return await new Promise<string>((resolve, reject) => {\n    const timer = setTimeout(() => {\n      cleanup();\n      try {\n        ws.close();\n      } catch {\n        /* ignore close errors */\n      }\n      reject(new Error('tempmail-cn: timed out waiting for shortid'));\n    }, CONNECT_TIMEOUT_MS);\n\n    const cleanup = () => {\n      clearTimeout(timer);\n      ws.off('message', onMessage);\n      ws.off('error', onError);\n      ws.off('close', onClose);\n    };\n\n    const finish = (value: string) => {\n      cleanup();\n      try {\n        ws.close();\n      } catch {\n        /* ignore close errors */\n      }\n      resolve(value);\n    };\n\n    const fail = (error: Error) => {\n      cleanup();\n      try {\n        ws.close();\n      } catch {\n        /* ignore close errors */\n      }\n      reject(error);\n    };\n\n    const onMessage = (data: WebSocket.RawData) => {\n      const packet = data.toString();\n      if (packet === '2') {\n        ws.send('3');\n        return;\n      }\n      const decoded = parseEventPacket(packet);\n      if (!decoded || decoded.event !== 'shortid' || typeof decoded.payload !== 'string') {\n        return;\n      }\n      finish(decoded.payload);\n    };\n\n    const onError = (error: Error) => fail(error);\n    const onClose = () => fail(new Error('tempmail-cn: websocket closed before shortid arrived'));\n\n    ws.on('message', onMessage);\n    ws.once('error', onError);\n    ws.once('close', onClose);\n\n    sendEvent(ws, 'request shortid', true);\n  });\n}\n\nasync function ensureMailbox(email: string): Promise<void> {\n  const st = getState(email);\n  if (st.ws?.readyState === WebSocket.OPEN) {\n    return;\n  }\n  if (st.connectPromise) {\n    return st.connectPromise;\n  }\n\n  const { local, host } = splitAddress(email);\n\n  st.connectPromise = (async () => {\n    try {\n      const ws = await connectSocket(host);\n      st.ws = ws;\n\n      const detach = () => {\n        if (st.ws === ws) {\n          st.ws = null;\n        }\n        st.connectPromise = undefined;\n      };\n\n      ws.on('message', (data: WebSocket.RawData) => {\n        const packet = data.toString();\n        if (packet === '2') {\n          try {\n            ws.send('3');\n          } catch {\n            /* ignore late pong failures */\n          }\n          return;\n        }\n\n        const decoded = parseEventPacket(packet);\n        if (!decoded || decoded.event !== 'mail' || !decoded.payload) {\n          return;\n        }\n\n        const normalized = normalizeEmail(flattenMail(decoded.payload, email), email);\n        if (!normalized.id || st.seenIds.has(normalized.id)) {\n          return;\n        }\n\n        st.seenIds.add(normalized.id);\n        st.emails.push(normalized);\n      });\n\n      ws.on('close', detach);\n      ws.on('error', detach);\n\n      sendEvent(ws, 'set shortid', local);\n      await sleep(INITIAL_SYNC_WAIT_MS);\n    } catch (error) {\n      st.connectPromise = undefined;\n      throw error;\n    }\n  })();\n\n  return st.connectPromise;\n}\n\nexport async function generateEmail(domain?: string | null): Promise<InternalEmailInfo> {\n  const host = normalizeHost(domain);\n  const shortid = await requestShortId(host);\n  return {\n    channel: CHANNEL,\n    email: `${shortid}@${host}`,\n  };\n}\n\nexport async function getEmails(email: string): Promise<Email[]> {\n  await ensureMailbox(email);\n  const st = getState(email);\n  return [...st.emails];\n}\n"]}

package/dist/retry.d.ts

@@ -26,5 +26,18 @@ export interface RetryOptions {
  * @param fn 要执行的异步操作
  * @param options 重试配置
  */
+export type RetryWithAttemptsResult<T> = {
+    ok: true;
+    value: T;
+    attempts: number;
+} | {
+    ok: false;
+    error: unknown;
+    attempts: number;
+};
+/**
+ * 与 withRetry 相同，额外返回尝试次数（成功或最终失败时均有效）
+ */
+export declare function withRetryWithAttempts<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<RetryWithAttemptsResult<T>>;
 export declare function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T>;
 export declare function fetchWithTimeout(url: string, init?: RequestInit, timeoutMs?: number): Promise<Response>;

package/dist/retry.js

@@ -4,6 +4,7 @@
  * 提供请求重试、超时控制、指数退避等错误恢复机制
  */
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.withRetryWithAttempts = withRetryWithAttempts;
 exports.withRetry = withRetry;
 exports.fetchWithTimeout = fetchWithTimeout;
 const logger_1 = require("./logger");
@@ -60,24 +61,19 @@ function sleep(ms) {
     return new Promise(resolve => setTimeout(resolve, ms));
 }
 /**
- * 带重试的异步操作执行器
- * - 自动重试可恢复的错误（网络错误、超时、HTTP 4xx/5xx）
- * - 指数退避避免过度请求
- * - 不可恢复的错误（SDK 内部参数校验错误等）直接抛出不重试
- *
- * @param fn 要执行的异步操作
- * @param options 重试配置
+ * 与 withRetry 相同，额外返回尝试次数（成功或最终失败时均有效）
  */
-async function withRetry(fn, options) {
+async function withRetryWithAttempts(fn, options) {
     const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };
     let lastError;
     for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {
+        const attempts = attempt + 1;
         try {
             const result = await fn();
             if (attempt > 0) {
                 logger_1.logger.info(`第 ${attempt + 1} 次尝试成功`);
             }
-            return result;
+            return { ok: true, value: result, attempts };
         }
         catch (error) {
             lastError = error;
@@ -90,7 +86,7 @@ async function withRetry(fn, options) {
                 else if (!opts.shouldRetry(error)) {
                     logger_1.logger.debug(`不可重试的错误: ${errorMsg}`);
                 }
-                throw error;
+                return { ok: false, error, attempts };
             }
             /* 指数退避等待 */
             const delay = Math.min(opts.initialDelay * Math.pow(2, attempt), opts.maxDelay);
@@ -98,7 +94,13 @@ async function withRetry(fn, options) {
             await sleep(delay);
         }
     }
-    throw lastError;
+    return { ok: false, error: lastError, attempts: opts.maxRetries + 1 };
+}
+async function withRetry(fn, options) {
+    const r = await withRetryWithAttempts(fn, options);
+    if (r.ok)
+        return r.value;
+    throw r.error;
 }
 /**
  * 带超时控制的 fetch 包装
@@ -158,4 +160,4 @@ async function fetchWithTimeout(url, init, timeoutMs) {
         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';\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 * 以下错误类型会触发重试：\n * - 网络连接错误（fetch failed, ECONNREFUSED, ECONNRESET 等）\n * - 超时错误（timeout, abort）\n * - DNS 解析失败\n * - HTTP 429 限流\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 * - 自动重试可恢复的错误（网络错误、超时、HTTP 4xx/5xx）\n * - 指数退避避免过度请求\n * - 不可恢复的错误（SDK 内部参数校验错误等）直接抛出不重试\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 */\n/**\n * 缓存的全局配置快照，避免每次请求都读取\n * 仅在 setConfig 被调用时失效（通过 configVersion 比对）\n */\nlet _cachedFetchConfig: { fetchFn: typeof fetch; timeout: number; version: number } | null = null;\n\n/**\n * 获取缓存的 fetch 配置\n */\nfunction getFetchConfig(): { fetchFn: typeof fetch; timeout: number } {\n  const config = getConfig();\n  /* 简单的引用比对即可，getConfig 在未变更时返回同一对象 */\n  if (!_cachedFetchConfig || _cachedFetchConfig.fetchFn !== (config.customFetch || fetch) || _cachedFetchConfig.timeout !== (config.timeout ?? DEFAULT_RETRY_OPTIONS.timeout)) {\n    _cachedFetchConfig = {\n      fetchFn: config.customFetch || fetch,\n      timeout: config.timeout ?? DEFAULT_RETRY_OPTIONS.timeout,\n      version: 0,\n    };\n  }\n  return _cachedFetchConfig;\n}\n\nexport async function fetchWithTimeout(\n  url: string,\n  init?: RequestInit,\n  timeoutMs?: number,\n): Promise<Response> {\n  const { fetchFn, timeout: defaultTimeout } = getFetchConfig();\n  const effectiveTimeout = timeoutMs ?? defaultTimeout;\n  const controller = new AbortController();\n  const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);\n\n  /*\n   * 如果调用方已提供 signal，需要同时监听两个信号（调用方 + 超时）\n   * 任一触发则中断请求\n   */\n  const externalSignal = init?.signal;\n  if (externalSignal) {\n    externalSignal.addEventListener('abort', () => controller.abort(), { once: true });\n  }\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"]}
+//# 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 * 以下错误类型会触发重试：\n * - 网络连接错误（fetch failed, ECONNREFUSED, ECONNRESET 等）\n * - 超时错误（timeout, abort）\n * - DNS 解析失败\n * - HTTP 429 限流\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 * - 自动重试可恢复的错误（网络错误、超时、HTTP 4xx/5xx）\n * - 指数退避避免过度请求\n * - 不可恢复的错误（SDK 内部参数校验错误等）直接抛出不重试\n *\n * @param fn 要执行的异步操作\n * @param options 重试配置\n */\nexport type RetryWithAttemptsResult<T> =\n  | { ok: true; value: T; attempts: number }\n  | { ok: false; error: unknown; attempts: number };\n\n/**\n * 与 withRetry 相同，额外返回尝试次数（成功或最终失败时均有效）\n */\nexport async function withRetryWithAttempts<T>(\n  fn: () => Promise<T>,\n  options?: RetryOptions,\n): Promise<RetryWithAttemptsResult<T>> {\n  const opts = { ...DEFAULT_RETRY_OPTIONS, ...options };\n  let lastError: any;\n\n  for (let attempt = 0; attempt <= opts.maxRetries; attempt++) {\n    const attempts = attempt + 1;\n    try {\n      const result = await fn();\n      if (attempt > 0) {\n        logger.info(`第 ${attempt + 1} 次尝试成功`);\n      }\n      return { ok: true, value: result, attempts };\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        return { ok: false, error, attempts };\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  return { ok: false, error: lastError, attempts: opts.maxRetries + 1 };\n}\n\nexport async function withRetry<T>(fn: () => Promise<T>, options?: RetryOptions): Promise<T> {\n  const r = await withRetryWithAttempts(fn, options);\n  if (r.ok) return r.value;\n  throw r.error;\n}\n\n/**\n * 带超时控制的 fetch 包装\n * 在原生 fetch 基础上添加超时中断能力\n *\n * @param url 请求 URL\n * @param init fetch 选项\n * @param timeoutMs 超时时间（毫秒）\n */\n/**\n * 缓存的全局配置快照，避免每次请求都读取\n * 仅在 setConfig 被调用时失效（通过 configVersion 比对）\n */\nlet _cachedFetchConfig: { fetchFn: typeof fetch; timeout: number; version: number } | null = null;\n\n/**\n * 获取缓存的 fetch 配置\n */\nfunction getFetchConfig(): { fetchFn: typeof fetch; timeout: number } {\n  const config = getConfig();\n  /* 简单的引用比对即可，getConfig 在未变更时返回同一对象 */\n  if (!_cachedFetchConfig || _cachedFetchConfig.fetchFn !== (config.customFetch || fetch) || _cachedFetchConfig.timeout !== (config.timeout ?? DEFAULT_RETRY_OPTIONS.timeout)) {\n    _cachedFetchConfig = {\n      fetchFn: config.customFetch || fetch,\n      timeout: config.timeout ?? DEFAULT_RETRY_OPTIONS.timeout,\n      version: 0,\n    };\n  }\n  return _cachedFetchConfig;\n}\n\nexport async function fetchWithTimeout(\n  url: string,\n  init?: RequestInit,\n  timeoutMs?: number,\n): Promise<Response> {\n  const { fetchFn, timeout: defaultTimeout } = getFetchConfig();\n  const effectiveTimeout = timeoutMs ?? defaultTimeout;\n  const controller = new AbortController();\n  const timeoutId = setTimeout(() => controller.abort(), effectiveTimeout);\n\n  /*\n   * 如果调用方已提供 signal，需要同时监听两个信号（调用方 + 超时）\n   * 任一触发则中断请求\n   */\n  const externalSignal = init?.signal;\n  if (externalSignal) {\n    externalSignal.addEventListener('abort', () => controller.abort(), { once: true });\n  }\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/telemetry.d.ts

@@ -0,0 +1 @@
+export declare function reportTelemetry(operation: string, channel: string, success: boolean, attemptCount: number, channelsTried: number, error: string): void;