slk 0.1.0 → 0.2.0

data/lib/slk/services/activity_enricher.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Enriches activity feed items with resolved user/channel names
+    class ActivityEnricher
+      def initialize(cache_store:, conversations_api:, on_debug: nil)
+        @cache = cache_store
+        @conversations_api = conversations_api
+        @on_debug = on_debug
+      end
+
+      # Enrich a list of activity items
+      def enrich_all(items, workspace)
+        items.map do |item|
+          enriched = item.dup
+          enrich_item(enriched, workspace)
+          enriched
+        end
+      end
+
+      # Enrich a single activity item based on its type
+      def enrich_item(item, workspace)
+        type = item.dig('item', 'type')
+        dispatch_enrich(type, item, workspace)
+      end
+
+      def dispatch_enrich(type, item, workspace)
+        case type
+        when 'message_reaction' then enrich_reaction(item, workspace)
+        when 'at_user', 'at_user_group', 'at_channel', 'at_everyone' then enrich_mention(item, workspace)
+        when 'thread_v2' then enrich_thread(item, workspace)
+        when 'bot_dm_bundle' then enrich_bot_dm(item, workspace)
+        else @on_debug&.call("Unknown activity type: #{type.inspect}") if type
+        end
+      end
+
+      # Resolve user ID to name (cache-only)
+      def resolve_user(workspace, user_id)
+        @cache.get_user(workspace.name, user_id) || user_id
+      end
+
+      # Resolve channel ID to name (with API fallback)
+      def resolve_channel(workspace, channel_id, with_hash: true)
+        return 'DM' if channel_id.start_with?('D')
+        return 'Group DM' if channel_id.start_with?('G')
+
+        name = fetch_channel_name(workspace, channel_id)
+        return channel_id unless name
+
+        with_hash ? "##{name}" : name
+      end
+
+      private
+
+      def enrich_reaction(item, workspace)
+        reaction_data = item.dig('item', 'reaction')
+        message_data = item.dig('item', 'message')
+        return debug_missing('reaction', 'reaction or message') unless reaction_data && message_data
+
+        enrich_user(item, %w[item reaction], 'user', workspace)
+        enrich_channel(item, %w[item message], 'channel', workspace)
+      end
+
+      def enrich_mention(item, workspace)
+        message_data = item.dig('item', 'message')
+        return debug_missing('mention', 'message') unless message_data
+
+        user_id = message_data['author_user_id'] || message_data['user']
+        item['item']['message']['user_name'] = resolve_user(workspace, user_id) if user_id
+        enrich_channel(item, %w[item message], 'channel', workspace)
+      end
+
+      def enrich_thread(item, workspace)
+        thread_entry = item.dig('item', 'bundle_info', 'payload', 'thread_entry')
+        return debug_missing('thread', 'thread_entry') unless thread_entry
+
+        enrich_channel(item, %w[item bundle_info payload thread_entry], 'channel_id', workspace)
+      end
+
+      def enrich_bot_dm(item, workspace)
+        message_data = item.dig('item', 'bundle_info', 'payload', 'message')
+        return debug_missing('bot DM', 'message') unless message_data
+
+        enrich_channel(item, %w[item bundle_info payload message], 'channel', workspace)
+      end
+
+      def enrich_user(item, path, key, workspace)
+        data = item.dig(*path)
+        return unless data
+
+        user_id = data[key]
+        data['user_name'] = resolve_user(workspace, user_id) if user_id
+      end
+
+      def enrich_channel(item, path, key, workspace)
+        data = item.dig(*path)
+        return unless data
+
+        channel_id = data[key]
+        data['channel_name'] = resolve_channel(workspace, channel_id, with_hash: false) if channel_id
+      end
+
+      def fetch_channel_name(workspace, channel_id)
+        cached = @cache.get_channel_name(workspace.name, channel_id)
+        return cached if cached
+
+        response = @conversations_api.info(channel: channel_id)
+        return nil unless response['ok'] && response['channel']
+
+        name = response['channel']['name']
+        @cache.set_channel(workspace.name, name, channel_id)
+        name
+      rescue ApiError => e
+        @on_debug&.call("Could not resolve channel #{channel_id}: #{e.message}")
+        nil
+      end
+
+      def debug_missing(item_type, missing_data)
+        @on_debug&.call("Could not enrich #{item_type} item - missing #{missing_data} data")
+      end
+    end
+  end
+end

data/lib/slk/services/api_client.rb

@@ -0,0 +1,145 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # HTTP client for Slack API with connection pooling
+    # rubocop:disable Metrics/ClassLength
+    class ApiClient
+      BASE_URL = ENV.fetch('SLACK_API_BASE', 'https://slack.com/api')
+
+      # Network errors that should be wrapped in ApiError
+      NETWORK_ERRORS = [
+        SocketError,
+        Errno::ECONNREFUSED,
+        Errno::ECONNRESET,
+        Errno::ETIMEDOUT,
+        Errno::EHOSTUNREACH,
+        Net::OpenTimeout,
+        Net::ReadTimeout,
+        OpenSSL::SSL::SSLError
+      ].freeze
+
+      attr_reader :call_count
+      attr_accessor :on_request
+
+      def initialize
+        @call_count = 0
+        @on_request = nil
+        @http_cache = {}
+      end
+
+      # Close all cached HTTP connections
+      def close
+        @http_cache.each_value { |http| safe_close(http) }
+        @http_cache.clear
+      end
+
+      def post(workspace, method, params = {})
+        execute_request(method) do |uri, http|
+          request = Net::HTTP::Post.new(uri)
+          workspace.headers.each { |k, v| request[k] = v }
+          request.body = JSON.generate(params) unless params.empty?
+          http.request(request)
+        end
+      end
+
+      def get(workspace, method, params = {})
+        execute_request(method, params) do |uri, http|
+          request = Net::HTTP::Get.new(uri)
+          apply_auth_headers(request, workspace)
+          http.request(request)
+        end
+      end
+
+      # Form-encoded POST (some Slack endpoints require this)
+      def post_form(workspace, method, params = {})
+        execute_request(method) do |uri, http|
+          request = Net::HTTP::Post.new(uri)
+          apply_auth_headers(request, workspace)
+          request.set_form_data(params)
+          http.request(request)
+        end
+      end
+
+      private
+
+      def safe_close(http)
+        http.finish if http.started?
+      rescue IOError
+        # Connection already closed
+      end
+
+      def execute_request(method, query_params = nil)
+        log_request(method)
+        uri = URI("#{BASE_URL}/#{method}")
+        uri.query = URI.encode_www_form(query_params) if query_params&.any?
+
+        http = get_http(uri)
+        response = yield(uri, http)
+        handle_response(response, method)
+      rescue *NETWORK_ERRORS => e
+        raise ApiError, "Network error: #{e.message}"
+      end
+
+      def apply_auth_headers(request, workspace)
+        request['Authorization'] = workspace.headers['Authorization']
+        request['Cookie'] = workspace.headers['Cookie'] if workspace.headers['Cookie']
+      end
+
+      def log_request(method)
+        @call_count += 1
+        @on_request&.call(method, @call_count)
+      end
+
+      # Get or create a persistent HTTP connection for the given URI
+      def get_http(uri)
+        key = "#{uri.host}:#{uri.port}"
+        cached = @http_cache[key]
+
+        # Return cached connection if it's still active
+        return cached if cached&.started?
+
+        # Create new connection
+        http = Net::HTTP.new(uri.host, uri.port)
+        configure_ssl(http, uri)
+        http.start
+
+        @http_cache[key] = http
+        http
+      end
+
+      def configure_ssl(http, uri)
+        http.use_ssl = uri.scheme == 'https'
+        http.open_timeout = 10
+        http.read_timeout = 30
+        http.keep_alive_timeout = 30
+
+        return unless http.use_ssl?
+
+        # Use system certificate store for SSL verification
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.cert_store = OpenSSL::X509::Store.new
+        http.cert_store.set_default_paths
+      end
+
+      def handle_response(response, _method)
+        case response
+        when Net::HTTPSuccess then parse_success_response(response)
+        when Net::HTTPUnauthorized then raise ApiError, 'Invalid token or session expired'
+        when Net::HTTPTooManyRequests then raise ApiError, 'Rate limited - please wait and try again'
+        else raise ApiError, "HTTP #{response.code}: #{response.message}"
+        end
+      end
+
+      def parse_success_response(response)
+        result = JSON.parse(response.body)
+        raise ApiError, result['error'] || 'Unknown error' unless result['ok']
+
+        result
+      rescue JSON::ParserError
+        raise ApiError, 'Invalid JSON response from Slack API'
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/{slack_cli → slk}/services/cache_store.rb

@@ -1,7 +1,9 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Services
+    # Persistent cache for user names, channel names, and subteams
+    # rubocop:disable Metrics/ClassLength
     class CacheStore
       attr_accessor :on_warning
 
@@ -54,10 +56,10 @@ module SlackCli
         if workspace_name
           @user_cache.delete(workspace_name)
           file = user_cache_file(workspace_name)
-          File.delete(file) if File.exist?(file)
+          FileUtils.rm_f(file)
         else
           @user_cache.clear
-          Dir.glob(@paths.cache_file("users-*.json")).each { |f| File.delete(f) }
+          Dir.glob(@paths.cache_file('users-*.json')).each { |f| File.delete(f) }
         end
       end
 
@@ -83,10 +85,10 @@ module SlackCli
         if workspace_name
           @channel_cache.delete(workspace_name)
           file = channel_cache_file(workspace_name)
-          File.delete(file) if File.exist?(file)
+          FileUtils.rm_f(file)
         else
           @channel_cache.clear
-          Dir.glob(@paths.cache_file("channels-*.json")).each { |f| File.delete(f) }
+          Dir.glob(@paths.cache_file('channels-*.json')).each { |f| File.delete(f) }
         end
       end
 
@@ -129,10 +131,10 @@ module SlackCli
 
         file = user_cache_file(workspace_name)
         @user_cache[workspace_name] = if File.exist?(file)
-          JSON.parse(File.read(file))
-        else
-          {}
-        end
+                                        JSON.parse(File.read(file))
+                                      else
+                                        {}
+                                      end
       rescue JSON::ParserError => e
         @on_warning&.call("User cache corrupted for #{workspace_name}: #{e.message}")
         @user_cache[workspace_name] = {}
@@ -143,10 +145,10 @@ module SlackCli
 
         file = channel_cache_file(workspace_name)
         @channel_cache[workspace_name] = if File.exist?(file)
-          JSON.parse(File.read(file))
-        else
-          {}
-        end
+                                           JSON.parse(File.read(file))
+                                         else
+                                           {}
+                                         end
       rescue JSON::ParserError => e
         @on_warning&.call("Channel cache corrupted for #{workspace_name}: #{e.message}")
         @channel_cache[workspace_name] = {}
@@ -173,10 +175,10 @@ module SlackCli
 
         file = subteam_cache_file(workspace_name)
         @subteam_cache[workspace_name] = if File.exist?(file)
-          JSON.parse(File.read(file))
-        else
-          {}
-        end
+                                           JSON.parse(File.read(file))
+                                         else
+                                           {}
+                                         end
       rescue JSON::ParserError => e
         @on_warning&.call("Subteam cache corrupted for #{workspace_name}: #{e.message}")
         @subteam_cache[workspace_name] = {}
@@ -194,5 +196,6 @@ module SlackCli
         @paths.cache_file("subteams-#{workspace_name}.json")
       end
     end
+    # rubocop:enable Metrics/ClassLength
   end
 end

data/lib/{slack_cli → slk}/services/configuration.rb

@@ -1,36 +1,37 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Services
+    # Manages CLI configuration stored in XDG config directory
     class Configuration
       attr_accessor :on_warning
 
       def initialize(paths: Support::XdgPaths.new)
         @paths = paths
         @on_warning = nil
-        @data = nil  # Lazy load to allow on_warning to be set first
+        @data = nil # Lazy load to allow on_warning to be set first
       end
 
       def primary_workspace
-        data["primary_workspace"]
+        data['primary_workspace']
       end
 
       def primary_workspace=(name)
-        data["primary_workspace"] = name
+        data['primary_workspace'] = name
         save_config
       end
 
       def ssh_key
-        data["ssh_key"]
+        data['ssh_key']
       end
 
       def ssh_key=(path)
-        data["ssh_key"] = path
+        data['ssh_key'] = path
         save_config
       end
 
       def emoji_dir
-        data["emoji_dir"]
+        data['emoji_dir']
       end
 
       def [](key)
@@ -53,7 +54,7 @@ module SlackCli
       end
 
       def config_file
-        @paths.config_file("config.json")
+        @paths.config_file('config.json')
       end
 
       def load_config

data/lib/slk/services/emoji_downloader.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Downloads workspace custom emoji to local cache
+    class EmojiDownloader
+      NETWORK_ERRORS = [
+        SocketError,
+        Errno::ECONNREFUSED,
+        Errno::ETIMEDOUT,
+        Net::OpenTimeout,
+        Net::ReadTimeout,
+        URI::InvalidURIError,
+        OpenSSL::SSL::SSLError
+      ].freeze
+
+      def initialize(emoji_dir:, on_progress: nil, on_debug: nil)
+        @emoji_dir = emoji_dir
+        @on_progress = on_progress
+        @on_debug = on_debug
+      end
+
+      # Download custom emoji for a workspace
+      # @param workspace_name [String] Name of the workspace
+      # @param emoji_map [Hash] Map of emoji name to URL from API
+      # @return [Hash] Result with :downloaded, :skipped, :failed, :aliases
+      def download(workspace_name, emoji_map)
+        workspace_dir = File.join(@emoji_dir, workspace_name)
+        FileUtils.mkdir_p(workspace_dir)
+
+        to_download = emoji_map.reject { |_, url| url.start_with?('alias:') }
+        stats = initial_stats(emoji_map.size, to_download.size)
+
+        download_all(workspace_dir, to_download, stats)
+        stats
+      end
+
+      private
+
+      def initial_stats(total_count, downloadable_count)
+        { downloaded: 0, skipped: 0, failed: 0, aliases: total_count - downloadable_count, total: downloadable_count }
+      end
+
+      def download_all(workspace_dir, to_download, stats)
+        to_download.each_with_index do |(name, url), idx|
+          result = download_single(workspace_dir, name, url)
+          update_stats(stats, result)
+          report_progress(idx + 1, stats)
+        end
+      end
+
+      def update_stats(stats, result)
+        stats[result] += 1 if %i[downloaded skipped failed].include?(result)
+      end
+
+      def download_single(workspace_dir, name, url)
+        ext = File.extname(URI.parse(url).path)
+        ext = '.png' if ext.empty?
+        filepath = File.join(workspace_dir, "#{name}#{ext}")
+
+        # Skip if already exists
+        return :skipped if File.exist?(filepath)
+
+        # Download the emoji
+        download_file(url, filepath) ? :downloaded : :failed
+      rescue URI::InvalidURIError
+        :failed
+      end
+
+      def download_file(url, filepath)
+        response = fetch_url(url)
+        return false unless response.is_a?(Net::HTTPSuccess)
+
+        File.binwrite(filepath, response.body)
+        true
+      rescue *NETWORK_ERRORS, SystemCallError => e
+        @on_debug&.call("Failed to download emoji: #{e.message}")
+        false
+      end
+
+      def fetch_url(url)
+        uri = URI.parse(url)
+        http = build_http_client(uri)
+        http.request(Net::HTTP::Get.new(uri))
+      end
+
+      def build_http_client(uri)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.verify_mode = OpenSSL::SSL::VERIFY_PEER
+        http.cert_store = OpenSSL::X509::Store.new
+        http.cert_store.set_default_paths
+        http.open_timeout = 10
+        http.read_timeout = 30
+        http
+      end
+
+      def report_progress(current, stats)
+        @on_progress&.call(current, stats[:total], stats[:downloaded], stats[:skipped])
+      end
+    end
+  end
+end

data/lib/slk/services/emoji_searcher.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Searches standard and workspace custom emoji
+    class EmojiSearcher
+      def initialize(cache_dir:, emoji_dir:, on_debug: nil)
+        @cache_dir = cache_dir
+        @emoji_dir = emoji_dir
+        @on_debug = on_debug
+      end
+
+      # Search emoji by pattern
+      # @param query [String] Search query
+      # @param workspaces [Array<Workspace>] Workspaces to search (nil for all)
+      # @return [Hash] Results grouped by source
+      def search(query, workspaces: [])
+        pattern = Regexp.new(Regexp.escape(query), Regexp::IGNORECASE)
+        results = []
+
+        # Search standard emoji
+        results.concat(search_standard(pattern))
+
+        # Search workspace custom emoji
+        workspaces.each do |workspace|
+          results.concat(search_workspace(workspace, pattern))
+        end
+
+        # Group by source
+        results.group_by { |r| r[:source] }
+      end
+
+      # Search standard emoji only
+      # @param pattern [Regexp] Pattern to match
+      # @return [Array<Hash>] Matching emoji with :name, :char, :source
+      def search_standard(pattern)
+        gemoji = load_gemoji
+        return [] unless gemoji
+
+        gemoji.filter_map do |name, char|
+          { name: name, char: char, source: 'standard' } if name.match?(pattern)
+        end
+      end
+
+      # Search a workspace's custom emoji
+      # @param workspace [Workspace] Workspace to search
+      # @param pattern [Regexp] Pattern to match
+      # @return [Array<Hash>] Matching emoji with :name, :path, :source
+      def search_workspace(workspace, pattern)
+        workspace_dir = File.join(@emoji_dir, workspace.name)
+        return [] unless Dir.exist?(workspace_dir)
+
+        Dir.glob(File.join(workspace_dir, '*')).filter_map do |filepath|
+          name = File.basename(filepath, '.*')
+          { name: name, path: filepath, source: workspace.name } if name.match?(pattern)
+        end
+      end
+
+      private
+
+      def load_gemoji
+        gemoji_path = File.join(@cache_dir, 'gemoji.json')
+        return nil unless File.exist?(gemoji_path)
+
+        JSON.parse(File.read(gemoji_path))
+      rescue JSON::ParserError
+        @on_debug&.call('Standard emoji cache corrupted, skipping')
+        nil
+      end
+    end
+  end
+end

data/lib/{slack_cli → slk}/services/encryption.rb

@@ -1,25 +1,24 @@
 # frozen_string_literal: true
 
-require "open3"
+require 'open3'
 
-module SlackCli
+module Slk
   module Services
+    # Encrypts/decrypts tokens using age with SSH keys
     class Encryption
       def available?
-        system("which age > /dev/null 2>&1")
+        system('which age > /dev/null 2>&1')
       end
 
-      def encrypt(content, ssh_key_path, output_file)
-        raise EncryptionError, "age encryption tool not available" unless available?
+      def encrypt(content, ssh_key_path, output_file) # rubocop:disable Naming/PredicateMethod
+        raise EncryptionError, 'age encryption tool not available' unless available?
 
         public_key = "#{ssh_key_path}.pub"
         raise EncryptionError, "Public key not found: #{public_key}" unless File.exist?(public_key)
 
-        _output, error, status = Open3.capture3("age", "-R", public_key, "-o", output_file, stdin_data: content)
+        _output, error, status = Open3.capture3('age', '-R', public_key, '-o', output_file, stdin_data: content)
 
-        unless status.success?
-          raise EncryptionError, "Failed to encrypt: #{error.strip}"
-        end
+        raise EncryptionError, "Failed to encrypt: #{error.strip}" unless status.success?
 
         true
       end
@@ -33,14 +32,12 @@ module SlackCli
         # File not existing is not an error - it just means no encrypted data yet
         return nil unless File.exist?(encrypted_file)
 
-        raise EncryptionError, "age encryption tool not available" unless available?
+        raise EncryptionError, 'age encryption tool not available' unless available?
         raise EncryptionError, "SSH key not found: #{ssh_key_path}" unless File.exist?(ssh_key_path)
 
-        output, error, status = Open3.capture3("age", "-d", "-i", ssh_key_path, encrypted_file)
+        output, error, status = Open3.capture3('age', '-d', '-i', ssh_key_path, encrypted_file)
 
-        unless status.success?
-          raise EncryptionError, "Failed to decrypt #{encrypted_file}: #{error.strip}"
-        end
+        raise EncryptionError, "Failed to decrypt #{encrypted_file}: #{error.strip}" unless status.success?
 
         output
       rescue Errno::ENOENT => e