tempmail_sdk 1.3.3

data/lib/tempmail_sdk/providers/lroid.rb

@@ -0,0 +1,170 @@
+# frozen_string_literal: true
+
+require "json"
+
+module TempmailSdk
+  module Providers
+    # Lroid 渠道 — https://lroid.com
+    # HTML 解析模式，session cookies 维持邮箱身份
+    module Lroid
+      CHANNEL = "lroid"
+      BASE_URL = "https://lroid.com"
+
+      EMAIL_RE = /<input[^>]+id=["']eposta_adres["'][^>]+value=["']([^"']+@[^"']+)["']/i
+      EMAIL_RE_ALT = /<input[^>]+value=["']([^"']+@[^"']+)["'][^>]+id=["']eposta_adres["']/i
+
+      HEADERS = {
+        "Accept" => "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+        "Accept-Language" => "en-US,en;q=0.9",
+        "Referer" => "#{BASE_URL}/",
+        "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
+
+      # 从响应中收集并序列化 cookies
+      def cookie_header_from_resp(resp)
+        map = {}
+        resp.set_cookies.each do |line|
+          pair = line.split(";", 2).first.to_s.strip
+          next unless pair.include?("=")
+
+          k, v = pair.split("=", 2)
+          map[k.strip] = v.to_s.strip unless k.strip.empty?
+        end
+        map.keys.sort.map { |k| "#{k}=#{map[k]}" }.join("; ")
+      end
+
+      # 从 HTML 中提取邮箱地址
+      def extract_email(html_str)
+        m = html_str.match(EMAIL_RE) || html_str.match(EMAIL_RE_ALT)
+        raise "lroid: 无法从 HTML 响应中解析邮箱地址" unless m
+
+        addr = m[1].strip
+        raise "lroid: 解析到的邮箱地址无效" unless addr.include?("@")
+
+        addr
+      end
+
+      # 解码 token
+      def decode_token(token)
+        data = JSON.parse(token)
+        cookie = (data["cookie"] || "").strip
+        raise "lroid: session token 中缺少 cookie" if cookie.empty?
+
+        cookie
+      rescue JSON::ParserError
+        raise "lroid: 无效的 session token"
+      end
+
+      # 创建临时邮箱
+      # @return [EmailInfo]
+      def generate_email
+        resp = Http.get(BASE_URL, headers: HEADERS, timeout: 15)
+        resp.raise_for_status
+        email = extract_email(resp.body)
+        cookie_hdr = cookie_header_from_resp(resp)
+        token = JSON.generate("cookie" => cookie_hdr)
+        EmailInfo.new(channel: CHANNEL, email: email, token: token)
+      end
+
+      # 获取邮件列表
+      # @param token [String]
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(token, email = "")
+        cookie = decode_token(token)
+        address = (email || "").strip
+        raise "lroid: 邮箱地址不能为空" if address.empty?
+
+        # 尝试 kontrol API
+        begin
+          resp = Http.get(
+            "#{BASE_URL}/en/api-kontrol/",
+            headers: {
+              "Accept" => "application/json, text/html, */*;q=0.8",
+              "Referer" => "#{BASE_URL}/",
+              "Cookie" => cookie,
+              "User-Agent" => HEADERS["User-Agent"]
+            },
+            timeout: 15
+          )
+          resp.raise_for_status
+          data = resp.json
+          if data.is_a?(Array)
+            return parse_json_emails(data, address)
+          elsif data.is_a?(Hash)
+            %w[mails emails messages data inbox].each do |key|
+              items = data[key]
+              return parse_json_emails(items, address) if items.is_a?(Array)
+            end
+            if data["id"] || data["subject"] || data["from"]
+              return parse_json_emails([data], address)
+            end
+          end
+        rescue StandardError
+          # API 不可用，回退到 HTML 解析
+        end
+
+        parse_html_emails(cookie, address)
+      end
+
+      def parse_json_emails(items, recipient)
+        items.filter_map do |raw|
+          next unless raw.is_a?(Hash)
+
+          normalized = raw.dup
+          normalized["html"] = raw["body"] || raw["content"] if !raw.key?("html")
+          Normalize.normalize_email(normalized, recipient)
+        end
+      end
+
+      def parse_html_emails(cookie, recipient)
+        resp = Http.get(
+          BASE_URL,
+          headers: {
+            "Accept" => "text/html,application/xhtml+xml,*/*;q=0.8",
+            "Referer" => "#{BASE_URL}/",
+            "Cookie" => cookie,
+            "User-Agent" => HEADERS["User-Agent"]
+          },
+          timeout: 15
+        )
+        resp.raise_for_status
+        html_str = resp.body
+
+        # 解析 <li class="mail"> 元素
+        mail_items = html_str.scan(/<li[^>]*class=["'][^"']*\bmail\b[^"']*["'][^>]*>(.*?)<\/li>/mi)
+        return [] if mail_items.empty?
+
+        mail_items.each_with_index.filter_map do |(item_html), idx|
+          subject = ""
+          from_addr = ""
+          date = ""
+          mail_id = (idx + 1).to_s
+
+          # 提取主题
+          sm = item_html.match(/class=["'][^"']*\bsubject\b[^"']*["'][^>]*>(.*?)<\//mi)
+          subject = sm[1].gsub(/<[^>]+>/, "").strip if sm
+
+          # 提取发件人
+          fm = item_html.match(/class=["'][^"']*\b(?:from|sender)\b[^"']*["'][^>]*>(.*?)<\//mi)
+          from_addr = fm[1].gsub(/<[^>]+>/, "").strip if fm
+
+          # 提取日期
+          dm = item_html.match(/class=["'][^"']*\b(?:date|time)\b[^"']*["'][^>]*>(.*?)<\//mi)
+          date = dm[1].gsub(/<[^>]+>/, "").strip if dm
+
+          Normalize.normalize_email({
+            "id" => mail_id,
+            "from" => from_addr,
+            "to" => recipient,
+            "subject" => subject,
+            "date" => date
+          }, recipient)
+        end
+      end
+    end
+  end
+end

data/lib/tempmail_sdk/providers/m2u.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "json"
+
+module TempmailSdk
+  module Providers
+    # m2u.io 渠道实现
+    module M2u
+      CHANNEL = "m2u"
+      API_BASE = "https://api.m2u.io"
+      HEADERS = {
+        "Accept" => "application/json",
+        "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"
+      }.freeze
+
+      module_function
+
+      def pack_token(token, view_token)
+        JSON.generate({ "token" => token, "viewToken" => view_token })
+      end
+
+      def unpack_token(token)
+        value = token.to_s.strip
+        return ["", ""] if value.empty?
+
+        if value.start_with?("{")
+          begin
+            data = JSON.parse(value)
+            if data.is_a?(Hash)
+              return [data["token"].to_s.strip, data["viewToken"].to_s.strip]
+            end
+          rescue StandardError
+            return ["", ""]
+          end
+        end
+        [value, ""]
+      end
+
+      def flatten_message(raw, recipient)
+        {
+          "id" => (raw["id"] || raw["message_id"]).to_s,
+          "from" => (raw["from_addr"] || raw["from_address"] || raw["from"]).to_s,
+          "to" => recipient,
+          "subject" => (raw["subject"] || "").to_s,
+          "text" => (raw["text_body"] || raw["body_text"] || raw["text"]).to_s,
+          "html" => (raw["html_body"] || raw["body_html"] || raw["html"]).to_s,
+          "date" => (raw["received_at"] || raw["created_at"]).to_s,
+          "is_read" => raw["is_read"] || raw["isRead"] || raw["seen"] || false,
+          "attachments" => raw["attachments"].is_a?(Array) ? raw["attachments"] : []
+        }
+      end
+
+      # @return [EmailInfo]
+      def generate_email
+        resp = Http.post(
+          "#{API_BASE}/v1/mailboxes/auto",
+          headers: HEADERS.merge("Content-Type" => "application/json"),
+          json: {},
+          timeout: 15
+        )
+        resp.raise_for_status
+        data = resp.json
+        mailbox = data.is_a?(Hash) ? data["mailbox"] : nil
+        raise "m2u: invalid mailbox response" unless mailbox.is_a?(Hash)
+
+        local_part = mailbox["local_part"].to_s.strip
+        domain = mailbox["domain"].to_s.strip
+        token = mailbox["token"].to_s.strip
+        view_token = mailbox["view_token"].to_s.strip
+        email = !local_part.empty? && !domain.empty? ? "#{local_part}@#{domain}" : ""
+        raise "m2u: invalid mailbox response" if email.empty? || token.empty? || view_token.empty?
+
+        EmailInfo.new(
+          channel: CHANNEL,
+          email: email,
+          token: pack_token(token, view_token),
+          expires_at: mailbox["expires_at"],
+          created_at: mailbox["created_at"]
+        )
+      end
+
+      def fetch_detail(token, view_token, message_id)
+        resp = Http.get(
+          "#{API_BASE}/v1/mailboxes/#{URI.encode_www_form_component(token)}/messages/#{URI.encode_www_form_component(message_id)}?view=#{URI.encode_www_form_component(view_token)}",
+          headers: HEADERS, timeout: 15
+        )
+        return nil unless resp.ok?
+
+        data = resp.json
+        return nil unless data.is_a?(Hash)
+
+        detail = data["message"]
+        detail.is_a?(Hash) ? detail : nil
+      rescue StandardError
+        nil
+      end
+
+      # @param token [String] JSON 打包的 token
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(token, email)
+        mailbox_token, view_token = unpack_token(token)
+        address = email.to_s.strip
+        raise "m2u: missing token" if mailbox_token.empty?
+        raise "m2u: missing view token" if view_token.empty?
+        raise "m2u: empty email" if address.empty?
+
+        resp = Http.get(
+          "#{API_BASE}/v1/mailboxes/#{URI.encode_www_form_component(mailbox_token)}/messages?view=#{URI.encode_www_form_component(view_token)}",
+          headers: HEADERS, timeout: 15
+        )
+        resp.raise_for_status
+        data = resp.json
+        rows = data.is_a?(Hash) ? (data["messages"] || []) : []
+        return [] unless rows.is_a?(Array)
+
+        rows.select { |r| r.is_a?(Hash) }.map do |item|
+          message_id = (item["id"] || item["message_id"]).to_s.strip
+          detail = message_id.empty? ? nil : fetch_detail(mailbox_token, view_token, message_id)
+          Normalize.normalize_email(flatten_message(detail || item, address), address)
+        end
+      end
+    end
+  end
+end

data/lib/tempmail_sdk/providers/mail10s.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module TempmailSdk
+  module Providers
+    # mail10s.com 渠道实现
+    module Mail10s
+      CHANNEL = "mail10s"
+      BASE_URL = "https://mail10s.com"
+      DOMAIN = "mail10s.com"
+      HEADERS = { "Accept" => "application/json", "User-Agent" => "Mozilla/5.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 flatten(raw, recipient)
+        {
+          "id" => raw["id"].to_s,
+          "from" => (raw["sender"] || "").to_s,
+          "to" => recipient,
+          "subject" => (raw["subject"] || "").to_s,
+          "text" => (raw["body_text"] || "").to_s,
+          "html" => (raw["body_html"] || "").to_s,
+          "date" => (raw["received_at"] || "").to_s,
+          "attachments" => raw["attachments"].is_a?(Array) ? raw["attachments"] : []
+        }
+      end
+
+      # @return [EmailInfo]
+      def generate_email
+        email = "#{random_local}@#{DOMAIN}"
+        EmailInfo.new(channel: CHANNEL, email: email, token: email)
+      end
+
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(email)
+        address = email.to_s.strip
+        raise "mail10s: empty email" if address.empty?
+
+        resp = Http.get(
+          "#{BASE_URL}/api/emails/#{URI.encode_www_form_component(address)}/inbox",
+          headers: HEADERS, timeout: 15
+        )
+        resp.raise_for_status
+        data = resp.json
+        messages = if data.is_a?(Hash) && data["data"].is_a?(Hash)
+                     data["data"]["messages"]
+                   end
+        return [] unless messages.is_a?(Array)
+
+        messages.select { |r| r.is_a?(Hash) }.map { |row| Normalize.normalize_email(flatten(row, address), address) }
+      end
+    end
+  end
+end

data/lib/tempmail_sdk/providers/mail123.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module TempmailSdk
+  module Providers
+    # mail123.fr 渠道实现
+    module Mail123
+      CHANNEL = "mail123"
+      API_BASE = "https://mail123.fr/api/v1"
+      HEADERS = { "Accept" => "application/json", "User-Agent" => "Mozilla/5.0" }.freeze
+
+      module_function
+
+      def flatten(raw, recipient)
+        out = raw.dup
+        out["id"] = raw["id"].to_s
+        out["to"] = (raw["to"] || recipient).to_s
+        out["text"] = (raw["text"] || raw["preview"] || "").to_s
+        out["html"] = (raw["html"] || "").to_s
+        if raw.key?("is_unread") && (raw["is_unread"] == true || raw["is_unread"] == false)
+          out["isRead"] = !raw["is_unread"]
+        end
+        out
+      end
+
+      # @return [EmailInfo]
+      def generate_email
+        resp = Http.get("#{API_BASE}/mailbox/new", headers: HEADERS, timeout: 15)
+        resp.raise_for_status
+        data = resp.json
+        raise "mail123: invalid mailbox response" unless data.is_a?(Hash)
+
+        email = data["address"].to_s.strip
+        raise "mail123: invalid mailbox response" if email.empty? || !email.include?("@")
+
+        expires_at = nil
+        if data["expires_in_days"].is_a?(Numeric) && data["expires_in_days"] > 0
+          expires_at = ((Time.now.to_f + data["expires_in_days"].to_f * 86_400) * 1000).to_i
+        end
+
+        EmailInfo.new(channel: CHANNEL, email: email, token: email, expires_at: expires_at)
+      end
+
+      def fetch_detail(address, message_id)
+        resp = Http.get(
+          "#{API_BASE}/mailbox/#{URI.encode_www_form_component(address)}/messages/#{URI.encode_www_form_component(message_id)}",
+          headers: HEADERS, timeout: 15
+        )
+        return nil unless resp.ok?
+
+        data = resp.json
+        if data.is_a?(Hash) && data["message"].is_a?(Hash)
+          return data["message"]
+        end
+        nil
+      rescue StandardError
+        nil
+      end
+
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(email)
+        address = email.to_s.strip
+        raise "mail123: empty email" if address.empty?
+
+        resp = Http.get(
+          "#{API_BASE}/mailbox/#{URI.encode_www_form_component(address)}/messages?limit=50",
+          headers: HEADERS, timeout: 15
+        )
+        resp.raise_for_status
+        data = resp.json
+        rows = data.is_a?(Hash) ? (data["messages"] || []) : []
+        return [] unless rows.is_a?(Array)
+
+        rows.select { |r| r.is_a?(Hash) }.map do |item|
+          message_id = (item["id"] || "").to_s.strip
+          detail = message_id.empty? ? nil : fetch_detail(address, message_id)
+          Normalize.normalize_email(flatten(detail || item, address), address)
+        end
+      end
+    end
+  end
+end

data/lib/tempmail_sdk/providers/mail_cx.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require "securerandom"
+require "time"
+
+module TempmailSdk
+  module Providers
+    # mail.cx 渠道实现
+    # 匿名 Web API: https://mail.cx/v1
+    module MailCx
+      CHANNEL = "mail-cx"
+      BASE_URL = "https://mail.cx"
+      UA = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/146.0.0.0 Safari/537.36"
+
+      module_function
+
+      def random_string(length)
+        chars = ("a".."z").to_a + ("0".."9").to_a
+        Array.new(length) { chars.sample }.join
+      end
+
+      def client_id
+        "tempmail-sdk-#{random_string(16)}"
+      end
+
+      def headers(cid)
+        {
+          "Accept" => "application/json", "Origin" => BASE_URL, "Referer" => "#{BASE_URL}/",
+          "User-Agent" => UA, "X-Client-ID" => cid
+        }
+      end
+
+      def fetch_config(cid)
+        resp = Http.get("#{BASE_URL}/v1/config", headers: headers(cid), timeout: 15)
+        resp.raise_for_status
+        data = resp.json
+        data.is_a?(Hash) ? data : {}
+      end
+
+      def pick_domain(config, preferred)
+        items = config["system_domains"].is_a?(Array) ? config["system_domains"] : []
+        domains = items.select { |i| i.is_a?(Hash) && !i["domain"].to_s.strip.empty? }
+                       .map { |i| i["domain"].to_s.strip }
+        raise "mail-cx: no system domains" if domains.empty?
+
+        pref = preferred.to_s.strip.sub(/\A@/, "").downcase
+        unless pref.empty?
+          found = domains.find { |d| d.downcase == pref }
+          return found if found
+        end
+        default = items.find { |i| i.is_a?(Hash) && i["default"] && !i["domain"].to_s.strip.empty? }
+        default ? default["domain"].to_s.strip : domains.first
+      end
+
+      def first_non_empty(*values)
+        values.each do |v|
+          next if v.nil?
+
+          t = v.to_s.strip
+          return t unless t.empty?
+        end
+        ""
+      end
+
+      # @param preferred_domain [String, nil]
+      # @return [EmailInfo]
+      def generate_email(preferred_domain = nil)
+        cid = client_id
+        config = fetch_config(cid)
+        domain = pick_domain(config, preferred_domain)
+        created = Time.now.utc
+        expires_at = nil
+        ttl = config["ttl_seconds"]
+        expires_at = ((created + ttl).to_f * 1000).to_i if ttl.is_a?(Numeric) && ttl.positive?
+        EmailInfo.new(channel: CHANNEL, email: "#{random_string(12)}@#{domain}",
+                      token: cid, expires_at: expires_at, created_at: created.iso8601)
+      end
+
+      def fetch_detail(cid, message_id)
+        resp = Http.get("#{BASE_URL}/v1/email/#{URI.encode_www_form_component(message_id)}",
+                        headers: headers(cid), timeout: 15)
+        return nil unless resp.ok?
+
+        data = resp.json
+        data.is_a?(Hash) ? data : nil
+      end
+
+      # @param email [String]
+      # @param client_id [String]
+      # @return [Array<Email>]
+      def get_emails(email, client_id)
+        resp = Http.get("#{BASE_URL}/v1/inbox/#{URI.encode_www_form_component(email)}",
+                        headers: headers(client_id), timeout: 30)
+        return [] if resp.status_code == 204
+
+        resp.raise_for_status
+        data = resp.json
+        rows = data.is_a?(Hash) ? data["emails"] : nil
+        return [] unless rows.is_a?(Array)
+
+        rows.map do |row|
+          unless row.is_a?(Hash)
+            next Normalize.normalize_email({}, email)
+          end
+
+          raw = {
+            "id" => row["id"], "from" => first_non_empty(row["from_email"], row["from_name"]),
+            "to" => email, "subject" => row["subject"] || "", "text" => row["preview_text"] || "",
+            "created_at" => row["created_at"], "attachments" => row["attachments"]
+          }
+          mid = row["id"].to_s.strip
+          unless mid.empty?
+            begin
+              detail = fetch_detail(client_id, mid)
+              if detail
+                raw = {
+                  "id" => detail["id"], "from" => first_non_empty(detail["from_email"], detail["from_name"]),
+                  "to" => email, "subject" => detail["subject"] || "",
+                  "text" => first_non_empty(detail["text_body"], detail["preview_text"]),
+                  "html" => detail["html_body"] || "", "created_at" => detail["created_at"],
+                  "attachments" => detail["attachments"]
+                }
+              end
+            rescue StandardError
+              # 忽略详情失败
+            end
+          end
+          Normalize.normalize_email(raw, email)
+        end
+      end
+    end
+  end
+end

data/lib/tempmail_sdk/providers/mail_sunls.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module TempmailSdk
+  module Providers
+    # Mail Sunls 渠道实现
+    # API: https://mail.sunls.de
+    # 无需 token，无需 session
+    module MailSunls
+      CHANNEL = "mail-sunls"
+      BASE = "https://mail.sunls.de"
+
+      HEADERS = {
+        "Accept" => "application/json, text/plain, */*",
+        "Cache-Control" => "no-cache",
+        "DNT" => "1",
+        "Referer" => "https://mail.sunls.de/",
+        "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(length = 10)
+        chars = ("a".."z").to_a + ("0".."9").to_a
+        Array.new(length) { chars.sample }.join
+      end
+
+      # 从 API 获取可用域名列表
+      def fetch_domains
+        resp = Http.get("#{BASE}/api/domain", headers: HEADERS, timeout: 15)
+        resp.raise_for_status
+        data = resp.json
+        raise "mail-sunls: 域名列表响应格式无效" unless data.is_a?(Array)
+
+        out = data.select { |d| d.is_a?(String) && !d.strip.empty? }.map(&:strip)
+        raise "mail-sunls: 无可用域名" if out.empty?
+
+        out
+      end
+
+      # 创建临时邮箱：获取域名列表后随机生成地址
+      # @return [EmailInfo]
+      def generate_email
+        domains = fetch_domains
+        domain = domains.sample
+        local = random_local(10)
+        EmailInfo.new(channel: CHANNEL, email: "#{local}@#{domain}")
+      end
+
+      # 获取邮件列表
+      # @param email [String]
+      # @return [Array<Email>]
+      def get_emails(email)
+        addr = email.to_s.strip
+        raise "mail-sunls: 邮箱地址不能为空" if addr.empty?
+
+        resp = Http.get("#{BASE}/api/fetch?to=#{URI.encode_www_form_component(addr)}", headers: HEADERS, timeout: 15)
+        resp.raise_for_status
+        data = resp.json
+        return [] unless data.is_a?(Array)
+
+        data.select { |raw| raw.is_a?(Hash) }.map do |raw|
+          Normalize.normalize_email(raw, addr)
+        end
+      end
+    end
+  end
+end