slk 0.4.2 → 0.6.0

data/lib/slk/services/cache_store.rb

@@ -12,10 +12,37 @@ module Slk
         @user_cache = {}
         @channel_cache = {}
         @subteam_cache = {}
+        @meta_cache = {}
         @on_warning = nil
         @on_cache_access = nil
       end
 
+      # Workspace metadata cache (auth.test user_id, team.info team_id,
+      # team.profile.get schema). One JSON file per workspace; entries can
+      # carry an optional fetched_at epoch for TTL checks.
+      def get_meta(workspace_name, key, ttl: nil)
+        load_meta_cache(workspace_name)
+        entry = @meta_cache[workspace_name][key]
+        return nil unless entry
+        return nil if ttl && entry['fetched_at'] && Time.now.to_i - entry['fetched_at'] > ttl
+
+        log_cache_access('meta', workspace_name, key, entry['value'])
+        entry['value']
+      end
+
+      def set_meta(workspace_name, key, value, persist: true)
+        load_meta_cache(workspace_name)
+        @meta_cache[workspace_name] ||= {}
+        @meta_cache[workspace_name][key] = { 'value' => value, 'fetched_at' => Time.now.to_i }
+        save_meta_cache(workspace_name) if persist
+        value
+      end
+
+      def each_meta(workspace_name)
+        load_meta_cache(workspace_name)
+        (@meta_cache[workspace_name] || {}).each
+      end
+
       # User cache methods
       def get_user(workspace_name, user_id)
         load_user_cache(workspace_name)
@@ -126,12 +153,12 @@ module Slk
       # Cache status
       def user_cache_size(workspace_name)
         load_user_cache(workspace_name)
-        @user_cache[workspace_name]&.size || 0
+        @user_cache[workspace_name].size
       end
 
       def channel_cache_size(workspace_name)
         load_channel_cache(workspace_name)
-        @channel_cache[workspace_name]&.size || 0
+        @channel_cache[workspace_name].size
       end
 
       def user_cache_file_exists?(workspace_name)
@@ -208,6 +235,23 @@ module Slk
         @paths.cache_file("subteams-#{workspace_name}.json")
       end
 
+      def meta_cache_file(workspace_name)
+        @paths.cache_file("meta-#{workspace_name}.json")
+      end
+
+      def load_meta_cache(workspace_name)
+        return if @meta_cache.key?(workspace_name)
+
+        @meta_cache[workspace_name] = load_cache_file(meta_cache_file(workspace_name), 'Meta', workspace_name)
+      end
+
+      def save_meta_cache(workspace_name)
+        return if @meta_cache[workspace_name].nil? || @meta_cache[workspace_name].empty?
+
+        @paths.ensure_cache_dir
+        File.write(meta_cache_file(workspace_name), JSON.pretty_generate(@meta_cache[workspace_name]))
+      end
+
       def log_cache_access(type, workspace, key, result)
         return unless @on_cache_access
 

data/lib/slk/services/file_downloader.rb

@@ -0,0 +1,180 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Downloads Slack message files and attachment images to XDG cache dir.
+    # Authed files (url_private_download) require workspace headers.
+    # Public attachment images (image_url) are fetched without auth.
+    # rubocop:disable Metrics/ClassLength
+    class FileDownloader
+      NETWORK_ERRORS = [
+        SocketError,
+        Errno::ECONNREFUSED,
+        Errno::ETIMEDOUT,
+        Net::OpenTimeout,
+        Net::ReadTimeout,
+        URI::InvalidURIError,
+        OpenSSL::SSL::SSLError
+      ].freeze
+
+      IMAGE_TYPES = %w[png jpg jpeg gif bmp webp svg].freeze
+      MAX_REDIRECTS = 3
+
+      def initialize(cache_dir:, on_debug: nil)
+        @cache_dir = cache_dir
+        @on_debug = on_debug
+      end
+
+      # Download all files from a list of messages, returning a hash of
+      # file_id => local_path for files and attachment index => local_path for attachments.
+      def download_message_files(messages, workspace)
+        files_dir = ensure_workspace_dir(workspace.name)
+        file_paths = {}
+
+        messages.each do |message|
+          download_files(message.files, files_dir, workspace, file_paths)
+          download_attachment_images(message.attachments, message.ts, files_dir, file_paths)
+        end
+
+        file_paths
+      end
+
+      private
+
+      def ensure_workspace_dir(workspace_name)
+        dir = File.join(@cache_dir, 'files', workspace_name)
+        FileUtils.mkdir_p(dir)
+        dir
+      end
+
+      def download_files(files, dir, workspace, paths)
+        files.each do |file|
+          path = download_single_file(file, dir, workspace)
+          paths[file['id']] = path if path
+        end
+      end
+
+      def download_single_file(file, dir, workspace)
+        file_id = file['id']
+        url = file['url_private_download']
+        return unless file_id && url
+
+        name = file['name'] || 'file'
+        local_path = File.join(dir, "#{file_id}_#{sanitize_filename(name)}")
+
+        return local_path if cached?(local_path, name)
+
+        download_authed(url, local_path, workspace) ? local_path : nil
+      end
+
+      def download_attachment_images(attachments, message_ts, dir, paths)
+        attachments.each_with_index do |att, idx|
+          path = download_single_attachment(att, message_ts, idx, dir)
+          paths["att_#{message_ts}_#{idx}"] = path if path
+        end
+      end
+
+      def download_single_attachment(att, message_ts, idx, dir)
+        url = att['image_url'] || att['thumb_url']
+        return unless url && downloadable_image_url?(url)
+
+        local_path = attachment_path(dir, message_ts, idx, url)
+        return local_path if cached?(local_path, 'attachment image')
+
+        download_public(url, local_path) ? local_path : nil
+      rescue URI::InvalidURIError
+        nil
+      end
+
+      def attachment_path(dir, message_ts, idx, url)
+        ext = File.extname(URI.parse(url).path)
+        ext = '.jpg' if ext.empty?
+        File.join(dir, "att_#{message_ts}_#{idx}#{ext}")
+      end
+
+      def cached?(local_path, label)
+        return false unless File.exist?(local_path)
+
+        @on_debug&.call("Skipping #{label} (cached)")
+        true
+      end
+
+      def downloadable_image_url?(url)
+        ext = File.extname(URI.parse(url).path).delete('.').downcase
+        IMAGE_TYPES.include?(ext) || url.include?('/giphy') || url.include?('tenor.com')
+      rescue URI::InvalidURIError
+        false
+      end
+
+      def download_authed(url, filepath, workspace)
+        uri = URI.parse(url)
+        request = Net::HTTP::Get.new(uri)
+        apply_workspace_headers(request, workspace)
+        write_response(build_http_client(uri).request(request), filepath)
+      rescue *NETWORK_ERRORS, SystemCallError => e
+        @on_debug&.call("Failed to download file: #{e.message}")
+        false
+      end
+
+      def apply_workspace_headers(request, workspace)
+        request['Authorization'] = workspace.headers['Authorization']
+        request['Cookie'] = workspace.headers['Cookie'] if workspace.headers['Cookie']
+      end
+
+      def download_public(url, filepath)
+        response = fetch_with_redirect(url)
+        write_response(response, filepath)
+      rescue *NETWORK_ERRORS, SystemCallError => e
+        @on_debug&.call("Failed to download attachment image: #{e.message}")
+        false
+      end
+
+      def fetch_with_redirect(url)
+        uri = URI.parse(url)
+        MAX_REDIRECTS.times do
+          response = build_http_client(uri).request(Net::HTTP::Get.new(uri))
+          return response unless response.is_a?(Net::HTTPRedirection) && response['location']
+
+          uri = resolve_redirect(uri, response['location'])
+          return response unless uri.host
+        end
+        # Exhausted redirects — return last response as-is
+        build_http_client(uri).request(Net::HTTP::Get.new(uri))
+      end
+
+      def resolve_redirect(original_uri, location)
+        parsed = URI.parse(location)
+        return parsed if parsed.host
+
+        # Relative redirect — resolve against original URI
+        URI.parse("#{original_uri.scheme}://#{original_uri.host}:#{original_uri.port}#{location}")
+      end
+
+      def write_response(response, filepath) # rubocop:disable Naming/PredicateMethod
+        return false unless response.is_a?(Net::HTTPSuccess)
+
+        File.binwrite(filepath, response.body)
+        @on_debug&.call("Downloaded #{File.basename(filepath)} (#{response.body.bytesize} bytes)")
+        true
+      end
+
+      def build_http_client(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == 'https'
+        if http.use_ssl?
+          http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          http.cert_store = OpenSSL::X509::Store.new
+          http.cert_store.set_default_paths
+        end
+        http.open_timeout = 10
+        http.read_timeout = 30
+        http
+      end
+
+      def sanitize_filename(name)
+        name.gsub(%r{[/\\:*?"<>|]}, '_')
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/slk/services/meta_cache.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Read-through wrapper around CacheStore#get_meta/#set_meta with optional
+    # TTL and refresh override. Used by ProfileResolver and similar services.
+    module MetaCache
+      module_function
+
+      def fetch(cache_store, workspace_name, key, ttl: nil, refresh: false)
+        cached = read(cache_store, workspace_name, key, ttl: ttl) unless refresh
+        return cached if cached
+
+        value = yield
+        write(cache_store, workspace_name, key, value)
+        value
+      end
+
+      def read(cache_store, workspace_name, key, ttl: nil)
+        return nil unless cache_store && workspace_name
+
+        cache_store.get_meta(workspace_name, key, ttl: ttl)
+      end
+
+      def write(cache_store, workspace_name, key, value)
+        return unless cache_store && workspace_name && value
+
+        cache_store.set_meta(workspace_name, key, value)
+      end
+    end
+  end
+end

data/lib/slk/services/profile_builder.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Builds Models::Profile from raw users.profile.get + users.info +
+    # team.profile.get responses. Pure data assembly — no API calls.
+    module ProfileBuilder
+      module_function
+
+      # rubocop:disable Metrics/MethodLength
+      def build(profile_response:, info_response: nil, schema_response: nil, workspace_team_id: nil)
+        info_data = extract_info(info_response)
+        profile_data = extract_profile(profile_response, info_data)
+        schema = extract_schema(schema_response)
+        team_id = info_data['team_id'] || profile_data['team']
+
+        Models::Profile.new(
+          **identity(profile_data, info_data),
+          **status(profile_data),
+          **tz(info_data),
+          **flags(info_data, team_id, workspace_team_id),
+          team_id: team_id,
+          home_team_name: nil,
+          presence: nil,
+          sections: schema[:sections],
+          custom_fields: build_fields(profile_data['fields'] || {}, schema[:fields_by_id]),
+          resolved_users: {}
+        )
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      # Slack Connect external users often fail users.profile.get with
+      # user_not_found, but users.info still returns the same fields nested at
+      # user.profile. Fall back to that so we render a useful card.
+      def extract_profile(response, info_data = {})
+        primary = response.is_a?(Hash) ? (response['profile'] || {}) : {}
+        return primary unless primary.empty?
+
+        info_data['profile'] || {}
+      end
+
+      def extract_info(response)
+        return {} unless response.is_a?(Hash)
+
+        response['user'] || {}
+      end
+
+      def extract_schema(response)
+        section = response.is_a?(Hash) ? (response['profile'] || {}) : {}
+        fields = section['fields'] || []
+        {
+          fields_by_id: fields.to_h { |f| [f['id'], f] },
+          sections: section['sections'] || []
+        }
+      end
+
+      def identity(profile_data, info_data)
+        names(profile_data, info_data).merge(contact(profile_data))
+      end
+
+      def names(profile_data, info_data)
+        {
+          user_id: info_data['id'] || profile_data['id'] || '',
+          real_name: profile_data['real_name'] || info_data['real_name'],
+          display_name: profile_data['display_name'],
+          first_name: profile_data['first_name'],
+          last_name: profile_data['last_name']
+        }
+      end
+
+      def contact(profile_data)
+        {
+          title: profile_data['title'],
+          email: profile_data['email'],
+          phone: profile_data['phone'],
+          pronouns: profile_data['pronouns'],
+          image_url: profile_data['image_512'] || profile_data['image_192'] || profile_data['image_72'],
+          start_date: profile_data['start_date']
+        }
+      end
+
+      def status(profile_data)
+        {
+          status_text: profile_data['status_text'] || '',
+          status_emoji: profile_data['status_emoji'] || '',
+          status_expiration: profile_data['status_expiration'] || 0
+        }
+      end
+
+      def tz(info_data)
+        {
+          tz: info_data['tz'],
+          tz_label: info_data['tz_label'],
+          tz_offset: info_data['tz_offset'] || 0
+        }
+      end
+
+      def flags(info_data, team_id, workspace_team_id)
+        {
+          is_admin: info_data['is_admin'] || false,
+          is_owner: info_data['is_owner'] || false,
+          is_bot: info_data['is_bot'] || false,
+          is_external: external?(team_id, workspace_team_id),
+          deleted: info_data['deleted'] == true
+        }
+      end
+
+      def external?(team_id, workspace_team_id)
+        !!(workspace_team_id && team_id && team_id != workspace_team_id)
+      end
+
+      def build_fields(profile_fields, schema_fields_by_id)
+        profile_fields.map do |field_id, field_data|
+          build_field(field_id, field_data, schema_fields_by_id[field_id] || {})
+        end
+      end
+
+      def build_field(field_id, field_data, schema)
+        Models::ProfileField.new(
+          id: field_id, label: field_data['label'] || schema['label'] || field_id,
+          value: field_data['value'].to_s, alt: field_data['alt'].to_s,
+          type: schema['type'] || 'text', ordering: schema['ordering'].to_i,
+          section_id: schema['section_id'],
+          hidden: schema['is_hidden'] == true, inverse: schema['is_inverse'] == true
+        )
+      end
+    end
+  end
+end

data/lib/slk/services/profile_resolver.rb

@@ -0,0 +1,138 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Orchestrates the API calls needed to assemble a Models::Profile.
+    # Memoizes within the instance — one resolver per command run.
+    class ProfileResolver
+      SCHEMA_TTL = 86_400 # 24h
+      PROFILE_TTL = 3_600 # 1h
+      EMPTY_SCHEMA = { 'ok' => false, 'profile' => { 'fields' => [], 'sections' => [] } }.freeze
+
+      attr_accessor :refresh
+
+      def initialize(users_api:, team_api:, cache_store: nil, workspace_name: nil, on_debug: nil)
+        @users_api = users_api
+        @team_api = team_api
+        @cache_store = cache_store
+        @workspace_name = workspace_name
+        @on_debug = on_debug
+        @refresh = false
+        @profile_cache = {}
+        @home_team_names = {}
+      end
+
+      # Resolve a user ID to a Profile. Memoized per resolver instance.
+      def resolve(user_id)
+        return @profile_cache[user_id] if @profile_cache.key?(user_id)
+
+        @profile_cache[user_id] = build_profile(user_id)
+      end
+
+      # Resolve a profile and one level of type:user custom fields, populating
+      # `resolved_users` so the formatter can render the People section.
+      def resolve_with_people(user_id)
+        profile = resolve(user_id)
+        return profile if profile.external?
+
+        profile.people_fields.flat_map(&:user_ids).uniq.each do |ref_id|
+          profile.resolved_users[ref_id] ||= resolve(ref_id)
+        end
+        profile
+      end
+
+      # Walks Supervisor (or first non-inverse type:user field) upward.
+      # Returns Array<Profile> from immediate supervisor to top, capped by depth.
+      def resolve_chain_up(user_id, depth: 5)
+        chain = []
+        seen = Set.new([user_id])
+        current = resolve(user_id)
+        depth.times { current = step_up(current, seen, chain) or break }
+        chain
+      end
+
+      private
+
+      def step_up(current, seen, chain)
+        parent_id = current.supervisor_ids.first
+        return nil unless parent_id && !seen.include?(parent_id)
+
+        parent = resolve(parent_id)
+        chain << parent
+        seen << parent.user_id
+        parent
+      end
+
+      def build_profile(user_id)
+        profile = ProfileBuilder.build(
+          profile_response: fetch_profile_response(user_id),
+          info_response: cache_or_fetch("ui_#{user_id}", ttl: PROFILE_TTL) { @users_api.info(user_id) },
+          schema_response: schema,
+          workspace_team_id: workspace_team_id
+        )
+        attach_extras(profile, user_id)
+      rescue ApiError => e
+        @on_debug&.call("Profile resolve failed for #{user_id}: #{e.message}")
+        raise
+      end
+
+      # Only swallow `user_not_found` (Slack Connect); other errors propagate.
+      def fetch_profile_response(user_id)
+        key = "up_#{user_id}"
+        cached = MetaCache.read(@cache_store, @workspace_name, key, ttl: PROFILE_TTL) unless @refresh
+        return cached if cached
+
+        response = @users_api.profile_for(user_id)
+        MetaCache.write(@cache_store, @workspace_name, key, response)
+        response
+      rescue ApiError => e
+        raise unless e.code == :user_not_found
+
+        @on_debug&.call("#{key}: #{e.message} (falling back to users.info)")
+        nil
+      end
+
+      def attach_extras(profile, user_id)
+        profile = attach_home_team_name(profile)
+        presence = fetch_presence(user_id)
+        presence ? Models::Profile.new(**profile.to_h, presence: presence) : profile
+      end
+
+      def fetch_presence(user_id)
+        @users_api.get_presence_for(user_id)&.dig('presence')
+      rescue ApiError => e
+        @on_debug&.call("get_presence_for(#{user_id}) failed: #{e.message}")
+        nil
+      end
+
+      def schema
+        @schema ||= cache_or_fetch('team_profile_schema', ttl: SCHEMA_TTL,
+                                                          empty: EMPTY_SCHEMA) { @team_api.profile_schema }
+      end
+
+      def workspace_team_id
+        @workspace_team_id ||= cache_or_fetch('workspace_team_id') { @team_api.info.dig('team', 'id') }
+      end
+
+      def cache_or_fetch(key, ttl: nil, empty: nil, &)
+        MetaCache.fetch(@cache_store, @workspace_name, key, ttl: ttl, refresh: @refresh, &)
+      rescue ApiError => e
+        @on_debug&.call("#{key} fetch failed: #{e.message}")
+        empty
+      end
+
+      def attach_home_team_name(profile)
+        return profile unless profile.external? && profile.team_id && (name = home_team_name(profile.team_id))
+
+        Models::Profile.new(**profile.to_h, home_team_name: name)
+      end
+
+      def home_team_name(team_id)
+        @home_team_names[team_id] ||= @team_api.info(team_id).dig('team', 'name')
+      rescue ApiError => e
+        @on_debug&.call("team.info(#{team_id}) failed: #{e.message}")
+        @home_team_names[team_id] = nil
+      end
+    end
+  end
+end

data/lib/slk/services/user_lookup.rb

@@ -52,6 +52,14 @@ module Slk
         fetch_id_by_name(name)
       end
 
+      # @return [Array<Hash>] raw users.list-shaped hashes for all matches
+      def find_all_by_name(name)
+        UserMatcher.new(
+          api_client: @api, workspace: @workspace,
+          cache_store: @cache, on_debug: @on_debug
+        ).find_all(name)
+      end
+
       private
 
       def fetch_and_cache_name(user_id)
@@ -88,11 +96,7 @@ module Slk
       end
 
       def fetch_id_by_name(name)
-        return nil unless @api
-
-        users_api = Api::Users.new(@api, @workspace, on_debug: @on_debug)
-        users = users_api.list['members'] || []
-        user = find_user_by_name(users, name)
+        user = find_all_by_name(name).first
         cache_user_from_api(user) if user
         user&.dig('id')
       rescue ApiError => e
@@ -100,14 +104,6 @@ module Slk
         nil
       end
 
-      def find_user_by_name(users, name)
-        users.find do |u|
-          u['name'] == name ||
-            u.dig('profile', 'display_name') == name ||
-            u.dig('profile', 'real_name') == name
-        end
-      end
-
       def cache_user_from_api(user_data)
         user = Models::User.from_api(user_data)
         @cache.set_user(@workspace.name, user.id, user.best_name, persist: true)

data/lib/slk/services/user_matcher.rb

@@ -0,0 +1,64 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Finds all users whose name/display/real/first+last matches a query
+    # (case-insensitive). Combines users.list with previously-resolved profiles
+    # cached locally — Slack Connect external users don't appear in users.list
+    # but do show up in the meta cache once users.info has been fetched.
+    class UserMatcher
+      def initialize(api_client:, workspace:, cache_store:, on_debug: nil)
+        @api = api_client
+        @workspace = workspace
+        @cache = cache_store
+        @on_debug = on_debug
+      end
+
+      # Returns users.list-shaped hashes (deduped by id). Raises ApiError on
+      # network/auth failures so callers don't conflate them with "no matches".
+      def find_all(name)
+        return [] if name.to_s.empty? || @api.nil?
+
+        target = name.downcase
+        candidates = list_members + cached_profile_users
+        unique_by_id(candidates.select { |u| matches?(u, target) })
+      end
+
+      def matches?(user, target_lower)
+        name_candidates(user).any? { |c| c.downcase == target_lower }
+      end
+
+      def name_candidates(user)
+        profile = user['profile'] || {}
+        full = [profile['first_name'], profile['last_name']].compact.join(' ').strip
+        [user['name'], profile['display_name'], profile['real_name'], full]
+          .map(&:to_s).reject(&:empty?)
+      end
+
+      private
+
+      def list_members
+        Api::Users.new(@api, @workspace, on_debug: @on_debug).list['members'] || []
+      end
+
+      # Reshape cached `ui_<uid>` meta entries (raw users.info responses) into
+      # users.list-shaped hashes so the matcher can compare them uniformly.
+      def cached_profile_users
+        return [] unless @cache.respond_to?(:each_meta)
+
+        @cache.each_meta(@workspace.name).filter_map do |key, value|
+          next unless key.start_with?('ui_')
+
+          user = value.is_a?(Hash) ? value.dig('value', 'user') : nil
+          user if user.is_a?(Hash) && user['id']
+        end
+      end
+
+      def unique_by_id(users)
+        seen = {}
+        users.each { |u| seen[u['id']] ||= u }
+        seen.values
+      end
+    end
+  end
+end