lex-microsoft_teams 0.5.2 → 0.5.4

data/lib/legion/extensions/microsoft_teams/actors/auth_validator.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Actor
+        class AuthValidator < Legion::Extensions::Actors::Once
+          def use_runner?     = false
+          def check_subtask?  = false
+          def generate_task?  = false
+
+          def delay
+            2.0
+          end
+
+          def enabled?
+            defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
+          rescue StandardError
+            false
+          end
+
+          def token_cache
+            @token_cache ||= Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.new
+          end
+
+          def manual
+            loaded = token_cache.load_from_vault
+
+            if loaded
+              token = token_cache.cached_delegated_token
+              if token
+                log_info('Teams delegated auth restored')
+              elsif token_cache.previously_authenticated?
+                attempt_browser_reauth(token_cache)
+              end
+            elsif token_cache.previously_authenticated?
+              log_warn('Token file found but could not load, attempting re-authentication')
+              attempt_browser_reauth(token_cache)
+            else
+              log_debug('No Teams delegated auth configured, skipping')
+            end
+          rescue StandardError => e
+            log_error("AuthValidator: #{e.message}")
+          end
+
+          private
+
+          def attempt_browser_reauth(cache)
+            settings = teams_auth_settings
+            return false unless settings[:tenant_id] && settings[:client_id]
+
+            log_warn('Delegated token expired, opening browser for re-authentication...')
+
+            scopes = settings.dig(:delegated, :scopes) ||
+                     Legion::Extensions::MicrosoftTeams::Helpers::BrowserAuth::DEFAULT_SCOPES
+            browser_auth = Legion::Extensions::MicrosoftTeams::Helpers::BrowserAuth.new(
+              tenant_id: settings[:tenant_id],
+              client_id: settings[:client_id],
+              scopes:    scopes
+            )
+
+            result = browser_auth.authenticate
+            return false if result[:error]
+
+            body = result[:result]
+            cache.store_delegated_token(
+              access_token:  body['access_token'],
+              refresh_token: body['refresh_token'],
+              expires_in:    body['expires_in'],
+              scopes:        scopes
+            )
+            cache.save_to_vault
+            log_info('Teams delegated auth restored via browser')
+            true
+          rescue StandardError => e
+            log_error("Browser re-auth failed: #{e.message}")
+            false
+          end
+
+          def teams_auth_settings
+            return {} unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:microsoft_teams, :auth) || {}
+          end
+
+          def log_info(msg)
+            Legion::Logging.info(msg) if defined?(Legion::Logging)
+          end
+
+          def log_warn(msg)
+            Legion::Logging.warn(msg) if defined?(Legion::Logging)
+          end
+
+          def log_debug(msg)
+            Legion::Logging.debug(msg) if defined?(Legion::Logging)
+          end
+
+          def log_error(msg)
+            Legion::Logging.error(msg) if defined?(Legion::Logging)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/microsoft_teams/actors/cache_sync.rb

@@ -29,11 +29,7 @@ module Legion
           end
 
           def args
-            { since: @last_sync_time, skip_bots: true }.tap do |a|
-              # After manual call returns, update high-water mark
-              # This works because Base#manual calls runner_class.send(runner_function, **args)
-              # and we update @last_sync_time in the overridden manual method
-            end
+            { since: @last_sync_time, skip_bots: true }
           end
 
           def manual

data/lib/legion/extensions/microsoft_teams/actors/direct_chat_poller.rb

@@ -50,13 +50,13 @@ module Legion
 
           def fetch_bot_chats(token:)
             conn = graph_connection(token: token)
-            response = conn.get('/me/chats', { '$filter' => "chatType eq 'oneOnOne'", '$top' => 50 })
+            response = conn.get('me/chats', { '$filter' => "chatType eq 'oneOnOne'", '$top' => 50 })
             response.body&.dig('value') || []
           end
 
           def poll_chat(chat_id:, token:)
             conn = graph_connection(token: token)
-            response = conn.get("/chats/#{chat_id}/messages",
+            response = conn.get("chats/#{chat_id}/messages",
                                 { '$top' => 10, '$orderby' => 'createdDateTime desc' })
             messages = response.body&.dig('value') || []
 

data/lib/legion/extensions/microsoft_teams/actors/message_processor.rb

@@ -3,7 +3,7 @@
 module Legion
   module Extensions
     module MicrosoftTeams
-      module Actors
+      module Actor
         class MessageProcessor < Legion::Extensions::Actors::Subscription
           def runner_class    = 'Legion::Extensions::MicrosoftTeams::Runners::Bot'
           def runner_function = 'handle_message'

data/lib/legion/extensions/microsoft_teams/actors/observed_chat_poller.rb

@@ -61,7 +61,7 @@ module Legion
 
           def poll_observed_chat(chat_id:, owner_id:, peer_name:, token:)
             conn = graph_connection(token: token)
-            response = conn.get("/chats/#{chat_id}/messages",
+            response = conn.get("chats/#{chat_id}/messages",
                                 { '$top' => 10, '$orderby' => 'createdDateTime desc' })
             messages = response.body&.dig('value') || []
 

data/lib/legion/extensions/microsoft_teams/actors/token_refresher.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Legion
+  module Extensions
+    module MicrosoftTeams
+      module Actor
+        class TokenRefresher < Legion::Extensions::Actors::Every
+          DEFAULT_REFRESH_INTERVAL = 900
+
+          def runner_class    = Legion::Extensions::MicrosoftTeams::Helpers::TokenCache
+          def runner_function = 'cached_delegated_token'
+          def run_now?        = false
+          def use_runner?     = false
+          def check_subtask?  = false
+          def generate_task?  = false
+
+          def time
+            settings = teams_auth_settings
+            delegated = settings[:delegated]
+            return DEFAULT_REFRESH_INTERVAL unless delegated.is_a?(Hash)
+
+            delegated[:refresh_interval] || DEFAULT_REFRESH_INTERVAL
+          end
+
+          def enabled?
+            defined?(Legion::Extensions::MicrosoftTeams::Helpers::TokenCache)
+          rescue StandardError
+            false
+          end
+
+          def token_cache
+            @token_cache ||= Legion::Extensions::MicrosoftTeams::Helpers::TokenCache.new
+          end
+
+          def manual
+            return unless token_cache.authenticated?
+
+            token = token_cache.cached_delegated_token
+            if token
+              token_cache.save_to_vault
+            elsif token_cache.previously_authenticated?
+              attempt_browser_reauth(token_cache)
+            end
+          rescue StandardError => e
+            log_error("TokenRefresher: #{e.message}")
+          end
+
+          private
+
+          def attempt_browser_reauth(cache)
+            settings = teams_auth_settings
+            return false unless settings[:tenant_id] && settings[:client_id]
+
+            log_warn('Delegated token expired, opening browser for re-authentication...')
+
+            scopes = settings.dig(:delegated, :scopes) ||
+                     Legion::Extensions::MicrosoftTeams::Helpers::BrowserAuth::DEFAULT_SCOPES
+            browser_auth = Legion::Extensions::MicrosoftTeams::Helpers::BrowserAuth.new(
+              tenant_id: settings[:tenant_id],
+              client_id: settings[:client_id],
+              scopes:    scopes
+            )
+
+            result = browser_auth.authenticate
+            return false if result[:error]
+
+            body = result[:result]
+            cache.store_delegated_token(
+              access_token:  body['access_token'],
+              refresh_token: body['refresh_token'],
+              expires_in:    body['expires_in'],
+              scopes:        scopes
+            )
+            cache.save_to_vault
+            log_info('Teams delegated auth restored via browser')
+            true
+          rescue StandardError => e
+            log_error("Browser re-auth failed: #{e.message}")
+            false
+          end
+
+          def teams_auth_settings
+            return {} unless defined?(Legion::Settings)
+
+            Legion::Settings.dig(:microsoft_teams, :auth) || {}
+          end
+
+          def log_info(msg)
+            Legion::Logging.info(msg) if defined?(Legion::Logging)
+          end
+
+          def log_warn(msg)
+            Legion::Logging.warn(msg) if defined?(Legion::Logging)
+          end
+
+          def log_error(msg)
+            Legion::Logging.error(msg) if defined?(Legion::Logging)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/legion/extensions/microsoft_teams/client.rb

@@ -36,9 +36,10 @@ module Legion
 
         attr_reader :opts
 
-        def initialize(tenant_id: nil, client_id: nil, client_secret: nil, token: nil, **extra)
+        def initialize(tenant_id: nil, client_id: nil, client_secret: nil, token: nil,
+                       user_id: 'me', **extra)
           @opts = { tenant_id: tenant_id, client_id: client_id, client_secret: client_secret,
-                    token: token, **extra }
+                    token: token, user_id: user_id, **extra }
         end
 
         def graph_connection(**override)
@@ -59,6 +60,8 @@ module Legion
             client_id:     @opts[:client_id],
             client_secret: @opts[:client_secret]
           )
+          return result unless result&.dig(:result, 'access_token')
+
           @opts[:token] = result[:result]['access_token']
           result
         end

data/lib/legion/extensions/microsoft_teams/helpers/browser_auth.rb

@@ -17,7 +17,7 @@ module Legion
 
           attr_reader :tenant_id, :client_id, :scopes
 
-          def initialize(tenant_id:, client_id:, scopes: DEFAULT_SCOPES, auth: nil)
+          def initialize(tenant_id:, client_id:, scopes: DEFAULT_SCOPES, auth: nil, **)
             @tenant_id = tenant_id
             @client_id = client_id
             @scopes    = scopes

data/lib/legion/extensions/microsoft_teams/helpers/callback_server.rb

@@ -75,8 +75,13 @@ module Legion
               client.close
               break if @result
             end
-          rescue StandardError
-            nil # server closed or unexpected error
+          rescue IOError
+            nil # server closed during shutdown
+          rescue StandardError => e
+            @mutex.synchronize do
+              @result ||= { error: e.message }
+              @cv.broadcast
+            end
           end
         end
       end

data/lib/legion/extensions/microsoft_teams/helpers/client.rb

@@ -25,6 +25,10 @@ module Legion
             end
           end
 
+          def user_path(user_id = 'me')
+            user_id == 'me' ? 'me' : "users/#{user_id}"
+          end
+
           def oauth_connection(tenant_id: 'common', **_opts)
             Faraday.new(url: "https://login.microsoftonline.com/#{tenant_id}") do |conn|
               conn.request :url_encoded

data/lib/legion/extensions/microsoft_teams/helpers/prompt_resolver.rb

@@ -41,11 +41,8 @@ module Legion
             end
           end
 
-          def conversation_overrides(conversation_id: nil)
-            return nil unless conversation_id
-            return nil unless defined?(Legion::Extensions::Memory::Runners::Traces)
-
-            nil # TODO: query lex-memory for conversation_config by conversation_id
+          def conversation_overrides(conversation_id: nil) # rubocop:disable Lint/UnusedMethodArgument
+            nil
           end
 
           def preference_instructions_for(owner_id:)

data/lib/legion/extensions/microsoft_teams/helpers/subscription_registry.rb

@@ -12,6 +12,7 @@ module Legion
           def initialize
             @subscriptions = {}
             @mutex = Mutex.new
+            load
           end
 
           def subscribe(owner_id:, chat_id:, peer_name:)

data/lib/legion/extensions/microsoft_teams/helpers/token_cache.rb

@@ -1,6 +1,8 @@
 # frozen_string_literal: true
 
 require 'time'
+require 'json'
+require 'fileutils'
 require 'legion/extensions/microsoft_teams/runners/auth'
 
 module Legion
@@ -10,6 +12,8 @@ module Legion
         class TokenCache
           REFRESH_BUFFER = 60
           DEFAULT_VAULT_PATH = 'legionio/microsoft_teams/delegated_token'
+          DEFAULT_LOCAL_DIR = File.join(Dir.home, '.legionio', 'tokens')
+          DEFAULT_LOCAL_FILE = File.join(DEFAULT_LOCAL_DIR, 'microsoft_teams.json')
 
           def initialize
             @token_cache = nil
@@ -58,11 +62,19 @@ module Legion
             @mutex.synchronize { @delegated_cache = nil }
           end
 
+          def authenticated?
+            @mutex.synchronize { !@delegated_cache.nil? }
+          end
+
+          def previously_authenticated?
+            File.exist?(local_token_path)
+          end
+
           def load_from_vault
-            return false unless defined?(Legion::Crypt)
+            return load_from_local unless defined?(Legion::Crypt)
 
             data = Legion::Crypt.get(vault_path)
-            return false unless data && data[:access_token]
+            return load_from_local unless data && data[:access_token]
 
             @mutex.synchronize do
               @delegated_cache = {
@@ -75,10 +87,12 @@ module Legion
             true
           rescue StandardError => e
             log_error("Failed to load delegated token from Vault: #{e.message}")
-            false
+            load_from_local
           end
 
           def save_to_vault
+            save_to_local
+
             return false unless defined?(Legion::Crypt)
 
             data = @mutex.synchronize { @delegated_cache&.dup }
@@ -95,6 +109,47 @@ module Legion
             false
           end
 
+          def load_from_local
+            path = local_token_path
+            return false unless File.exist?(path)
+
+            raw = File.read(path)
+            data = ::JSON.parse(raw)
+            return false unless data['access_token'] && data['refresh_token']
+
+            @mutex.synchronize do
+              @delegated_cache = {
+                token:         data['access_token'],
+                refresh_token: data['refresh_token'],
+                expires_at:    Time.parse(data['expires_at']),
+                scopes:        data['scopes']
+              }
+            end
+            true
+          rescue StandardError => e
+            log_error("Failed to load delegated token from local file: #{e.message}")
+            false
+          end
+
+          def save_to_local
+            data = @mutex.synchronize { @delegated_cache&.dup }
+            return false unless data
+
+            path = local_token_path
+            FileUtils.mkdir_p(File.dirname(path))
+            File.write(path, ::JSON.pretty_generate(
+                               'access_token'  => data[:token],
+                               'refresh_token' => data[:refresh_token],
+                               'expires_at'    => data[:expires_at].utc.iso8601,
+                               'scopes'        => data[:scopes]
+                             ))
+            File.chmod(0o600, path)
+            true
+          rescue StandardError => e
+            log_error("Failed to save delegated token to local file: #{e.message}")
+            false
+          end
+
           private
 
           def token_expired?(cache_entry)
@@ -120,6 +175,14 @@ module Legion
             delegated[:vault_path] || DEFAULT_VAULT_PATH
           end
 
+          def local_token_path
+            settings = teams_auth_settings
+            delegated = settings[:delegated]
+            return DEFAULT_LOCAL_FILE unless delegated.is_a?(Hash)
+
+            delegated[:local_token_path] || DEFAULT_LOCAL_FILE
+          end
+
           def refresh_app_token
             result = acquire_fresh_token
             return nil unless result

data/lib/legion/extensions/microsoft_teams/local_cache/extractor.rb

@@ -17,7 +17,7 @@ module Legion
         class Extractor
           Message = Struct.new(
             :content,         # HTML message body
-            :sender,          # display name (e.g. "Iverson, Matthew D")
+            :sender,          # display name (e.g. "Doe, Jane A")
             :sender_id,       # orgid URI (e.g. "8:orgid:uuid")
             :message_type,    # RichText/Html, RichText/Media_Card, Text
             :content_type,    # Text

data/lib/legion/extensions/microsoft_teams/local_cache/record_parser.rb

@@ -178,7 +178,7 @@ module Legion
                 third = data.getbyte(pos + 2)
                 return nil unless third
 
-                actual_len = (len & 0x7F) | ((next_byte & 0x7F) << 7) | (third << 14)
+                actual_len = (len & 0x7F) | ((next_byte & 0x7F) << 7) | ((third & 0x7F) << 14)
                 str_start = pos + 3
               end
             end

data/lib/legion/extensions/microsoft_teams/runners/bot.rb

@@ -194,7 +194,7 @@ module Legion
 
           def send_chat_message_via_graph(chat_id:, text:, token: nil, **)
             conn = graph_connection(token: token)
-            response = conn.post("/chats/#{chat_id}/messages", { body: { contentType: 'text', content: text } })
+            response = conn.post("chats/#{chat_id}/messages", { body: { contentType: 'text', content: text } })
             { result: response.body }
           end
 
@@ -384,13 +384,13 @@ module Legion
             nil
           end
 
-          def find_chat_with_person(name:, token: nil)
+          def find_chat_with_person(name:, user_id: 'me', token: nil)
             conn = graph_connection(token: token)
-            response = conn.get('/me/chats', { '$filter' => "chatType eq 'oneOnOne'", '$top' => 50 })
+            response = conn.get("#{user_path(user_id)}/chats", { '$filter' => "chatType eq 'oneOnOne'", '$top' => 50 })
             chats = response.body&.dig('value') || []
 
             chats.each do |chat|
-              members_resp = conn.get("/chats/#{chat['id']}/members")
+              members_resp = conn.get("chats/#{chat['id']}/members")
               members = members_resp.body&.dig('value') || members_resp.body || []
               return { id: chat['id'] } if members.any? { |m| m['displayName']&.downcase&.include?(name.downcase) }
             end

data/lib/legion/extensions/microsoft_teams/runners/cache_ingest.rb

@@ -7,15 +7,6 @@ module Legion
     module MicrosoftTeams
       module Runners
         module CacheIngest
-          # Strip HTML tags from message content for clean memory traces.
-          def strip_html(html)
-            return '' if html.nil? || html.empty?
-
-            html.gsub(/<[^>]+>/, ' ').gsub('&nbsp;', ' ').gsub('&amp;', '&')
-                .gsub('&lt;', '<').gsub('&gt;', '>').gsub('&quot;', '"')
-                .gsub(/\s+/, ' ').strip
-          end
-
           # Ingest Teams messages from local cache into lex-memory traces.
           # Returns count of new traces stored and the latest compose_time seen.
           def ingest_cache(since: nil, skip_bots: true, db_path: nil, imprint_active: false, **)
@@ -60,6 +51,14 @@ module Legion
 
           private
 
+          def strip_html(html)
+            return '' if html.nil? || html.empty?
+
+            html.gsub(/<[^>]+>/, ' ').gsub('&nbsp;', ' ').gsub('&amp;', '&')
+                .gsub('&lt;', '<').gsub('&gt;', '>').gsub('&quot;', '"')
+                .gsub(/\s+/, ' ').strip
+          end
+
           def memory_available?
             defined?(Legion::Extensions::Memory::Runners::Traces)
           end

data/lib/legion/extensions/microsoft_teams/runners/channel_messages.rb

@@ -11,26 +11,26 @@ module Legion
 
           def list_channel_messages(team_id:, channel_id:, top: 50, **)
             params = { '$top' => top }
-            response = graph_connection(**).get("/teams/#{team_id}/channels/#{channel_id}/messages", params)
+            response = graph_connection(**).get("teams/#{team_id}/channels/#{channel_id}/messages", params)
             { result: response.body }
           end
 
           def get_channel_message(team_id:, channel_id:, message_id:, **)
-            response = graph_connection(**).get("/teams/#{team_id}/channels/#{channel_id}/messages/#{message_id}")
+            response = graph_connection(**).get("teams/#{team_id}/channels/#{channel_id}/messages/#{message_id}")
             { result: response.body }
           end
 
           def send_channel_message(team_id:, channel_id:, content:, content_type: 'text', attachments: [], **)
             payload = { body: { contentType: content_type, content: content } }
             payload[:attachments] = attachments unless attachments.empty?
-            response = graph_connection(**).post("/teams/#{team_id}/channels/#{channel_id}/messages", payload)
+            response = graph_connection(**).post("teams/#{team_id}/channels/#{channel_id}/messages", payload)
             { result: response.body }
           end
 
           def reply_to_channel_message(team_id:, channel_id:, message_id:, content:, content_type: 'text', **)
             payload = { body: { contentType: content_type, content: content } }
             response = graph_connection(**).post(
-              "/teams/#{team_id}/channels/#{channel_id}/messages/#{message_id}/replies", payload
+              "teams/#{team_id}/channels/#{channel_id}/messages/#{message_id}/replies", payload
             )
             { result: response.body }
           end
@@ -38,7 +38,7 @@ module Legion
           def list_channel_message_replies(team_id:, channel_id:, message_id:, top: 50, **)
             params = { '$top' => top }
             response = graph_connection(**).get(
-              "/teams/#{team_id}/channels/#{channel_id}/messages/#{message_id}/replies", params
+              "teams/#{team_id}/channels/#{channel_id}/messages/#{message_id}/replies", params
             )
             { result: response.body }
           end

data/lib/legion/extensions/microsoft_teams/runners/channels.rb

@@ -10,19 +10,19 @@ module Legion
           include Legion::Extensions::MicrosoftTeams::Helpers::Client
 
           def list_channels(team_id:, **)
-            response = graph_connection(**).get("/teams/#{team_id}/channels")
+            response = graph_connection(**).get("teams/#{team_id}/channels")
             { result: response.body }
           end
 
           def get_channel(team_id:, channel_id:, **)
-            response = graph_connection(**).get("/teams/#{team_id}/channels/#{channel_id}")
+            response = graph_connection(**).get("teams/#{team_id}/channels/#{channel_id}")
             { result: response.body }
           end
 
           def create_channel(team_id:, display_name:, description: nil, membership_type: 'standard', **)
             payload = { displayName: display_name, membershipType: membership_type }
             payload[:description] = description if description
-            response = graph_connection(**).post("/teams/#{team_id}/channels", payload)
+            response = graph_connection(**).post("teams/#{team_id}/channels", payload)
             { result: response.body }
           end
 
@@ -30,17 +30,17 @@ module Legion
             payload = {}
             payload[:displayName] = display_name if display_name
             payload[:description] = description if description
-            response = graph_connection(**).patch("/teams/#{team_id}/channels/#{channel_id}", payload)
+            response = graph_connection(**).patch("teams/#{team_id}/channels/#{channel_id}", payload)
             { result: response.body }
           end
 
           def delete_channel(team_id:, channel_id:, **)
-            response = graph_connection(**).delete("/teams/#{team_id}/channels/#{channel_id}")
+            response = graph_connection(**).delete("teams/#{team_id}/channels/#{channel_id}")
             { result: response.body }
           end
 
           def list_channel_members(team_id:, channel_id:, **)
-            response = graph_connection(**).get("/teams/#{team_id}/channels/#{channel_id}/members")
+            response = graph_connection(**).get("teams/#{team_id}/channels/#{channel_id}/members")
             { result: response.body }
           end
 

data/lib/legion/extensions/microsoft_teams/runners/chats.rb

@@ -11,24 +11,24 @@ module Legion
 
           def list_chats(user_id: 'me', top: 50, **)
             params = { '$top' => top }
-            response = graph_connection(**).get("/#{user_id}/chats", params)
+            response = graph_connection(**).get("#{user_path(user_id)}/chats", params)
             { result: response.body }
           end
 
           def get_chat(chat_id:, **)
-            response = graph_connection(**).get("/chats/#{chat_id}")
+            response = graph_connection(**).get("chats/#{chat_id}")
             { result: response.body }
           end
 
           def create_chat(members:, chat_type: 'oneOnOne', topic: nil, **)
             payload = { chatType: chat_type, members: members }
             payload[:topic] = topic if topic
-            response = graph_connection(**).post('/chats', payload)
+            response = graph_connection(**).post('chats', payload)
             { result: response.body }
           end
 
           def list_chat_members(chat_id:, **)
-            response = graph_connection(**).get("/chats/#{chat_id}/members")
+            response = graph_connection(**).get("chats/#{chat_id}/members")
             { result: response.body }
           end
 
@@ -38,7 +38,7 @@ module Legion
               'roles'           => roles,
               'user@odata.bind' => "https://graph.microsoft.com/v1.0/users('#{user_id}')"
             }
-            response = graph_connection(**).post("/chats/#{chat_id}/members", payload)
+            response = graph_connection(**).post("chats/#{chat_id}/members", payload)
             { result: response.body }
           end