teems 0.1.0

data/lib/teems/models/message.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+module Teems
+  module Models
+    # Represents a message in Teams
+    # Handles both Graph API and Teams internal API response formats
+    Message = Data.define(
+      :id, :sender_id, :sender_name, :content, :created_at,
+      :message_type, :reply_to_id, :reactions, :attachments, :importance,
+      :edited, :mentions
+    ) do
+      extend Parsing
+
+      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)
+        else from_graph_api(data)
+        end
+      end
+
+      def self.from_ng_msg_api(data)
+        new(**ng_msg_attrs(data))
+      end
+
+      def self.ng_msg_attrs(data)
+        props = data['properties'] || {}
+        {
+          id: data['id'], sender_id: data['from'],
+          sender_name: data['imdisplayname'] || data['fromDisplayNameInToken'] || 'Unknown',
+          content: strip_html(data['content'] || ''),
+          created_at: parse_time(data['composetime'] || data['originalarrivaltime']),
+          message_type: data['messagetype'],
+          **ng_msg_extras(data, props)
+        }
+      end
+
+      def self.ng_msg_extras(data, props)
+        root_message_id = data['rootMessageId']
+        {
+          reply_to_id: root_message_id == data['id'] ? nil : root_message_id,
+          reactions: parse_ng_msg_reactions(props['emotions']),
+          attachments: parse_files_json(props['files']),
+          importance: props['importance'],
+          edited: props.key?('edittime'),
+          mentions: parse_mentions(props['mentions'])
+        }
+      end
+
+      def self.parse_ng_msg_reactions(emotions)
+        return [] unless emotions.is_a?(Array)
+
+        emotions.map { |emotion| { type: emotion['key'], count: emotion['users']&.length || 1 } }
+      end
+
+      def self.from_teams_internal_api(data)
+        msg = data['message']
+        new(
+          id: data['id'], sender_id: msg['from'],
+          sender_name: msg['imDisplayName'] || msg['fromDisplayNameInToken'] || 'Unknown',
+          content: strip_html(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')),
+          importance: nil, edited: false, mentions: []
+        )
+      end
+
+      def self.from_graph_api(data)
+        new(**graph_attrs(data))
+      end
+
+      def self.graph_attrs(data)
+        {
+          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') || ''),
+          created_at: parse_time(data['createdDateTime']),
+          **graph_extras(data)
+        }
+      end
+
+      def self.graph_extras(data)
+        {
+          message_type: data['messageType'], reply_to_id: data['replyToId'],
+          reactions: parse_reactions(data['reactions']),
+          attachments: data['attachments'] || [],
+          importance: data['importance'],
+          edited: false, mentions: []
+        }
+      end
+
+      def self.extract_sender_name(data)
+        data.dig('from', 'user', 'displayName') || data.dig('from', 'application', 'displayName') || 'Unknown'
+      end
+
+      def self.parse_reactions(reactions_data)
+        return [] unless reactions_data.is_a?(Array)
+
+        reactions_data.map { |reaction| { type: reaction['reactionType'], count: reaction['user']&.length || 1 } }
+      end
+
+      def downloadable_attachments = attachments.grep(Hash).select { |att| att.key?('sharepointIds') }
+
+      def content_with_mentions_highlighted
+        return content if mentions.empty?
+
+        mentions.inject(content) { |text, name| text.gsub(name, yield(name)) }
+      end
+
+      def short_hash = Digest::SHA256.hexdigest(id.to_s)[0, 6]
+      def timestamp = created_at
+      def reply? = !!reply_to_id
+      def edited? = !!edited
+      def important? = %w[urgent high].include?(importance)
+      def system_message? = message_type && !normal_message_type? && !rich_text_type?
+      def to_s = "[#{created_at&.strftime('%H:%M')}] #{sender_name}: #{content}"
+
+      private
+
+      def normal_message_type? = %w[Message message Text].include?(message_type)
+      def rich_text_type? = message_type.start_with?('RichText')
+    end
+  end
+end

data/lib/teems/models/parsing.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Teems
+  module Models
+    # Shared parsing helpers for API response data
+    module Parsing
+      module_function
+
+      def strip_html(html)
+        return nil unless html
+
+        require 'cgi'
+        CGI.unescapeHTML(html.gsub(/<[^>]+>/, ' ')).gsub('&nbsp;', ' ').gsub(/\s+/, ' ').strip
+      end
+
+      def parse_time(time_str)
+        return nil unless time_str
+
+        Time.parse(time_str)
+      rescue ArgumentError
+        nil
+      end
+
+      def parse_files_json(files_json)
+        return [] unless files_json
+
+        JSON.parse(files_json)
+      rescue JSON::ParserError
+        []
+      end
+
+      def parse_mentions(mentions_json)
+        raw = normalize_mentions(mentions_json)
+        return [] unless raw
+
+        raw.group_by { |mention| mention['mri'] }
+           .except(nil)
+           .each_value.filter_map { |entries| mention_display_name(entries) }
+      end
+
+      def normalize_mentions(data)
+        return nil unless data
+
+        parsed = data.is_a?(String) ? JSON.parse(data) : data
+        parsed if parsed.is_a?(Array)
+      rescue JSON::ParserError
+        nil
+      end
+
+      def mention_display_name(entries)
+        name = entries.filter_map { |entry| entry['displayName'] }.join(' ')
+        name unless name.empty?
+      end
+    end
+  end
+end

data/lib/teems/models/user.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Teems
+  module Models
+    # Represents a user in Teams
+    User = Data.define(:id, :display_name, :email, :user_principal_name) do
+      def self.from_api(data)
+        new(
+          id: data['id'],
+          display_name: data['displayName'],
+          email: data['mail'] || data['email'],
+          user_principal_name: data['userPrincipalName']
+        )
+      end
+
+      def best_name
+        [display_name, email, user_principal_name, id].find { |value| value && !value.empty? }
+      end
+
+      def to_s
+        best_name
+      end
+    end
+  end
+end

data/lib/teems/models/user_profile.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Teems
+  module Models
+    # Rich user profile with extended fields for who/org commands
+    UserProfile = Data.define(
+      :id,
+      :display_name,
+      :email,
+      :user_principal_name,
+      :job_title,
+      :department,
+      :office_location,
+      :business_phones,
+      :mobile_phone
+    ) do
+      def self.from_api(data)
+        new(**identity_attrs(data), **detail_attrs(data))
+      end
+
+      def self.identity_attrs(data)
+        { id: data['id'], display_name: data['displayName'],
+          email: data['mail'] || data['email'], user_principal_name: data['userPrincipalName'] }
+      end
+
+      def self.detail_attrs(data)
+        { job_title: data['jobTitle'], department: data['department'],
+          office_location: data['officeLocation'],
+          business_phones: data['businessPhones'] || [], mobile_phone: data['mobilePhone'] }
+      end
+
+      def best_name
+        [display_name, email, user_principal_name, id].find { |value| value && !value.empty? }
+      end
+
+      def json_attrs
+        [to_h, id]
+      end
+
+      def search_display
+        [best_name, job_title, email]
+      end
+    end
+  end
+end

data/lib/teems/runner.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Teems
+  # API factory methods for Runner, extracted to keep method count manageable
+  module ApiFactories
+    def channels_api = Api::Channels.new(api_client, account)
+    def chats_api = Api::Chats.new(api_client, account)
+    def messages_api = Api::Messages.new(api_client, account)
+    def calendar_api = Api::Calendar.new(api_client, account)
+    def users_api = Api::Users.new(api_client, account)
+    def files_api = Api::Files.new(api_client, account)
+  end
+
+  # Dependency injection container providing services to commands
+  class Runner
+    include ApiFactories
+
+    attr_reader :output, :config, :token_store
+
+    def initialize(
+      output: Formatters::Output.new,
+      config: Services::Configuration.new,
+      token_store: Services::TokenStore.new,
+      api_client: nil,
+      cache_store: Services::CacheStore.new
+    )
+      api_client ||= Services::ApiClient.new(endpoints: config['endpoints'] || {})
+      @output = output
+      @config = config
+      @token_store = token_store
+      @services = { api_client: api_client, cache_store: cache_store }
+
+      wire_up_warnings
+    end
+
+    def api_client = @services[:api_client]
+    def cache_store = @services[:cache_store]
+
+    # Account helpers - always get fresh from token_store (important for token refresh)
+    def account
+      @token_store.account or raise ConfigError, 'No account configured. Run: teems auth login'
+    end
+
+    def configured?
+      @token_store.configured?
+    end
+
+    # Clear any cached API instances after token refresh
+    def clear_api_cache
+      # API instances are not cached, but account is fetched fresh each time
+      # This method exists for future extensibility
+    end
+
+    # Formatter helpers
+    def message_formatter
+      Formatters::MessageFormatter.new(output: @output, cache_store: cache_store)
+    end
+
+    # Token extractor for Safari automation
+    def token_extractor(auth_mode: :default)
+      Services::TokenExtractor.new(output: @output, auth_mode: auth_mode)
+    end
+
+    # Token refresher for automatic token refresh
+    def token_refresher
+      Services::TokenRefresher.new(token_store: @token_store, output: @output)
+    end
+
+    # Attempt to refresh the skype_token
+    def refresh_tokens
+      token_refresher.refresh
+    end
+
+    private
+
+    def wire_up_warnings
+      warning_handler = ->(message) { @output.warn(message) }
+      @config.register_warning_handler(warning_handler)
+    end
+  end
+end

data/lib/teems/services/api_client.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module Teems
+  module Services
+    # HTTP connection pool management for API endpoints
+    module ConnectionPool
+      DEFAULT_ENDPOINTS = {
+        graph: 'https://graph.microsoft.com',
+        teams: 'https://teams.microsoft.com',
+        msgservice: 'https://amer.ng.msg.teams.microsoft.com',
+        presence: 'https://presence.teams.microsoft.com'
+      }.freeze
+
+      TIMEOUTS = { open_timeout: 10, read_timeout: 30, keep_alive_timeout: 30 }.freeze
+
+      private
+
+      def get_http_for_endpoint(endpoint_key)
+        uri = URI(resolve_endpoint(endpoint_key))
+        cache_key = "#{uri.host}:#{uri.port}"
+        (http = @http_cache[cache_key])&.started? ? http : @http_cache[cache_key] = start_http(uri)
+      end
+
+      def start_http(uri)
+        build_http(uri.host, uri.port, ssl_scheme?(uri)).tap(&:start)
+      end
+
+      def ssl_scheme?(uri) = uri.scheme == 'https'
+
+      def build_http(host, port, use_ssl)
+        http = Net::HTTP.new(host, port)
+        apply_timeouts(http)
+        http.use_ssl = use_ssl
+        configure_ssl(http) if use_ssl
+        http
+      end
+
+      def apply_timeouts(http)
+        TIMEOUTS.each { |attr, val| http.send(:"#{attr}=", val) }
+      end
+
+      def configure_ssl(http)
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.cert_store = OpenSSL::X509::Store.new.tap(&:set_default_paths)
+      end
+    end
+
+    # POST/PATCH request methods, extracted to manage class size
+    module WriteRequests
+      def post(endpoint_key, path, **options)
+        account = options.delete(:account)
+        body = options.delete(:body)
+        req = Net::HTTP::Post.new(URI("#{resolve_endpoint(endpoint_key)}#{path}"))
+        apply_auth(req, account, endpoint_key)
+        req.body = JSON.generate(body) if body
+        run_request(path, get_http_for_endpoint(endpoint_key)) { |http| http.request(req) }
+      end
+
+      def patch(endpoint_key, path, **options)
+        account = options.delete(:account)
+        body = options.delete(:body)
+        req = Net::HTTP::Patch.new(URI("#{resolve_endpoint(endpoint_key)}#{path}"))
+        apply_auth(req, account, endpoint_key)
+        req.body = JSON.generate(body) if body
+        run_request(path, get_http_for_endpoint(endpoint_key)) { |http| http.request(req) }
+      end
+    end
+
+    # HTTP response handling for API client
+    module ResponseHandler
+      private
+
+      def handle_response(response)
+        return parse_json_body(response) if response.is_a?(Net::HTTPSuccess)
+
+        raise_http_error(response)
+      end
+
+      def raise_http_error(response)
+        case response
+        when Net::HTTPUnauthorized   then raise ApiError.new('Invalid token or session expired', status_code: 401)
+        when Net::HTTPForbidden      then raise ApiError.new('Access forbidden', status_code: 403)
+        when Net::HTTPTooManyRequests then raise_rate_limit(response)
+        else
+          code = response.code
+          raise ApiError.new("HTTP #{code}: #{response.message}", status_code: code.to_i)
+        end
+      end
+
+      def raise_rate_limit(response)
+        retry_after = response['Retry-After']
+        suffix = retry_after ? "retry after #{retry_after} seconds" : 'please wait and try again'
+        raise ApiError.new("Rate limited - #{suffix}", status_code: 429)
+      end
+
+      def parse_json_body(response)
+        body = response.body
+        return {} if body.to_s.empty?
+
+        JSON.parse(body)
+      rescue JSON::ParserError
+        raise ApiError, 'Invalid JSON response from Teams API'
+      end
+    end
+
+    # HTTP client for Teams API with connection pooling and multi-endpoint support
+    class ApiClient
+      include ConnectionPool
+      include ResponseHandler
+      include WriteRequests
+
+      NETWORK_ERRORS = [
+        SocketError, Errno::ECONNREFUSED, Errno::ECONNRESET, Errno::ETIMEDOUT,
+        Errno::EHOSTUNREACH, Net::OpenTimeout, Net::ReadTimeout, OpenSSL::SSL::SSLError
+      ].freeze
+
+      AUTH_HEADERS = {
+        msgservice: ->(account) { ['Authentication', account.skype_auth_header] },
+        teams: ->(account) { ['Authorization', "Bearer #{account.skype_token}"] },
+        presence: ->(account) { ['Authorization', "Bearer #{account.presence_token}"] }
+      }.freeze
+      DEFAULT_AUTH_HEADER = ->(account) { ['Authorization', account.teams_auth_header] }
+
+      attr_reader :call_count
+
+      def initialize(on_request: nil, on_response: nil, endpoints: {})
+        @call_count = 0
+        @callbacks = { on_request: on_request, on_response: on_response }
+        @http_cache = {}
+        @endpoints = DEFAULT_ENDPOINTS.merge(endpoints.transform_keys(&:to_sym))
+      end
+
+      def on_request = @callbacks[:on_request]
+      def on_response = @callbacks[:on_response]
+
+      def on_request=(callback)
+        close_idle_connections
+        @callbacks[:on_request] = callback
+      end
+
+      def on_response=(callback)
+        close_idle_connections
+        @callbacks[:on_response] = callback
+      end
+
+      def close
+        @http_cache.each_value do |http|
+          http.finish if http.started?
+        rescue IOError
+          nil
+        end
+        @http_cache.clear
+      end
+
+      def get(endpoint_key, path, **options)
+        account = options.delete(:account)
+        base_url = resolve_endpoint(endpoint_key)
+        uri = build_request_uri(base_url, path, options.fetch(:params, {}))
+        req = Net::HTTP::Get.new(uri)
+        apply_headers(req, options.fetch(:headers, {}))
+        apply_auth(req, account, endpoint_key)
+        run_request(path, get_http_for_endpoint(endpoint_key)) { |http| http.request(req) }
+      end
+
+      def delete(url, endpoint_key:, account:)
+        uri = URI(url)
+        run_request(uri.path, get_http_for_endpoint(endpoint_key)) do |http|
+          req = Net::HTTP::Delete.new(uri)
+          apply_auth(req, account, endpoint_key)
+          http.request(req)
+        end
+      end
+
+      private
+
+      def close_idle_connections
+        @http_cache.select! { |_key, http| http.started? }
+      end
+
+      def apply_headers(request, headers)
+        headers.each { |key, value| request[key] = value }
+      end
+
+      def build_request_uri(base_url, path, params)
+        URI(path.start_with?('http') ? path : "#{base_url}#{path}").tap do |uri|
+          uri.query = URI.encode_www_form(params) if params&.any?
+        end
+      end
+
+      def resolve_endpoint(key) = @endpoints[key] || raise(ArgumentError, "Unknown endpoint: #{key}")
+
+      def apply_auth(request, account, endpoint_key)
+        request['Content-Type'] = 'application/json'
+        header, value = AUTH_HEADERS.fetch(endpoint_key, DEFAULT_AUTH_HEADER).call(account)
+        request[header] = value
+      end
+
+      def run_request(path, http)
+        track_request(path)
+        response = yield(http)
+        process_response(path, response)
+      rescue *NETWORK_ERRORS => e
+        raise ApiError, "Network error: #{e.message}"
+      end
+
+      def track_request(path)
+        @call_count += 1
+        @callbacks[:on_request]&.call(path, @call_count)
+      end
+
+      def process_response(path, response)
+        @callbacks[:on_response]&.call(path, response.code)
+        handle_response(response)
+      end
+    end
+  end
+end

data/lib/teems/services/cache_store.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Teems
+  module Services
+    # Manages caching of user and channel data
+    class CacheStore
+      def initialize(paths: Support::XdgPaths.new)
+        @paths = paths
+        @user_cache = {}
+      end
+
+      def get_user(user_id)
+        @user_cache[user_id]
+      end
+
+      def set_user(user_id, display_name)
+        @user_cache[user_id] = display_name
+      end
+
+      def clear
+        @user_cache.clear
+        FileUtils.rm_f(users_cache_file)
+      end
+
+      private
+
+      def users_cache_file
+        @paths.cache_file('users.json')
+      end
+    end
+  end
+end

data/lib/teems/services/configuration.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Teems
+  module Services
+    # Manages CLI configuration stored in XDG config directory
+    class Configuration
+      def initialize(paths: Support::XdgPaths.new)
+        @paths = paths
+        @on_warning = nil
+        @data = nil
+      end
+
+      def register_warning_handler(handler)
+        @on_warning = handler
+      end
+
+      def [](key)
+        data[key]
+      end
+
+      def []=(key, value)
+        data[key] = value
+        save_config
+      end
+
+      def to_h
+        data.dup
+      end
+
+      private
+
+      def data
+        @data ||= load_config
+      end
+
+      def config_file
+        @paths.config_file('config.json')
+      end
+
+      def load_config
+        return {} unless File.exist?(config_file)
+
+        JSON.parse(File.read(config_file))
+      rescue JSON::ParserError => e
+        @on_warning&.call("Config file #{config_file} is corrupted (#{e.message}). Using defaults.")
+        {}
+      end
+
+      def save_config
+        @paths.ensure_config_dir
+        File.write(config_file, JSON.pretty_generate(data))
+        File.chmod(0o600, config_file)
+      end
+    end
+  end
+end

data/lib/teems/services/file_downloader.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Teems
+  module Services
+    # Downloads files from pre-authenticated URLs with redirect following
+    class FileDownloader
+      MAX_REDIRECTS = 5
+
+      def initialize(http_client: nil)
+        @http_client = http_client
+      end
+
+      def download(url, output_path)
+        response = follow_redirects(URI(url))
+        File.binwrite(output_path, response.body)
+      end
+
+      private
+
+      def follow_redirects(uri, limit = MAX_REDIRECTS)
+        raise Teems::Error, 'Too many redirects' if limit.zero?
+
+        handle_response(http_get(uri), limit)
+      end
+
+      def http_get(uri)
+        @http_client ? @http_client.call(uri) : Net::HTTP.get_response(uri)
+      end
+
+      def handle_response(response, limit)
+        case response
+        when Net::HTTPSuccess then response
+        when Net::HTTPRedirection then follow_redirects(URI(response['location']), limit - 1)
+        else raise Teems::Error, "Download failed: HTTP #{response.code}"
+        end
+      end
+    end
+  end
+end