rb-edge-tts 1.0.0

data/lib/rb_edge_tts/constants.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module RbEdgeTTS
+  BASE_URL = 'speech.platform.bing.com/consumer/speech/synthesize/readaloud'
+  TRUSTED_CLIENT_TOKEN = '6A5AA1D4EAFF4E9FB37E23D68491D6F4'
+
+  WSS_URL = "wss://#{BASE_URL}/edge/v1?TrustedClientToken=#{TRUSTED_CLIENT_TOKEN}"
+  VOICE_LIST = "https://#{BASE_URL}/voices/list?trustedclienttoken=#{TRUSTED_CLIENT_TOKEN}"
+
+  DEFAULT_VOICE = 'en-US-EmmaMultilingualNeural'
+
+  CHROMIUM_FULL_VERSION = '143.0.3650.75'
+  CHROMIUM_MAJOR_VERSION = CHROMIUM_FULL_VERSION.split('.', 2).first
+  SEC_MS_GEC_VERSION = "1-#{CHROMIUM_FULL_VERSION}"
+
+  BASE_HEADERS = {
+    'User-Agent' => "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/#{CHROMIUM_MAJOR_VERSION}.0.0.0 Safari/537.36 Edg/#{CHROMIUM_MAJOR_VERSION}.0.0.0",
+    'Accept-Encoding' => 'gzip, deflate, br, zstd',
+    'Accept-Language' => 'en-US,en;q=0.9'
+  }.freeze
+
+  WSS_HEADERS = BASE_HEADERS.merge(
+    'Pragma' => 'no-cache',
+    'Cache-Control' => 'no-cache',
+    'Origin' => 'chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold',
+    'Sec-WebSocket-Version' => '13'
+  ).freeze
+
+  VOICE_HEADERS = BASE_HEADERS.merge(
+    'Authority' => 'speech.platform.bing.com',
+    'Sec-CH-UA' => "\" Not;A Brand\";v=\"99\", \"Microsoft Edge\";v=\"#{CHROMIUM_MAJOR_VERSION}\", \"Chromium\";v=\"#{CHROMIUM_MAJOR_VERSION}\"",
+    'Sec-CH-UA-Mobile' => '?0',
+    'Accept' => '*/*',
+    'Sec-Fetch-Site' => 'none',
+    'Sec-Fetch-Mode' => 'cors',
+    'Sec-Fetch-Dest' => 'empty'
+  ).freeze
+end

data/lib/rb_edge_tts/drm.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'securerandom'
+require 'time'
+
+module RbEdgeTTS
+  class DRM
+    @clock_skew_seconds = 0.0
+
+    WIN_EPOCH = 11_644_473_600
+    S_TO_NS = 1_000_000_000
+
+    class << self
+      attr_accessor :clock_skew_seconds
+
+      def adj_clock_skew_seconds(skew_seconds)
+        @clock_skew_seconds += skew_seconds
+      end
+
+      def get_unix_timestamp
+        Time.now.utc.to_f + @clock_skew_seconds
+      end
+
+      def parse_rfc2616_date(date_string)
+        Time.rfc2822(date_string)&.to_f
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def handle_client_response_error(error)
+        raise SkewAdjustmentError, 'No server date in headers.' unless error.headers
+
+        server_date = error.headers['Date'] || error.headers['date']
+        raise SkewAdjustmentError, 'No server date in headers.' unless server_date
+
+        server_date_parsed = parse_rfc2616_date(server_date)
+        raise SkewAdjustmentError, "Failed to parse server date: #{server_date}" unless server_date_parsed
+
+        client_date = get_unix_timestamp
+        adj_clock_skew_seconds(server_date_parsed - client_date)
+      end
+
+      def generate_sec_ms_gec
+        ticks = get_unix_timestamp
+        ticks += WIN_EPOCH
+        ticks -= (ticks % 300)
+        ticks = (ticks * S_TO_NS / 100).round
+
+        str_to_hash = "#{ticks.to_i}#{TRUSTED_CLIENT_TOKEN}"
+        Digest::SHA256.hexdigest(str_to_hash).upcase
+      end
+
+      def command_request(boundary)
+        word_boundary = boundary == 'WordBoundary'
+        wd = word_boundary ? 'true' : 'false'
+        sq = !word_boundary ? 'true' : 'false'
+
+        "X-Timestamp:#{Util.date_to_string}\r\n" \
+          "Content-Type:application/json; charset=utf-8\r\n" \
+          "Path:speech.config\r\n\r\n" \
+          '{"context":{"synthesis":{"audio":{"metadataoptions":{' \
+          "\"sentenceBoundaryEnabled\":\"#{sq}\",\"wordBoundaryEnabled\":\"#{wd}\"" \
+          '},' \
+          '"outputFormat":"audio-24khz-48kbitrate-mono-mp3"' \
+          '}}}}'
+      end
+
+      def generate_muid
+        SecureRandom.hex(16).upcase
+      end
+
+      def headers_with_muid(headers)
+        combined_headers = headers.dup
+        raise ArgumentError, 'Headers already contain Cookie' if combined_headers.key?('Cookie')
+
+        combined_headers['Cookie'] = "muid=#{generate_muid};"
+        combined_headers
+      end
+    end
+  end
+end

data/lib/rb_edge_tts/exceptions.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module RbEdgeTTS
+  class EdgeTTSException < StandardError; end
+  class UnknownResponse < EdgeTTSException; end
+  class UnexpectedResponse < EdgeTTSException; end
+  class NoAudioReceived < EdgeTTSException; end
+  class WebSocketError < EdgeTTSException; end
+  class SkewAdjustmentError < EdgeTTSException; end
+end

data/lib/rb_edge_tts/srt_composer.rb

@@ -0,0 +1,99 @@
+# frozen_string_literal: true
+
+module RbEdgeTTS
+  class Subtitle
+    attr_reader :index, :start, :end, :content
+
+    def initialize(index, start_time, end_time, content)
+      @index = index
+      @start = start_time
+      @end = end_time
+      @content = content
+    end
+
+    def to_srt(eol = "\n")
+      output_content = make_legal_content(content)
+      output_content = output_content.gsub("\n", eol) if eol != "\n"
+
+      template = "#{index}#{eol}#{timedelta_to_srt_timestamp(start)} --> #{timedelta_to_srt_timestamp(@end)}#{eol}#{output_content}#{eol}#{eol}"
+      template
+    end
+
+    def <=>(other)
+      [start, @end, index] <=> [other.start, other.end, other.index]
+    end
+
+    def hash
+      [index, start, @end, content].hash
+    end
+
+    alias eql? ==
+
+    private
+
+    def make_legal_content(content_str)
+      return content_str unless content_str.start_with?("\n") || content_str.include?("\n\n")
+
+      content_str.strip.split(/\n\n+/).join("\n")
+    end
+
+    def timedelta_to_srt_timestamp(time_delta)
+      total_seconds = time_delta.to_i
+      hours, remainder = total_seconds.divmod(3600)
+      minutes, seconds = remainder.divmod(60)
+      milliseconds = (time_delta * 1000).to_i % 1000
+
+      format('%02d:%02d:%02d,%03d', hours, minutes, seconds, milliseconds)
+    end
+  end
+
+  module SRTComposer
+    SECONDS_IN_HOUR = 3600
+    SECONDS_IN_MINUTE = 60
+
+    def self.compose(subtitles, reindex: true, start_index: 1, eol: "\n")
+      subtitles_to_use = reindex ? sort_and_reindex(subtitles, start_index:) : subtitles
+      subtitles_to_use.map { |sub| sub.to_srt(eol) }.join
+    end
+
+    def self.sort_and_reindex(subtitles, start_index: 1)
+      sorted_subs = subtitles.sort
+      result = []
+      current_index = start_index
+
+      sorted_subs.each do |sub|
+        next unless should_include_subtitle?(sub)
+
+        new_sub = Subtitle.new(current_index, sub.start, sub.end, sub.content)
+        result << new_sub
+        current_index += 1
+      end
+
+      result
+    end
+
+    class << self
+      private
+
+      def should_include_subtitle?(subtitle)
+        return false if content_empty?(subtitle)
+        return false if negative_start_time?(subtitle)
+        return false if invalid_time_range?(subtitle)
+
+        true
+      end
+
+      def content_empty?(subtitle)
+        subtitle.content.strip.empty?
+      end
+
+      def negative_start_time?(subtitle)
+        subtitle.start < 0
+      end
+
+      def invalid_time_range?(subtitle)
+        subtitle.start >= subtitle.end
+      end
+    end
+  end
+end

data/lib/rb_edge_tts/submaker.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require_relative 'srt_composer'
+
+module RbEdgeTTS
+  class SubMaker
+    attr_reader :cues, :type
+
+    def initialize
+      @cues = []
+      @type = nil
+    end
+
+    def feed(msg)
+      raise ArgumentError, 'msg must be a TTSChunk' unless msg.is_a?(TTSChunk)
+      raise ArgumentError, "Invalid message type, expected 'WordBoundary' or 'SentenceBoundary'." unless %w[
+        WordBoundary SentenceBoundary
+      ].include?(msg.type)
+
+      @type = msg.type if @type.nil?
+      raise ArgumentError, "Expected message type '#{@type}', but got '#{msg.type}'." if @type != msg.type
+
+      start_time = msg.offset / 10_000_000.0
+      end_time = (msg.offset + msg.duration) / 10_000_000.0
+      subtitle = Subtitle.new(cues.size + 1, start_time, end_time, msg.text)
+      @cues << subtitle
+    end
+
+    def get_srt
+      SRTComposer.compose(@cues)
+    end
+
+    alias to_srt get_srt
+
+    def to_s
+      get_srt
+    end
+  end
+end

data/lib/rb_edge_tts/typing.rb

@@ -0,0 +1,93 @@
+# frozen_string_literal: true
+
+module RbEdgeTTS
+  TTSChunk = Struct.new(:type, :data, :offset, :duration, :text, keyword_init: true)
+
+  VoiceTag = Struct.new(:content_categories, :voice_personalities, keyword_init: true)
+
+  Voice = Struct.new(
+    :name,
+    :short_name,
+    :gender,
+    :locale,
+    :suggested_codec,
+    :friendly_name,
+    :status,
+    :voice_tag,
+    keyword_init: true
+  )
+
+  VoicesManagerVoice = Struct.new(
+    :name,
+    :short_name,
+    :gender,
+    :locale,
+    :suggested_codec,
+    :friendly_name,
+    :status,
+    :voice_tag,
+    :language,
+    keyword_init: true
+  )
+
+  CommunicateState = Struct.new(
+    :partial_text,
+    :offset_compensation,
+    :last_duration_offset,
+    :stream_was_called,
+    keyword_init: true
+  )
+
+  class TTSConfig
+    attr_reader :voice, :rate, :volume, :pitch, :boundary
+
+    def initialize(voice, rate, volume, pitch, boundary)
+      validate_voice!(voice)
+      @voice = normalize_voice(voice)
+      @rate = validate_string_param('rate', rate, /^[+-]\d+%$/)
+      @volume = validate_string_param('volume', volume, /^[+-]\d+%$/)
+      @pitch = validate_string_param('pitch', pitch, /^[+-]\d+Hz$/)
+      @boundary = validate_boundary(boundary)
+    end
+
+    private
+
+    def validate_voice!(voice)
+      raise TypeError, 'voice must be a string' unless voice.is_a?(String)
+    end
+
+    def normalize_voice(voice)
+      # Check if voice is in short format (e.g., "en-US-EmmaMultilingualNeural")
+      match = voice.match(/^([a-z]{2,})-([A-Z]{2,})-(.+Neural)$/)
+      if match
+        lang = match[1]
+        region = match[2]
+        name = match[3]
+
+        # Handle names with hyphens (e.g., "en-US-JennyNeural-Angry")
+        if name.include?('-')
+          region = "#{region}-#{name[0...name.index('-')]}"
+          name = name[(name.index('-') + 1)..-1]
+        end
+
+        return "Microsoft Server Speech Text to Speech Voice (#{lang}-#{region}, #{name})"
+      end
+
+      voice
+    end
+
+    def validate_string_param(param_name, param_value, pattern)
+      raise TypeError, "#{param_name} must be a string" unless param_value.is_a?(String)
+      raise ArgumentError, "Invalid #{param_name} '#{param_value}'" unless param_value.match?(pattern)
+
+      param_value
+    end
+
+    def validate_boundary(boundary)
+      raise TypeError, 'boundary must be a string' unless boundary.is_a?(String)
+      raise ArgumentError, "Invalid boundary '#{boundary}'" unless %w[WordBoundary SentenceBoundary].include?(boundary)
+
+      boundary
+    end
+  end
+end

data/lib/rb_edge_tts/util.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module RbEdgeTTS
+  module Util
+    class << self
+      def get_headers_and_data(data, header_length)
+        raise TypeError, 'data must be a string' unless data.is_a?(String)
+
+        headers = {}
+        data[0...header_length].split("\r\n").each do |line|
+          key, value = line.split(':', 2)
+          headers[key.strip] = value.strip if key && value
+        end
+
+        [headers, data[(header_length + 2)..-1]]
+      end
+
+      def remove_incompatible_characters(string)
+        return string.encode('utf-8') if string.is_a?(String)
+        return string.dup.force_encoding('utf-8') if string.is_a?(String)
+
+        string.to_s
+      end
+
+      def connect_id
+        SecureRandom.uuid.gsub('-', '')
+      end
+
+      def split_text_by_byte_length(text, byte_length)
+        raise TypeError, 'text must be a string' unless text.is_a?(String)
+        raise ArgumentError, 'byte_length must be greater than 0' if byte_length <= 0
+
+        encoded_text = text.encode('utf-8')
+        Enumerator.new do |yielder|
+          while encoded_text.bytesize > byte_length
+            split_at = find_last_newline_or_space_within_limit(encoded_text, byte_length)
+
+            split_at = find_safe_utf8_split_point(encoded_text, byte_length) if split_at.nil? || split_at < 0
+
+            split_at = adjust_split_point_for_xml_entity(encoded_text, split_at)
+
+            raise ArgumentError, 'Maximum byte length is too small or invalid text structure' if split_at < 0
+
+            chunk = encoded_text[0...split_at].strip
+            yielder << chunk unless chunk.empty?
+
+            encoded_text = encoded_text[(split_at > 0 ? split_at : 1)..-1]
+          end
+
+          remaining_chunk = encoded_text.strip
+          yielder << remaining_chunk unless remaining_chunk.empty?
+        end
+      end
+
+      def mkssml(tts_config, escaped_text)
+        escaped_text = escaped_text.encode('utf-8') if escaped_text.is_a?(String)
+
+        "<speak version='1.0' xmlns='http://www.w3.org/2001/10/synthesis' xml:lang='en-US'>" \
+          "<voice name='#{tts_config.voice}'>" \
+          "<prosody pitch='#{tts_config.pitch}' rate='#{tts_config.rate}' volume='#{tts_config.volume}'>" \
+          "#{escaped_text}" \
+          '</prosody>' \
+          '</voice>' \
+          '</speak>'
+      end
+
+      def date_to_string
+        Time.now.utc.strftime('%a %b %d %Y %H:%M:%S GMT+0000 (Coordinated Universal Time)')
+      end
+
+      def ssml_headers_plus_data(request_id, timestamp, ssml)
+        <<~HEADERS
+          X-RequestId:#{request_id}\r
+          Content-Type:application/ssml+xml\r
+          X-Timestamp:#{timestamp}Z\r
+          Path:ssml\r
+          \r
+          #{ssml}
+        HEADERS
+      end
+
+      def escape_xml(text)
+        CGI.escapeHTML(text)
+      end
+
+      def unescape_xml(text)
+        CGI.unescapeHTML(text)
+      end
+
+      private
+
+      def find_last_newline_or_space_within_limit(text, limit)
+        split_at = text.rindex("\n", [limit - 1, 0].max)
+        split_at = text.rindex(' ', [limit - 1, 0].max) if split_at.nil? || split_at < 0
+        split_at
+      end
+
+      def find_safe_utf8_split_point(text_segment, byte_length = text_segment.bytesize)
+        split_at = [byte_length, text_segment.bytesize].min
+        while split_at > 0
+          begin
+            text_segment.byteslice(0, split_at).encode('utf-8')
+            return split_at
+          rescue Encoding::UndefinedConversionError
+            split_at -= 1
+          end
+        end
+        split_at
+      end
+
+      def adjust_split_point_for_xml_entity(text, split_at)
+        while split_at > 0 && text[0...split_at].include?('&')
+          ampersand_index = text.rindex('&', split_at - 1)
+          break if text.index(';', ampersand_index)&.< split_at
+
+          split_at = ampersand_index
+        end
+        split_at
+      end
+    end
+  end
+end

data/lib/rb_edge_tts/version.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module RbEdgeTTS
+  VERSION = '1.0.0'
+  VERSION_INFO = VERSION.split('.').map(&:to_i).freeze
+end

data/lib/rb_edge_tts/voices_manager.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module RbEdgeTTS
+  class VoicesManager
+    attr_accessor :voices
+    attr_reader :called_create
+
+    def initialize
+      @voices = []
+      @called_create = false
+    end
+
+    def self.create(custom_voices = nil)
+      voices_data = if custom_voices.nil?
+                      EdgeTTS.list_voices_helper
+                    else
+                      custom_voices
+                    end
+
+      voices_manager = new
+      voices_manager.voices = voices_data.map do |voice|
+        language = voice.locale.split('-').first
+        VoicesManagerVoice.new(
+          name: voice.name,
+          short_name: voice.short_name,
+          gender: voice.gender,
+          locale: voice.locale,
+          suggested_codec: voice.suggested_codec,
+          friendly_name: voice.friendly_name,
+          status: voice.status,
+          voice_tag: voice.voice_tag,
+          language: language
+        )
+      end
+      voices_manager.called_create = true
+      voices_manager
+    end
+
+    def find(**kwargs)
+      raise 'VoicesManager.find() called before VoicesManager.create()' unless @called_create
+
+      voices.select do |voice|
+        kwargs.all? do |key, value|
+          send(key.to_s, voice) == value
+        end
+      end
+    end
+
+    def gender(voice)
+      voice.gender
+    end
+
+    def locale(voice)
+      voice.locale
+    end
+
+    def language(voice)
+      voice.language
+    end
+  end
+
+  def self.list_voices(connector: nil, proxy: nil)
+    list_voices_helper(connector: connector, proxy: proxy)
+  end
+
+  def self.list_voices_helper(connector: nil, proxy: nil)
+    url = "#{VOICE_LIST}&Sec-MS-GEC=#{DRM.generate_sec_ms_gec}&Sec-MS-GEC-Version=#{SEC_MS_GEC_VERSION}"
+    headers = DRM.headers_with_muid(VOICE_HEADERS)
+
+    require 'net/http'
+    require 'uri'
+
+    uri = URI(url)
+    http = Net::HTTP.new(uri.host, uri.port)
+    http.use_ssl = true
+    http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+
+    request = Net::HTTP::Get.new(uri)
+    headers.each { |k, v| request[k] = v }
+
+    response = http.request(request)
+    raise UnexpectedResponse, "HTTP #{response.code}" unless response.is_a?(Net::HTTPSuccess)
+
+    body = JSON.parse(response.body)
+    body.map do |voice_data|
+      voice_data[:voice_tag] ||= {}
+      voice_data[:voice_tag][:content_categories] ||= []
+      voice_data[:voice_tag][:voice_personalities] ||= []
+
+      voice_data = voice_data.transform_keys { |k| k.to_s.gsub(/([a-z])([A-Z])/, '\1_\2').downcase.to_sym }
+      voice_data[:voice_tag] = VoiceTag.new(
+        content_categories: voice_data.dig(:voice_tag, :content_categories) || [],
+        voice_personalities: voice_data.dig(:voice_tag, :voice_personalities) || []
+      )
+      Voice.new(**voice_data)
+    end
+  end
+end

data/lib/rb_edge_tts.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require 'eventmachine'
+require 'faye/websocket'
+require 'json'
+require 'openssl'
+require 'securerandom'
+require 'time'
+
+require_relative 'rb_edge_tts/typing'
+require_relative 'rb_edge_tts/constants'
+require_relative 'rb_edge_tts/drm'
+require_relative 'rb_edge_tts/util'
+require_relative 'rb_edge_tts/srt_composer'
+require_relative 'rb_edge_tts/submaker'
+require_relative 'rb_edge_tts/voices_manager'
+require_relative 'rb_edge_tts/exceptions'
+require_relative 'rb_edge_tts/communicate'
+require_relative 'rb_edge_tts/version'

data/lib/rb_edge_tts_simple.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'async'
+require 'async/http'
+require 'async/io/stream'
+require 'json'
+require 'openssl'
+require 'time'
+
+module RbEdgeTTS
+  VERSION = '7.2.7'
+  VERSION_INFO = VERSION.split('.').map(&:to_i).freeze
+
+  # Test basic functionality
+  begin
+    puts 'Module loaded successfully'
+    puts "Version: #{VERSION}"
+    puts "Sec-MS-GEC: #{DRM.generate_sec_ms_gec}"
+    puts "MUID: #{DRM.generate_muid}"
+  rescue StandardError => e
+    puts "Error loading module: #{e.message}"
+  end
+end

data/rb-edge-tts.gemspec

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require_relative 'lib/rb_edge_tts/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'rb-edge-tts'
+  spec.version       = RbEdgeTTS::VERSION
+  spec.authors = ["Peng Zhang"]
+  spec.email = ["zpregister@gmail.com"]
+
+  spec.summary       = 'Ruby gem for Microsoft Edge\'s online text-to-speech service'
+  spec.description   = 'A Ruby library and CLI tool to use Microsoft Edge\'s online TTS service from within Ruby code or using the provided rb-edge-tts or rb-edge-playback commands.'
+  spec.homepage      = 'https://github.com/yourusername/rb-edge-tts'
+  spec.license       = 'LGPL-3.0-or-later'
+  spec.required_ruby_version = '>= 3.0.0'
+
+  spec.metadata['homepage_uri'] = spec.homepage
+  spec.metadata['source_code_uri'] = 'https://github.com/yourusername/rb-edge-tts'
+  spec.metadata['changelog_uri'] = 'https://github.com/yourusername/rb-edge-tts/blob/main/CHANGELOG.md'
+
+  spec.files = Dir.glob('{lib,exe,examples}/**/*') + %w[
+    LICENSE
+    README.md
+    Rakefile
+    rb-edge-tts.gemspec
+    Gemfile
+  ]
+  spec.bindir        = 'exe'
+  spec.executables   = %w[rb-edge-tts rb-edge-playback]
+  spec.require_paths = ['lib']
+
+  spec.add_dependency 'eventmachine', '~> 1.2'
+  spec.add_dependency 'faye-websocket', '~> 0.11'
+  spec.add_dependency 'json', '~> 2.6'
+  spec.add_dependency 'terminal-table', '~> 3.0'
+
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'rspec', '~> 3.12'
+  spec.add_development_dependency 'rubocop', '~> 1.50'
+  spec.add_development_dependency 'rubocop-rspec', '~> 2.20'
+  spec.add_development_dependency 'simplecov', '~> 0.22'
+end