tempmail_sdk 1.3.3

data/lib/tempmail_sdk/providers/anonymmail.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module TempmailSdk
+  module Providers
+    # anonymmail.net 渠道实现
+    # POST JSON API，需要 cookie session
+    module Anonymmail
+      CHANNEL = "anonymmail"
+      BASE = "https://anonymmail.net"
+      HEADERS = {
+        "Accept" => "*/*",
+        "Content-Type" => "application/x-www-form-urlencoded",
+        "Referer" => "https://anonymmail.net/",
+        "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"
+      }.freeze
+
+      module_function
+
+      def random_username(length = 10)
+        chars = ("a".."z").to_a + ("0".."9").to_a
+        Array.new(length) { chars.sample }.join
+      end
+
+      # 获取可用域名列表
+      def fetch_domains
+        resp = Http.post("#{BASE}/api/getDomains", headers: HEADERS, timeout: 15)
+        resp.raise_for_status
+        data = resp.json
+        return [] unless data.is_a?(Array)
+
+        data.select { |item| item.is_a?(Hash) && item["domain"].to_s.strip != "" }
+            .map { |item| item["domain"].to_s.strip }
+      end
+
+      # @return [EmailInfo]
+      def generate_email
+        domains = fetch_domains
+        raise "anonymmail: no domains available" if domains.empty?
+
+        domain = domains.sample
+        username = random_username
+        email = "#{username}@#{domain}"
+
+        # HEAD 请求获取 cookie session
+        Http.get("#{BASE}/", headers: HEADERS, timeout: 15)
+
+        # POST 创建邮箱
+        resp = Http.post("#{BASE}/api/create", headers: HEADERS, body: "email=#{email}", timeout: 15)
+        resp.raise_for_status
+        data = resp.json
+        raise "anonymmail: create inbox failed" unless data.is_a?(Hash) && data["success"]
+
+        addr = data["email"].to_s.strip
+        raise "anonymmail: missing email in response" if addr.empty?
+
+        EmailInfo.new(channel: CHANNEL, email: addr)
+      end
+
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(email)
+        e = email.to_s.strip
+        raise "anonymmail: empty email" if e.empty?
+
+        resp = Http.post("#{BASE}/api/get", headers: HEADERS, body: "email=#{e}", timeout: 15)
+        resp.raise_for_status
+        data = resp.json
+        return [] unless data.is_a?(Hash)
+
+        inbox = data[e]
+        return [] unless inbox.is_a?(Hash)
+
+        rows = inbox["emails"]
+        return [] unless rows.is_a?(Array)
+
+        rows.select { |r| r.is_a?(Hash) }.map do |raw|
+          normalized = raw.dup
+          # 将 token 字段映射为 id
+          if normalized.key?("token") && !normalized.key?("id")
+            normalized["id"] = normalized.delete("token")
+          end
+          # 将 body 字段映射为 html
+          if normalized.key?("body") && !normalized.key?("html")
+            normalized["html"] = normalized.delete("body")
+          end
+          Normalize.normalize_email(normalized, e)
+        end
+      end
+    end
+  end
+end

data/lib/tempmail_sdk/providers/byom.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module TempmailSdk
+  module Providers
+    # byom.de 渠道实现
+    # 纯 GET 无认证，直接生成随机用户名
+    module Byom
+      CHANNEL = "byom"
+      DOMAIN = "byom.de"
+      BASE = "https://api.byom.de"
+      HEADERS = {
+        "Accept" => "application/json, text/plain, */*",
+        "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"
+      }.freeze
+
+      module_function
+
+      def random_username(length = 10)
+        chars = ("a".."z").to_a + ("0".."9").to_a
+        Array.new(length) { chars.sample }.join
+      end
+
+      # @return [EmailInfo]
+      def generate_email
+        username = random_username
+        EmailInfo.new(channel: CHANNEL, email: "#{username}@#{DOMAIN}")
+      end
+
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(email)
+        e = email.to_s.strip
+        raise "byom: empty email" if e.empty?
+
+        username = e.split("@").first.to_s
+        raise "byom: invalid email format" if username.empty?
+
+        resp = Http.get("#{BASE}/mails/#{username}", headers: HEADERS, timeout: 15)
+        resp.raise_for_status
+        data = resp.json
+        return [] unless data.is_a?(Array)
+
+        data.select { |r| r.is_a?(Hash) }.map { |raw| Normalize.normalize_email(raw, e) }
+      end
+    end
+  end
+end

data/lib/tempmail_sdk/providers/catchmail.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require "uri"
+
+module TempmailSdk
+  module Providers
+    # Catchmail 渠道 — https://catchmail.io
+    # 匿名 REST API：创建邮箱即列表接口，逐封拉取详情
+    module Catchmail
+      CHANNEL = "catchmail"
+      API_BASE = "https://api.catchmail.io/api/v1"
+      DEFAULT_DOMAIN = "catchmail.io"
+      DOMAINS = %w[catchmail.io mailistry.com zeppost.com].freeze
+      HEADERS = {
+        "Accept" => "application/json",
+        "Referer" => "https://catchmail.io/",
+        "Origin" => "https://catchmail.io",
+        "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"
+      }.freeze
+
+      module_function
+
+      def random_local
+        chars = ("a".."z").to_a + ("0".."9").to_a
+        "sdk#{Array.new(16) { chars.sample }.join}"
+      end
+
+      # 选择域名：命中别名域名则用之，否则默认域名
+      def pick_domain(preferred)
+        p = preferred.to_s.strip.sub(/\A@/, "").downcase
+        unless p.empty?
+          found = DOMAINS.find { |d| d.downcase == p }
+          return found if found
+        end
+        DEFAULT_DOMAIN
+      end
+
+      # 从可能带显示名的地址字段提取纯地址
+      def clean_address(value)
+        value = value.first if value.is_a?(Array)
+        text = value.to_s.strip
+        m = text.match(/<([^>]+)>/)
+        m ? m[1].strip : text
+      end
+
+      def flatten_detail(raw, recipient)
+        body = raw["body"].is_a?(Hash) ? raw["body"] : {}
+        {
+          "id" => raw["id"] || "", "from" => clean_address(raw["from"]),
+          "to" => (a = clean_address(raw["to"])).empty? ? recipient : a,
+          "subject" => raw["subject"] || "", "text" => body["text"] || "",
+          "html" => body["html"] || "", "date" => raw["date"] || "",
+          "attachments" => raw["attachments"]
+        }
+      end
+
+      def fetch_message(message_id, email)
+        resp = Http.get(
+          "#{API_BASE}/message/#{URI.encode_www_form_component(message_id)}?mailbox=#{URI.encode_www_form_component(email)}",
+          headers: HEADERS, timeout: 15
+        )
+        return nil unless resp.ok?
+
+        data = resp.json
+        data.is_a?(Hash) ? data : nil
+      end
+
+      # @param domain [String, nil]
+      # @return [EmailInfo]
+      def generate_email(domain = nil)
+        email = "#{random_local}@#{pick_domain(domain)}"
+        Http.get("#{API_BASE}/mailbox?address=#{URI.encode_www_form_component(email)}",
+                 headers: HEADERS, timeout: 15).raise_for_status
+        EmailInfo.new(channel: CHANNEL, email: email)
+      end
+
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(email)
+        address = email.to_s.strip
+        raise "catchmail: empty email" if address.empty?
+
+        resp = Http.get("#{API_BASE}/mailbox?address=#{URI.encode_www_form_component(address)}",
+                        headers: HEADERS, timeout: 15)
+        resp.raise_for_status
+        data = resp.json
+        rows = data.is_a?(Hash) ? data["messages"] : nil
+        return [] unless rows.is_a?(Array)
+
+        rows.filter_map do |item|
+          next unless item.is_a?(Hash)
+
+          message_id = item["id"].to_s.strip
+          next if message_id.empty?
+
+          detail = fetch_message(message_id, address)
+          if detail
+            Normalize.normalize_email(flatten_detail(detail, address), address)
+          else
+            Normalize.normalize_email({
+                                        "id" => message_id, "from" => clean_address(item["from"]),
+                                        "to" => item["mailbox"] || address,
+                                        "subject" => item["subject"] || "", "date" => item["date"] || ""
+                                      }, address)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/tempmail_sdk/providers/cleantempmail.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module TempmailSdk
+  module Providers
+    # cleantempmail.com 渠道实现
+    module Cleantempmail
+      CHANNEL = "cleantempmail"
+      API_BASE = "https://cleantempmail.com/api"
+      HEADERS = {
+        "Accept" => "application/json",
+        "User-Agent" => "Mozilla/5.0",
+        "X-API-Key" => (ENV["CLEANTEMPMAIL_API_KEY"].to_s.strip.empty? ? "ct-test" : ENV["CLEANTEMPMAIL_API_KEY"].to_s.strip)
+      }.freeze
+
+      module_function
+
+      def fetch_json(path)
+        resp = Http.get("#{API_BASE}#{path}", headers: HEADERS, timeout: 15)
+        resp.raise_for_status
+        data = resp.json
+        data.is_a?(Hash) ? data : {}
+      end
+
+      # @return [EmailInfo]
+      def generate_email
+        data = fetch_json("/generate-email")
+        payload = data["data"].is_a?(Hash) ? data["data"] : {}
+        email = (payload["email"] || payload["mailbox"]).to_s.strip
+        raise "cleantempmail: invalid generate-email response" if email.empty? || !email.include?("@")
+
+        EmailInfo.new(channel: CHANNEL, email: email)
+      end
+
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(email)
+        address = email.to_s.strip
+        raise "cleantempmail: empty email" if address.empty?
+
+        data = fetch_json("/emails?email=#{URI.encode_www_form_component(address)}")
+        payload = data["data"].is_a?(Hash) ? data["data"] : {}
+        rows = payload["emails"]
+        return [] unless rows.is_a?(Array)
+
+        rows.select { |r| r.is_a?(Hash) }.map { |item| Normalize.normalize_email(item, address) }
+      end
+    end
+  end
+end

data/lib/tempmail_sdk/providers/devmail_uk.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module TempmailSdk
+  module Providers
+    # devmail.uk 渠道实现
+    module DevmailUk
+      CHANNEL = "devmail-uk"
+      API_BASE = "https://www.devmail.uk/api"
+      HEADERS = { "Accept" => "application/json" }.freeze
+
+      module_function
+
+      def mailbox_from_email(email)
+        address = email.to_s.strip
+        return "" if address.empty?
+        return address.split("@", 2).first.to_s.strip if address.include?("@")
+
+        address
+      end
+
+      # @return [EmailInfo]
+      def generate_email
+        resp = Http.get("#{API_BASE}/new", headers: HEADERS, timeout: 15)
+        resp.raise_for_status
+        data = resp.json
+        raise "devmail-uk: invalid new email response" unless data.is_a?(Hash)
+
+        email = data["email"].to_s.strip
+        if email.empty? && !data["mailbox"].to_s.strip.empty?
+          email = "#{data['mailbox'].to_s.strip}@devmail.uk"
+        end
+        raise "devmail-uk: invalid new email response" if email.empty? || !email.include?("@")
+
+        EmailInfo.new(channel: CHANNEL, email: email)
+      end
+
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(email)
+        mailbox = mailbox_from_email(email)
+        raise "devmail-uk: empty email" if mailbox.empty?
+
+        resp = Http.get(
+          "#{API_BASE}/inbox/#{URI.encode_www_form_component(mailbox)}?detail=true",
+          headers: HEADERS, timeout: 15
+        )
+        resp.raise_for_status
+        data = resp.json
+        return [] unless data.is_a?(Hash)
+
+        rows = data["emails"]
+        return [] unless rows.is_a?(Array)
+
+        rows.select { |r| r.is_a?(Hash) }.map { |item| Normalize.normalize_email(item, email) }
+      end
+    end
+  end
+end

data/lib/tempmail_sdk/providers/dropmail.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "json"
+require "uri"
+
+module TempmailSdk
+  module Providers
+    # dropmail.me GraphQL 渠道 — https://dropmail.me
+    # 使用 af_ 令牌访问 GraphQL API 创建 session 和查询邮件
+    module Dropmail
+      CHANNEL = "dropmail"
+      TOKEN_GENERATE_URL = "https://dropmail.me/api/token/generate"
+      TOKEN_RENEW_URL = "https://dropmail.me/api/token/renew"
+
+      CREATE_SESSION_QUERY = "mutation {introduceSession {id, expiresAt, addresses{id, address}}}"
+      GET_MAILS_QUERY = 'query ($id: ID!) { session(id:$id) { mails { id, rawSize, fromAddr, toAddr, receivedAt, text, headerFrom, headerSubject, html } } }'
+
+      TOKEN_HEADERS = {
+        "Accept" => "application/json",
+        "Content-Type" => "application/json",
+        "Origin" => "https://dropmail.me",
+        "Referer" => "https://dropmail.me/api/"
+      }.freeze
+
+      AUTO_CACHE_SEC = 50 * 60
+      RENEW_BEFORE_SEC = 10 * 60
+
+      @lock = Mutex.new
+      @cached_af = nil # [token_string, expiry_monotonic]
+
+      module_function
+
+      # 从配置或环境变量中获取显式 token
+      def explicit_af_token
+        ENV["DROPMAIL_AUTH_TOKEN"].to_s.strip.then do |t|
+          return t unless t.empty?
+        end
+        ENV["DROPMAIL_API_TOKEN"].to_s.strip
+      end
+
+      # 从 API 获取新 af_ token
+      def fetch_af_token
+        resp = Http.post(TOKEN_GENERATE_URL, headers: TOKEN_HEADERS, json: { "type" => "af", "lifetime" => "1h" })
+        resp.raise_for_status
+        body = resp.json
+        tok = (body["token"] || "").to_s.strip
+        raise "DropMail token/generate 未返回有效 af_ 令牌" if tok.empty? || !tok.start_with?("af_")
+
+        tok
+      end
+
+      # 解析 af_ token（优先显式配置，其次自动获取并缓存）
+      def resolve_af_token
+        ex = explicit_af_token
+        return ex unless ex.empty?
+
+        now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+        @lock.synchronize do
+          if @cached_af
+            tok, exp = @cached_af
+            return tok if now < exp - RENEW_BEFORE_SEC
+          end
+          @cached_af = nil
+          new_tok = fetch_af_token
+          @cached_af = [new_tok, Process.clock_gettime(Process::CLOCK_MONOTONIC) + AUTO_CACHE_SEC]
+          new_tok
+        end
+      end
+
+      # 构造 GraphQL URL
+      def graphql_url
+        af = resolve_af_token
+        "https://dropmail.me/api/graphql/#{URI.encode_www_form_component(af)}"
+      end
+
+      # 发送 GraphQL 请求
+      def graphql_request(query, variables = nil)
+        data = { "query" => query }
+        data["variables"] = JSON.generate(variables) if variables
+
+        resp = Http.post(
+          graphql_url,
+          headers: { "Content-Type" => "application/x-www-form-urlencoded" },
+          body: URI.encode_www_form(data)
+        )
+        resp.raise_for_status
+        result = resp.json
+        if result["errors"]&.any?
+          raise "GraphQL error: #{result['errors'].first['message'] || 'Unknown'}"
+        end
+
+        result["data"] || {}
+      end
+
+      # 创建临时邮箱
+      # @return [EmailInfo]
+      def generate_email
+        data = graphql_request(CREATE_SESSION_QUERY)
+        session = data["introduceSession"]
+        raise "Failed to generate email" unless session && session["addresses"]&.any?
+
+        EmailInfo.new(
+          channel: CHANNEL,
+          email: session["addresses"][0]["address"],
+          token: session["id"],
+          expires_at: session["expiresAt"]
+        )
+      end
+
+      # 获取邮件列表
+      # @param token [String] session ID
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(token, email = "")
+        data = graphql_request(GET_MAILS_QUERY, { "id" => token })
+        mails = ((data["session"] || {})["mails"]) || []
+        mails.map do |m|
+          raw = {
+            "id" => m["id"] || "",
+            "from" => m["fromAddr"] || "",
+            "to" => m["toAddr"] || email,
+            "subject" => m["headerSubject"] || "",
+            "text" => m["text"] || "",
+            "html" => m["html"] || "",
+            "received_at" => m["receivedAt"] || "",
+            "attachments" => []
+          }
+          Normalize.normalize_email(raw, email)
+        end
+      end
+    end
+  end
+end

data/lib/tempmail_sdk/providers/dropmail_click.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module TempmailSdk
+  module Providers
+    # dropmail.click 渠道实现
+    # 独立后端临时邮箱，免注册、无鉴权。Token 即邮箱地址本身。
+    module DropmailClick
+      CHANNEL = "dropmail-click"
+      BASE_URL = "https://dropmail.click"
+      DEFAULT_UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " \
+                   "(KHTML, like Gecko) Chrome/149.0.0.0 Safari/537.36"
+
+      module_function
+
+      def get_ua
+        cfg = Config.get_config
+        (cfg.headers || {})["User-Agent"] || DEFAULT_UA
+      end
+
+      def first_val(msg, *keys)
+        keys.each do |key|
+          val = msg[key]
+          return val.to_s if !val.nil? && val != ""
+        end
+        ""
+      end
+
+      # @return [EmailInfo]
+      def generate_email
+        resp = Http.post(
+          "#{BASE_URL}/api/v1/public/mailbox",
+          headers: { "User-Agent" => get_ua, "Accept" => "application/json" }
+        )
+        resp.raise_for_status
+        data = resp.json
+        raise "dropmail-click: invalid response" unless data.is_a?(Hash)
+
+        address = data["address"].to_s
+        raise "dropmail-click: missing address" if address.empty?
+
+        EmailInfo.new(
+          channel: CHANNEL,
+          email: address,
+          token: address,
+          expires_at: data["expires_at"]
+        )
+      end
+
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(email)
+        addr = email.to_s.strip
+        raise "dropmail-click: missing email" if addr.empty?
+
+        resp = Http.get(
+          "#{BASE_URL}/api/v1/public/mailbox/#{URI.encode_www_form_component(addr)}",
+          headers: { "User-Agent" => get_ua, "Accept" => "application/json" }
+        )
+        resp.raise_for_status
+        data = resp.json
+        return [] unless data.is_a?(Hash)
+
+        messages = data["messages"]
+        return [] unless messages.is_a?(Array)
+
+        messages.select { |m| m.is_a?(Hash) }.map do |msg|
+          row = {
+            "id" => first_val(msg, "id"),
+            "from" => first_val(msg, "from"),
+            "to" => first_val(msg, "address").empty? ? addr : first_val(msg, "address"),
+            "subject" => first_val(msg, "subject"),
+            "text" => first_val(msg, "text"),
+            "html" => first_val(msg, "html"),
+            "date" => first_val(msg, "received_at", "date")
+          }
+          Normalize.normalize_email(row, addr)
+        end
+      end
+    end
+  end
+end