teems 0.1.0

data/lib/teems/services/sync_engine.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Teems
+  module Services
+    # Message serialization helpers for sync storage
+    module SyncSerializer
+      private
+
+      def message_to_hash(message) = msg_core_hash(message).merge(msg_extras_hash(message))
+
+      def msg_core_hash(message)
+        {
+          'id' => message.id, 'sender_id' => message.sender_id,
+          'sender_name' => message.sender_name, 'content' => message.content,
+          'created_at' => message.created_at&.iso8601, 'message_type' => message.message_type
+        }
+      end
+
+      def msg_extras_hash(message)
+        {
+          'reply_to_id' => message.reply_to_id,
+          'reactions' => message.reactions.map do |reaction|
+            { 'type' => reaction[:type], 'count' => reaction[:count] }
+          end,
+          'attachments' => message.attachments, 'importance' => message.importance,
+          'edited' => message.edited, 'mentions' => message.mentions
+        }
+      end
+
+      def parse_stored_reactions(reactions)
+        Array(reactions).map { |reaction| stored_reaction_hash(reaction) }
+      end
+
+      def stored_reaction_hash(reaction) = { type: reaction['type'], count: reaction['count'] }
+
+      def stored_msg_attrs(data)
+        stored_msg_core(data).merge(stored_msg_extras(data))
+      end
+
+      def stored_msg_core(data)
+        created_at_raw = data['created_at']
+        { id: data['id'], sender_id: data['sender_id'], sender_name: data['sender_name'],
+          content: data['content'], created_at: created_at_raw ? Time.parse(created_at_raw) : nil,
+          message_type: data['message_type'] }
+      end
+
+      def stored_msg_extras(data)
+        { reply_to_id: data['reply_to_id'], reactions: parse_stored_reactions(data['reactions']),
+          attachments: stored_default(data, 'attachments', []),
+          importance: data['importance'],
+          edited: stored_default(data, 'edited', false),
+          mentions: stored_default(data, 'mentions', []) }
+      end
+
+      def stored_default(data, key, fallback) = data[key] || fallback
+    end
+
+    # Pagination helpers for fetching chat messages across pages
+    module SyncPagination
+      API_DELAY_SECONDS = 0.5
+      MAX_PAGES = 500
+
+      private
+
+      def paginate_messages(chat_id, start_time)
+        @backward_link = nil
+        @page_count = 0
+        messages = []
+        loop do
+          page_messages = fetch_next_page(chat_id, start_time)
+          break if page_messages.empty? || log_and_check_max?(@page_count += 1, page_messages)
+
+          @backward_link = accumulate_page(messages, page_messages, start_time)
+          break unless @backward_link
+        end
+        messages
+      end
+
+      def accumulate_page(messages, page_messages, start_time)
+        parsed, cutoff = parse_page_messages(page_messages, start_time)
+        messages.concat(parsed)
+        cutoff ? nil : advance_link(start_time)
+      end
+
+      def fetch_next_page(chat_id, start_time)
+        response = @runner.messages_api.chat_messages_page(
+          chat_id: chat_id, start_time: @page_count.zero? ? start_time : nil, backward_link: @backward_link
+        )
+        msgs = response['messages'] || response['value'] || []
+        @backward_link = response.dig('_metadata', 'backwardLink')
+        msgs
+      end
+
+      def log_and_check_max?(page_count, page_messages)
+        debug("  Page #{page_count}: #{page_messages.length} message(s)")
+        return false unless page_count >= MAX_PAGES
+
+        debug("  Reached max pages (#{MAX_PAGES}), stopping pagination")
+        true
+      end
+
+      def parse_page_messages(page_messages, start_time)
+        parsed = page_messages.map { |msg_data| Models::Message.from_api(msg_data) }
+        cutoff = reached_cutoff?(parsed, start_time)
+        [parsed, cutoff]
+      end
+
+      def reached_cutoff?(parsed, start_time)
+        oldest = parsed.min_by { |msg| msg.created_at || Time.now }
+        return false unless oldest&.created_at && oldest.created_at < start_time
+
+        debug('  Reached cutoff date, stopping pagination')
+        true
+      end
+
+      def advance_link(start_time)
+        return nil unless @backward_link
+
+        sleep(API_DELAY_SECONDS)
+        @backward_link.gsub(/startTime=\d+/, "startTime=#{(start_time.to_f * 1000).to_i}")
+      end
+    end
+
+    # Core sync logic: fetch, merge, and write chat messages.
+    # Extracted from Commands::Sync to keep the command thin.
+    class SyncEngine
+      include SyncSerializer
+      include SyncPagination
+
+      def initialize(runner:, sync_store:, state:, output:)
+        @runner = runner
+        @sync_store = sync_store
+        @state = state
+        @output = output
+      end
+
+      # Fetch all messages from a chat since start_time with pagination
+      def fetch_all_messages(chat_id, start_time)
+        messages = paginate_messages(chat_id, start_time)
+        filter_and_sort_messages(messages, start_time)
+      end
+
+      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)
+        all_messages
+      end
+
+      def message_from_stored(data) = Models::Message.new(**stored_msg_attrs(data))
+
+      private
+
+      def filter_and_sort_messages(messages, start_time)
+        messages.reject(&:system_message?)
+                .filter_map { |msg| message_with_timestamp(msg, start_time) }
+                .sort_by(&:first)
+                .map(&:last)
+      end
+
+      def message_with_timestamp(msg, start_time)
+        created_at = msg.created_at
+        timestamp = created_at || Time.at(0)
+        [timestamp, msg] if !created_at || timestamp >= start_time
+      end
+
+      def merge_messages(existing, new_messages)
+        merged = index_by_id(existing).merge(index_by_id(new_messages))
+        merged.values.sort_by { |msg| msg.created_at || Time.at(0) }
+      end
+
+      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)
+        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)
+        write_metadata(chat)
+      end
+
+      def write_metadata(chat)
+        @sync_store.write_chat_metadata(chat.id, chat_metadata_hash(chat), state: @state)
+      end
+
+      def chat_metadata_hash(chat)
+        { 'id' => chat.id, 'display_name' => chat.display_name,
+          'type' => chat.chat_type, 'synced_at' => Time.now.iso8601 }
+      end
+
+      def debug(message) = @output&.verbose? && @output.debug(message)
+    end
+  end
+end

data/lib/teems/services/sync_store.rb

@@ -0,0 +1,193 @@
+# frozen_string_literal: true
+
+module Teems
+  module Services
+    # File I/O helpers for SyncStore: atomic writes, backup, and JSON persistence
+    module SyncFileOps
+      private
+
+      def atomic_write(path, content)
+        tmp_path = "#{path}.tmp"
+        File.write(tmp_path, content)
+        File.rename(tmp_path, path)
+      end
+
+      def backup_corrupt_file(path)
+        backup_path = "#{path}.corrupt.#{Time.now.strftime('%Y%m%d%H%M%S')}"
+        File.rename(path, backup_path)
+      rescue SystemCallError, IOError => e
+        warn "teems: Could not back up corrupt file #{path}: #{e.message}"
+      end
+
+      def load_json_or_default(path, default)
+        return default unless File.exist?(path)
+
+        JSON.parse(File.read(path))
+      rescue JSON::ParserError
+        backup_corrupt_file(path)
+        default
+      end
+    end
+
+    # Chat state query operations for SyncStore
+    module SyncStateQuery
+      private
+
+      def parse_synced_at(timestamp)
+        return nil unless timestamp
+
+        Time.parse(timestamp)
+      rescue ArgumentError
+        nil
+      end
+
+      def chat_entry_unavailable?(entry)
+        entry&.dig('unavailable') == true
+      end
+    end
+
+    # Chat state mutation operations for SyncStore
+    module SyncStateMutation
+      def update_chat_state(state, chat_id, attrs:)
+        display_name, synced_at, count, chat_type =
+          attrs.values_at(:display_name, :last_synced_at, :message_count, :chat_type)
+        entry = (state['chats'] ||= {})[chat_id] ||= {}
+        entry.merge!('last_synced_at' => synced_at.iso8601, 'message_count' => count,
+                     'display_name' => display_name, 'chat_type' => chat_type,
+                     'dir_name' => build_dir_name(chat_id, display_name))
+        state
+      end
+
+      def mark_unavailable(state, chat_id, **opts)
+        entry = (state['chats'] ||= {})[chat_id] ||= {}
+        apply_unavailable(entry)
+        apply_chat_type(entry, opts[:chat_type])
+        apply_display_info(entry, chat_id, opts[:display_name])
+        state
+      end
+
+      private
+
+      def apply_unavailable(entry)
+        entry.merge!('unavailable' => true, 'unavailable_at' => Time.now.iso8601)
+      end
+
+      def apply_chat_type(entry, chat_type)
+        entry['chat_type'] = chat_type if chat_type
+      end
+
+      def apply_display_info(entry, chat_id, display_name)
+        return unless display_name
+
+        entry.merge!('display_name' => display_name,
+                     'dir_name' => build_dir_name(chat_id, display_name))
+      end
+    end
+
+    # Chat directory resolution for SyncStore
+    module SyncChatDir
+      def chat_dir(chat_id, state: nil)
+        chat_entry = state&.dig('chats', chat_id)
+        dir_name = chat_entry&.dig('dir_name') || sanitize_id(chat_id)
+        File.join(sync_dir, SyncStore::CHATS_DIR, type_dir(chat_entry&.dig('chat_type')), dir_name)
+      end
+
+      def read_messages_json(chat_id, state: nil)
+        load_json_or_default(File.join(chat_dir(chat_id, state: state), 'messages.json'), [])
+      end
+    end
+
+    # Chat file write operations for SyncStore
+    module SyncChatWrite
+      def write_messages(chat_id, **opts)
+        md, json, state = opts.values_at(:messages_md, :messages_json, :state)
+        write_to_dir(chat_dir(chat_id, state: state),
+                     'messages.md' => md, 'messages.json' => json)
+      end
+
+      def write_chat_metadata(chat_id, metadata, state: nil)
+        dir = chat_dir(chat_id, state: state)
+        write_to_dir(dir, 'chat_metadata.json' => JSON.pretty_generate(metadata))
+      end
+
+      private
+
+      def write_to_dir(dir, files)
+        FileUtils.mkdir_p(dir)
+        files.each { |name, content| atomic_write(File.join(dir, name), content) }
+      end
+    end
+
+    # Directory rename helpers for SyncStore
+    module SyncRenameOps
+      private
+
+      def rename_entry_dir(entry, new_dir_name, chat_type)
+        old_name = entry['dir_name']
+        old_type = entry['chat_type']
+        if old_name && (old_name != new_dir_name || old_type != chat_type)
+          move_chat_dir(chat_type_path(old_type, old_name),
+                        chat_type_path(chat_type, new_dir_name))
+        end
+        entry.merge!('dir_name' => new_dir_name, 'chat_type' => chat_type)
+      end
+
+      def move_chat_dir(old_path, new_path)
+        return if old_path == new_path || !File.directory?(old_path) || File.exist?(new_path)
+
+        FileUtils.mkdir_p(File.dirname(new_path))
+        File.rename(old_path, new_path)
+      end
+
+      def chat_type_path(type, name) = File.join(sync_dir, SyncStore::CHATS_DIR, type_dir(type), name)
+    end
+
+    # Manages local sync state and file storage for the sync command.
+    # Stores chat history as Markdown + JSON in XDG data directory.
+    class SyncStore
+      include SyncDirNaming
+      include SyncFileOps
+      include SyncStateQuery
+      include SyncStateMutation
+      include SyncChatDir
+      include SyncChatWrite
+      include SyncRenameOps
+
+      SYNC_DIR = 'sync'
+      STATE_FILE = 'sync_state.json'
+      CHATS_DIR = 'chats'
+
+      def initialize(xdg_paths: Support::XdgPaths.new)
+        @xdg_paths = xdg_paths
+      end
+
+      def sync_dir = @sync_dir ||= File.join(@xdg_paths.data_dir, SYNC_DIR)
+
+      def last_synced_time(state, chat_id)
+        parse_synced_at(state.dig('chats', chat_id, 'last_synced_at'))
+      end
+
+      def chat_unavailable?(state, chat_id)
+        chat_entry = state.dig('chats', chat_id)
+        chat_entry_unavailable?(chat_entry)
+      end
+
+      def load_state
+        load_json_or_default(File.join(sync_dir, STATE_FILE), {})
+      end
+
+      def save_state(state)
+        FileUtils.mkdir_p(sync_dir)
+        atomic_write(File.join(sync_dir, STATE_FILE), JSON.pretty_generate(state))
+      end
+
+      def ensure_dir_name(state, chat_info:)
+        chat_id, display_name, chat_type = chat_info.values_at(:chat_id, :display_name, :chat_type)
+        new_dir_name = build_dir_name(chat_id, display_name)
+        entry = (state['chats'] ||= {})[chat_id] ||= {}
+        rename_entry_dir(entry, new_dir_name, chat_type)
+        new_dir_name
+      end
+    end
+  end
+end

data/lib/teems/services/teams_url_parser.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'json'
+
+module Teems
+  module Services
+    # Parses Microsoft Teams URLs to extract conversation and message identifiers
+    class TeamsUrlParser
+      # Parsed components from a Teams message URL
+      Result = Struct.new(:conversation_id, :message_id, :context_type, :team_id)
+
+      TEAMS_HOST = 'teams.microsoft.com'
+      MESSAGE_PATH_PATTERN = %r{^/l/message/([^/]+)/(\d+)$}
+
+      class << self
+        def parse(url)
+          uri = URI.parse(url)
+          return nil unless teams_url?(uri)
+
+          match_and_build(uri)
+        rescue URI::InvalidURIError
+          nil
+        end
+
+        def match_and_build(uri)
+          match = uri.path.match(MESSAGE_PATH_PATTERN)
+          match ? build_result(match, uri.query) : nil
+        end
+
+        def teams_url?(uri_or_string)
+          uri = uri_or_string.is_a?(URI) ? uri_or_string : URI.parse(uri_or_string.to_s)
+          uri.host == TEAMS_HOST
+        rescue URI::InvalidURIError
+          false
+        end
+
+        private
+
+        def build_result(match, query_string)
+          context = parse_context(query_string)
+          Result.new(
+            conversation_id: URI.decode_www_form_component(match[1]),
+            message_id: match[2],
+            context_type: context[:context_type],
+            team_id: context[:team_id]
+          )
+        end
+
+        def parse_context(query_string)
+          return {} unless query_string
+
+          parse_context_param(extract_context_param(query_string))
+        rescue JSON::ParserError => e
+          log_context_parse_error(e)
+        end
+
+        def parse_context_param(context_json)
+          context_json ? parse_context_json(context_json) : {}
+        end
+
+        def log_context_parse_error(err)
+          warn "teems: Could not parse Teams URL context: #{err.message}"
+          {}
+        end
+
+        def extract_context_param(query_string)
+          URI.decode_www_form(query_string).to_h['context']
+        end
+
+        def parse_context_json(json)
+          context = JSON.parse(json)
+          { context_type: context['contextType'], team_id: context['teamId'] }
+        end
+      end
+    end
+  end
+end

data/lib/teems/services/token_exchange_scripts.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Teems
+  module Services
+    # JavaScript and text constants for token exchange and manual instructions.
+    # Separated from TokenExtractorScripts to keep modules under line limits.
+    module TokenExchangeScripts
+      # JavaScript to exchange skype spaces token for skypeToken via authsvc
+      EXCHANGE_TOKEN_JS = <<~JS
+        (function(skypeSpacesToken) {
+          var xhr = new XMLHttpRequest();
+          xhr.open('POST', 'https://teams.microsoft.com/api/authsvc/v1.0/authz', false);
+          xhr.setRequestHeader('Authorization', 'Bearer ' + skypeSpacesToken);
+          xhr.setRequestHeader('Content-Type', 'application/json');
+          try {
+            xhr.send('{}');
+            if (xhr.status === 200) {
+              var result = JSON.parse(xhr.responseText);
+              return JSON.stringify({
+                skype_token: result.tokens.skypeToken,
+                region: result.region,
+                chat_service: result.regionGtms.chatService
+              });
+            }
+          } catch(e) {}
+          return JSON.stringify({error: 'Exchange failed'});
+        })(%s)
+      JS
+
+      MANUAL_TOKEN_INSTRUCTIONS = <<~INSTRUCTIONS
+        To manually extract tokens:
+
+        1. Open https://teams.microsoft.com in your browser
+        2. Log in with your credentials
+        3. Open Developer Tools (F12 or Cmd+Option+I)
+        4. Go to Console tab and run:
+
+           // Get Graph token (for teams/channels)
+           for (let i = 0; i < localStorage.length; i++) {
+             let key = localStorage.key(i);
+             if (key.includes('accesstoken') && key.includes('graph.microsoft.com')) {
+               console.log('auth_token:', JSON.parse(localStorage.getItem(key)).secret);
+             }
+           }
+
+        5. To get the skypeToken (for messages), you need to:
+           a. Find the api.spaces.skype.com token in localStorage
+           b. Exchange it via POST to /api/authsvc/v1.0/authz
+           c. Or capture it from Network tab (Authentication header)
+
+        The skypeToken uses format: Authentication: skypetoken=<token>
+        The Graph token uses format: Authorization: Bearer <token>
+      INSTRUCTIONS
+    end
+  end
+end