teems 0.3.2 → 0.3.3

data/lib/teems/formatters/transcript_markdown.rb

@@ -7,8 +7,18 @@ module Teems
     # Converts Teams WebVTT transcripts into speaker-turn Markdown for local search indexes.
     # Consecutive cues from the same speaker are merged so each paragraph carries context.
     class TranscriptMarkdown
+      # One timed WebVTT cue: its start timestamp, speaker (nil when unattributed), and plain text
       Cue = Data.define(:start, :speaker, :text)
 
+      # Consecutive cues from one speaker, merged into a paragraph until it is too long to index well
+      Turn = Struct.new(:start, :speaker, :text) do
+        def self.from(cue) = new(cue.start, cue.speaker, +cue.text)
+
+        def accepts?(cue) = cue.speaker == speaker && text.length < MAX_TURN_CHARS
+
+        def add(cue) = text << ' ' << cue.text
+      end
+
       TIMING = /\A(?<start>(?:\d+:)?\d{2}:\d{2}\.\d{3})\s+-->/
       VOICE = /<v(?:\.[^\s>]+)?\s+([^>]+)>/
       ENTITIES = {
@@ -39,11 +49,7 @@ module Teems
 
       def append_cue(turns, cue)
         last = turns.last
-        if last && last[:speaker] == cue.speaker && last[:text].length < MAX_TURN_CHARS
-          last[:text] << ' ' << cue.text
-        else
-          turns << { start: cue.start, speaker: cue.speaker, text: +cue.text }
-        end
+        last&.accepts?(cue) ? last.add(cue) : turns << Turn.from(cue)
       end
 
       def cues
@@ -51,12 +57,10 @@ module Teems
         normalized.split(/\n{2,}/).filter_map { |block| parse_cue(block) }
       end
 
+      # Cue text is every line after the timing line; identifier lines before it are skipped
       def parse_cue(block)
-        lines = block.lines.map(&:chomp)
-        timing_index = lines.index { |line| TIMING.match?(line) }
-        return unless timing_index
-
-        build_cue(lines[timing_index][TIMING, :start], lines[(timing_index + 1)..].join(' '))
+        timing, *text = block.lines(chomp: true).drop_while { |line| !TIMING.match?(line) }
+        build_cue(timing[TIMING, :start], text.join(' ')) if timing
       end
 
       def build_cue(start, raw)
@@ -85,8 +89,8 @@ module Teems
       end
 
       def format_turn(turn)
-        speaker = turn[:speaker] || 'Unknown speaker'
-        "**#{speaker}** (#{turn[:start].sub(/\.\d+\z/, '')}): #{turn[:text]}"
+        speaker = turn.speaker || 'Unknown speaker'
+        "**#{speaker}** (#{turn.start.sub(/\.\d+\z/, '')}): #{turn.text}"
       end
     end
   end

data/lib/teems/models/inline_image.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require 'cgi'
+
+module Teems
+  module Models
+    # Extracts inline images (screenshots pasted into a message) from Teams message HTML.
+    # Teams stores them in its AMS object store and references them with
+    # <img itemtype="http://schema.skype.com/AMSImage" src="https://<ams-host>/v1/objects/<id>/views/imgo">.
+    module InlineImageParsing
+      IMG_TAG = /<img\b[^>]*>/i
+      ATTRIBUTE = /([\w:-]+)\s*=\s*(?:"([^"]*)"|'([^']*)')/
+      AMS_ITEMTYPE = 'schema.skype.com/AMSImage'
+      AMS_PATH = %r{\Ahttps://[^/\s]+/v1/objects/([^/?#\s]+)/views/}
+
+      module_function
+
+      def parse(html)
+        return [] unless html.is_a?(String) && html.match?(/<img/i)
+
+        html.scan(IMG_TAG).filter_map { |tag| image_from(tag_attributes(tag)) }.uniq(&:url)
+      end
+
+      def tag_attributes(tag)
+        tag.scan(ATTRIBUTE).to_h { |name, double, single| [name.downcase, CGI.unescapeHTML(double || single)] }
+      end
+
+      def image_from(attrs)
+        url = attrs['src'].to_s
+        return unless ams_image?(attrs, url)
+
+        InlineImage.new(id: attrs['itemid'] || url[AMS_PATH, 1], url: url, alt: attrs['alt'],
+                        width: dimension(attrs['width']), height: dimension(attrs['height']),
+                        format: attrs['itemscope'])
+      end
+
+      def ams_image?(attrs, url)
+        url.start_with?('https://') && (attrs['itemtype'].to_s.include?(AMS_ITEMTYPE) || url.match?(AMS_PATH))
+      end
+
+      def dimension(value) = Integer(value.to_s, exception: false)&.then { |num| num.positive? ? num : nil }
+    end
+
+    # An image pasted inline into a Teams message body
+    InlineImage = Data.define(:id, :url, :alt, :width, :height, :format) do
+      def self.parse_html(html) = InlineImageParsing.parse(html)
+
+      # Rebuilds an image from its stored (JSON) hash form
+      def self.from_h(hash)
+        return unless hash.is_a?(Hash)
+
+        attrs = hash.transform_keys(&:to_sym).slice(*members)
+        attrs[:url] ? new(**attrs) : nil
+      end
+
+      # Only the URL is required; the other attributes default to nil
+      def initialize(url:, **optional)
+        super(url: url, id: nil, alt: nil, width: nil, height: nil, format: nil, **optional)
+      end
+
+      # The original upload: `src` usually points at a recompressed JPEG preview,
+      # while this view is what Teams opens for "view full image".
+      def full_size_url
+        url.sub(%r{(/v1/objects/[^/]+/views/)[^/?#]+}, '\1imgpsh_fullsize_anim')
+      end
+
+      # JSON form: the stored attributes plus the original-resolution URL
+      def as_json = to_h.merge(full_size_url: full_size_url)
+
+      def dimensions = width && height ? "#{width}x#{height}" : nil
+
+      def label
+        name = alt.to_s.strip
+        name = 'image' if name.empty?
+        size = dimensions
+        size ? "#{name} (#{size})" : name
+      end
+
+      # Filesystem-safe name derived from the AMS object id
+      def file_stem = (id || url[%r{/v1/objects/([^/]+)/}, 1] || 'image').to_s.gsub(/[^\w.-]/, '_')
+    end
+  end
+end

data/lib/teems/models/message.rb

@@ -7,10 +7,13 @@ module Teems
     Message = Data.define(
       :id, :sender_id, :sender_name, :content, :created_at,
       :message_type, :reply_to_id, :reactions, :attachments, :importance,
-      :edited, :mentions
+      :edited, :mentions, :images
     ) do
       extend Parsing
 
+      # `images` (inline AMS images) defaults to empty so callers can omit it
+      def initialize(images: [], **attrs) = super
+
       def self.from_api(data)
         if data['message'] then from_teams_internal_api(data)
         elsif data['imdisplayname'] || data['messagetype'] then from_ng_msg_api(data)
@@ -27,7 +30,7 @@ module Teems
         {
           id: data['id'], sender_id: data['from'],
           sender_name: data['imdisplayname'] || data['fromDisplayNameInToken'] || 'Unknown',
-          content: strip_html(data['content'] || ''),
+          **html_body_attrs(data['content']),
           created_at: parse_time(data['composetime'] || data['originalarrivaltime']),
           message_type: data['messagetype'],
           **ng_msg_extras(data, props)
@@ -57,7 +60,7 @@ module Teems
         new(
           id: data['id'], sender_id: msg['from'],
           sender_name: msg['imDisplayName'] || msg['fromDisplayNameInToken'] || 'Unknown',
-          content: strip_html(msg['content'] || ''),
+          **html_body_attrs(msg['content']),
           created_at: parse_time(msg['composeTime'] || data['latestMessageTime']),
           message_type: msg['type'], reply_to_id: nil, reactions: [],
           attachments: parse_files_json(msg.dig('properties', 'files')),
@@ -74,7 +77,7 @@ module Teems
           id: data['id'],
           sender_id: data.dig('from', 'user', 'id') || data.dig('from', 'application', 'id'),
           sender_name: extract_sender_name(data),
-          content: strip_html(data.dig('body', 'content') || ''),
+          **html_body_attrs(data.dig('body', 'content')),
           created_at: parse_time(data['createdDateTime']),
           **graph_extras(data)
         }

data/lib/teems/models/parsing.rb

@@ -13,6 +13,11 @@ module Teems
         CGI.unescapeHTML(html.gsub(/<[^>]+>/, ' ')).gsub('&nbsp;', ' ').gsub(/\s+/, ' ').strip
       end
 
+      # Plain-text content plus the inline images that strip_html would discard
+      def html_body_attrs(html)
+        { content: strip_html(html || ''), images: InlineImage.parse_html(html) }
+      end
+
       def parse_time(time_str)
         return nil unless time_str
 

data/lib/teems/runner.rb

@@ -72,6 +72,11 @@ module Teems
       Services::TokenRefresher.new(token_store: @token_store, output: @output)
     end
 
+    # Downloader for inline message images; reads the current skype token on each request
+    def inline_image_downloader
+      Services::InlineImageDownloader.new(token_provider: -> { account.skype_token })
+    end
+
     # Attempt to refresh the skype_token
     def refresh_tokens
       token_refresher.refresh

data/lib/teems/services/inline_image_downloader.rb

@@ -0,0 +1,115 @@
+# frozen_string_literal: true
+
+module Teems
+  module Services
+    # Error responses from AMS, mapped so the caller can fall back or refresh tokens
+    module InlineImageErrors
+      # The requested AMS view does not exist for this object (try another view)
+      class ViewUnavailable < ApiError; end
+
+      MISSING_VIEW_CODES = %w[400 404 410].freeze
+
+      private
+
+      def raise_failure(response)
+        code = response.code
+        status = code.to_i
+        raise ApiError.new('Invalid token or session expired', status_code: 401) if status == 401
+        raise ViewUnavailable.new("HTTP #{code}", status_code: status) if MISSING_VIEW_CODES.include?(code)
+
+        raise ApiError.new("HTTP #{code}", status_code: status)
+      end
+
+      def untrusted_host!(uri)
+        raise Error, "Refusing to send Teams credentials to untrusted image host: #{uri.host}"
+      end
+    end
+
+    # Identifies image bytes by their magic number
+    module ImageSignature
+      SIGNATURES = { 'png' => "\x89PNG".b, 'jpg' => "\xFF\xD8\xFF".b, 'gif' => 'GIF8'.b }.freeze
+
+      module_function
+
+      def extension_for(body)
+        bytes = body.to_s.b
+        found = SIGNATURES.find { |_ext, magic| bytes.start_with?(magic) }&.first
+        found || ('webp' if bytes.start_with?('RIFF') && bytes.byteslice(8, 4) == 'WEBP')
+      end
+    end
+
+    # Fetches inline message images from Teams' AMS object store. AMS accepts the
+    # skype token as `Authorization: skype_token <token>` (Bearer tokens get a 401).
+    # Credentials are only sent over HTTPS to Microsoft Teams/Skype hosts.
+    class InlineImageDownloader
+      include InlineImageErrors
+
+      # Downloaded image bytes, the file extension they imply, and the URL that served them
+      Result = Data.define(:body, :extension, :url)
+
+      TRUSTED_HOST = /(?:\A|\.)(?:asm\.skype\.com|teams\.microsoft\.com|teams\.microsoft\.us)\z/i
+      MAX_REDIRECTS = 3
+      TIMEOUTS = { open_timeout: 10, read_timeout: 60 }.freeze
+
+      # token_provider is called per request so a refreshed skype token is picked up
+      def initialize(token_provider:, http_client: nil)
+        @token_provider = token_provider
+        @http_client = http_client
+      end
+
+      # Prefers the original upload and falls back to the `src` preview when that view is missing
+      def fetch(image)
+        full_size = image.full_size_url
+        preview = image.url
+        fetch_url(full_size)
+      rescue ViewUnavailable
+        raise if full_size == preview
+
+        fetch_url(preview)
+      end
+
+      def self.trusted?(uri) = uri.is_a?(URI::HTTPS) && TRUSTED_HOST.match?(uri.host.to_s)
+
+      private
+
+      def fetch_url(url)
+        uri = URI(url)
+        untrusted_host!(uri) unless self.class.trusted?(uri)
+
+        follow(uri, MAX_REDIRECTS)
+      end
+
+      def follow(uri, redirects_left)
+        response = http_get(uri)
+        case response
+        when Net::HTTPSuccess then build_result(response.body, uri)
+        when Net::HTTPRedirection then follow_redirect(uri, response['location'], redirects_left)
+        else raise_failure(response)
+        end
+      end
+
+      def follow_redirect(uri, location, redirects_left)
+        raise Error, 'Too many redirects' unless redirects_left.positive? && location
+
+        follow(uri + location, redirects_left - 1)
+      end
+
+      def build_result(body, uri)
+        extension = ImageSignature.extension_for(body)
+        raise Error, 'Response was not an image' unless extension
+
+        Result.new(body: body.to_s, extension: extension, url: uri.to_s)
+      end
+
+      # Redirect targets outside Teams/Skype (e.g. a signed CDN URL) get no credentials
+      def http_get(uri)
+        headers = self.class.trusted?(uri) ? { 'Authorization' => "skype_token #{@token_provider.call}" } : {}
+        return @http_client.call(uri, headers) if @http_client
+
+        Net::HTTP.start(uri.host, uri.port, use_ssl: true, **TIMEOUTS) do |http|
+          http.request(Net::HTTP::Get.new(uri, headers))
+        end
+      end
+    end
+  end
+end

data/lib/teems/services/sync_engine.rb

@@ -23,7 +23,8 @@ module Teems
             { 'type' => reaction[:type], 'count' => reaction[:count] }
           end,
           'attachments' => message.attachments, 'importance' => message.importance,
-          'edited' => message.edited, 'mentions' => message.mentions
+          'edited' => message.edited, 'mentions' => message.mentions,
+          'images' => message.images.map(&:as_json)
         }
       end
 
@@ -49,7 +50,8 @@ module Teems
           attachments: stored_default(data, 'attachments', []),
           importance: data['importance'],
           edited: stored_default(data, 'edited', false),
-          mentions: stored_default(data, 'mentions', []) }
+          mentions: stored_default(data, 'mentions', []),
+          images: Array(data['images']).filter_map { |image| Models::InlineImage.from_h(image) } }
       end
 
       def stored_default(data, key, fallback) = data[key] || fallback
@@ -140,10 +142,11 @@ module Teems
         filter_and_sort_messages(messages, start_time)
       end
 
-      def merge_and_write(chat, existing_raw, new_messages)
+      # Yields (chat_dir, merged_messages) before writing, e.g. to save inline images first
+      def merge_and_write(chat, existing_raw, new_messages, &)
         existing = existing_raw.map { |data| message_from_stored(data) }
         all_messages = merge_messages(existing, new_messages)
-        write_chat_files(chat, all_messages)
+        write_chat_files(chat, all_messages, &)
         all_messages
       end
 
@@ -172,10 +175,13 @@ module Teems
       def index_by_id(messages) = messages.to_h { |msg| [msg.id, msg] }
 
       def write_chat_files(chat, messages)
-        fmt = Formatters::MarkdownFormatter.new(chat_name: chat.display_name,
-                                                chat_type: chat.chat_type, synced_at: Time.now)
+        chat_id = chat.id
+        chat_dir = @sync_store.chat_dir(chat_id, state: @state)
+        yield(chat_dir, messages) if block_given?
+        fmt = Formatters::MarkdownFormatter.new(chat_name: chat.display_name, chat_type: chat.chat_type,
+                                                synced_at: Time.now, image_link: SyncImages.link_resolver(chat_dir))
         json = JSON.pretty_generate(messages.map { |msg| message_to_hash(msg) })
-        @sync_store.write_messages(chat.id, messages_md: fmt.format(messages), messages_json: json, state: @state)
+        @sync_store.write_messages(chat_id, messages_md: fmt.format(messages), messages_json: json, state: @state)
         write_metadata(chat)
       end
 

data/lib/teems/services/sync_images.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Teems
+  module Services
+    # Inline images saved beside a synced chat (`teems sync --images`) and linked from messages.md.
+    # Files are named by AMS object id, so images already on disk are never fetched again.
+    class SyncImages
+      DIR = 'images'
+
+      # { file stem => file name } for the images already saved for a chat
+      def self.saved(chat_dir)
+        dir = File.join(chat_dir, DIR)
+        return {} unless File.directory?(dir)
+
+        Dir.children(dir).reject { |name| name.end_with?('.tmp') }.to_h { |name| [File.basename(name, '.*'), name] }
+      end
+
+      # Callable for MarkdownFormatter: relative path of a saved image, or nil
+      def self.link_resolver(chat_dir)
+        saved = saved(chat_dir)
+        lambda do |image|
+          name = saved[image.file_stem]
+          "#{DIR}/#{name}" if name
+        end
+      end
+
+      def initialize(downloader:, output: nil)
+        @downloader = downloader
+        @output = output
+      end
+
+      # Downloads images not yet on disk; returns how many were saved
+      def save(chat_dir, messages)
+        existing = self.class.saved(chat_dir)
+        pending = messages.flat_map(&:images).uniq(&:file_stem).reject { |image| existing.key?(image.file_stem) }
+        pending.sum { |image| save_image(File.join(chat_dir, DIR), image) }
+      end
+
+      private
+
+      def save_image(dir, image)
+        stem = image.file_stem
+        result = @downloader.fetch(image)
+        FileUtils.mkdir_p(dir)
+        path = File.join(dir, "#{stem}.#{result.extension}")
+        File.binwrite("#{path}.tmp", result.body)
+        File.rename("#{path}.tmp", path)
+        1
+      rescue StandardError => e
+        @output&.warn("  Could not download image #{stem}: #{e.message}")
+        0
+      end
+    end
+  end
+end

data/lib/teems/support/subprocess.rb

@@ -17,6 +17,8 @@ module Teems
     module Subprocess
       module_function
 
+      # Named after Open3.capture3, which it wraps with the same signature and return value
+      # :reek:UncommunicativeMethodName
       def capture3(*command)
         previous = Thread.report_on_exception
         Thread.report_on_exception = false

data/lib/teems/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Teems
-  VERSION = '0.3.2'
+  VERSION = '0.3.3'
 end

data/lib/teems.rb

@@ -49,6 +49,8 @@ module Teems
     autoload :Chat, 'teems/models/chat'
     autoload :Event, 'teems/models/event'
     autoload :Message, 'teems/models/message'
+    autoload :InlineImage, 'teems/models/inline_image'
+    autoload :InlineImageParsing, 'teems/models/inline_image'
     autoload :Parsing, 'teems/models/parsing'
     autoload :User, 'teems/models/user'
     autoload :UserProfile, 'teems/models/user_profile'
@@ -64,11 +66,13 @@ module Teems
     autoload :TokenRefresher, 'teems/services/token_refresher'
     autoload :CacheStore, 'teems/services/cache_store'
     autoload :FileDownloader, 'teems/services/file_downloader'
+    autoload :InlineImageDownloader, 'teems/services/inline_image_downloader'
     autoload :TeamsUrlParser, 'teems/services/teams_url_parser'
     autoload :SyncStore, 'teems/services/sync_store'
     autoload :SyncDirNaming, 'teems/services/sync_dir_naming'
     autoload :SafariJsRunner, 'teems/services/safari_js_runner'
     autoload :SyncEngine, 'teems/services/sync_engine'
+    autoload :SyncImages, 'teems/services/sync_images'
   end
 
   # Output formatters for messages and terminal output

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: teems
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Eric Boehs
@@ -62,6 +62,7 @@ files:
 - lib/teems/models/chat.rb
 - lib/teems/models/duration.rb
 - lib/teems/models/event.rb
+- lib/teems/models/inline_image.rb
 - lib/teems/models/message.rb
 - lib/teems/models/parsing.rb
 - lib/teems/models/user.rb
@@ -72,10 +73,12 @@ files:
 - lib/teems/services/configuration.rb
 - lib/teems/services/file_downloader.rb
 - lib/teems/services/headless_extract.rb
+- lib/teems/services/inline_image_downloader.rb
 - lib/teems/services/safari_js_runner.rb
 - lib/teems/services/safari_oauth.rb
 - lib/teems/services/sync_dir_naming.rb
 - lib/teems/services/sync_engine.rb
+- lib/teems/services/sync_images.rb
 - lib/teems/services/sync_store.rb
 - lib/teems/services/teams_url_parser.rb
 - lib/teems/services/token_exchange_scripts.rb