slk 0.1.0

data/lib/slack_cli/services/api_client.rb

@@ -0,0 +1,149 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Services
+    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 do |http|
+          http.finish if http.started?
+        rescue IOError
+          # Connection already closed
+        end
+        @http_cache.clear
+      end
+
+      def post(workspace, method, params = {})
+        log_request(method)
+        uri = URI("#{BASE_URL}/#{method}")
+
+        http = get_http(uri)
+
+        request = Net::HTTP::Post.new(uri)
+        workspace.headers.each { |k, v| request[k] = v }
+        request.body = JSON.generate(params) unless params.empty?
+
+        response = http.request(request)
+        handle_response(response, method)
+      rescue *NETWORK_ERRORS => e
+        raise ApiError, "Network error: #{e.message}"
+      end
+
+      def get(workspace, method, params = {})
+        log_request(method)
+        uri = URI("#{BASE_URL}/#{method}")
+        uri.query = URI.encode_www_form(params) unless params.empty?
+
+        http = get_http(uri)
+
+        request = Net::HTTP::Get.new(uri)
+        request["Authorization"] = workspace.headers["Authorization"]
+        request["Cookie"] = workspace.headers["Cookie"] if workspace.headers["Cookie"]
+
+        response = http.request(request)
+        handle_response(response, method)
+      rescue *NETWORK_ERRORS => e
+        raise ApiError, "Network error: #{e.message}"
+      end
+
+      # Form-encoded POST (some Slack endpoints require this)
+      def post_form(workspace, method, params = {})
+        log_request(method)
+        uri = URI("#{BASE_URL}/#{method}")
+
+        http = get_http(uri)
+
+        request = Net::HTTP::Post.new(uri)
+        request["Authorization"] = workspace.headers["Authorization"]
+        request["Cookie"] = workspace.headers["Cookie"] if workspace.headers["Cookie"]
+        request.set_form_data(params)
+
+        response = http.request(request)
+        handle_response(response, method)
+      rescue *NETWORK_ERRORS => e
+        raise ApiError, "Network error: #{e.message}"
+      end
+
+      private
+
+      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
+        if cached && cached.started?
+          return cached
+        end
+
+        # 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
+          result = JSON.parse(response.body)
+          raise ApiError, result["error"] || "Unknown error" unless result["ok"]
+
+          result
+        when Net::HTTPUnauthorized
+          raise ApiError, "Invalid token or session expired"
+        when Net::HTTPTooManyRequests
+          raise ApiError, "Rate limited - please wait and try again"
+        else
+          raise ApiError, "HTTP #{response.code}: #{response.message}"
+        end
+      rescue JSON::ParserError
+        raise ApiError, "Invalid JSON response from Slack API"
+      end
+    end
+  end
+end

data/lib/slack_cli/services/cache_store.rb

@@ -0,0 +1,198 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Services
+    class CacheStore
+      attr_accessor :on_warning
+
+      def initialize(paths: nil)
+        @paths = paths || Support::XdgPaths.new
+        @user_cache = {}
+        @channel_cache = {}
+        @subteam_cache = {}
+        @on_warning = nil
+      end
+
+      # User cache methods
+      def get_user(workspace_name, user_id)
+        load_user_cache(workspace_name)
+        @user_cache.dig(workspace_name, user_id)
+      end
+
+      def set_user(workspace_name, user_id, display_name, persist: false)
+        load_user_cache(workspace_name)
+        @user_cache[workspace_name] ||= {}
+        @user_cache[workspace_name][user_id] = display_name
+        save_user_cache(workspace_name) if persist
+      end
+
+      def user_cached?(workspace_name, user_id)
+        load_user_cache(workspace_name)
+        @user_cache.dig(workspace_name, user_id) != nil
+      end
+
+      def save_user_cache(workspace_name)
+        return if @user_cache[workspace_name].nil? || @user_cache[workspace_name].empty?
+
+        @paths.ensure_cache_dir
+        file = user_cache_file(workspace_name)
+        File.write(file, JSON.pretty_generate(@user_cache[workspace_name]))
+      end
+
+      def populate_user_cache(workspace_name, users)
+        @user_cache[workspace_name] = {}
+
+        users.each do |user|
+          @user_cache[workspace_name][user.id] = user.best_name
+        end
+
+        save_user_cache(workspace_name)
+        @user_cache[workspace_name].size
+      end
+
+      def clear_user_cache(workspace_name = nil)
+        if workspace_name
+          @user_cache.delete(workspace_name)
+          file = user_cache_file(workspace_name)
+          File.delete(file) if File.exist?(file)
+        else
+          @user_cache.clear
+          Dir.glob(@paths.cache_file("users-*.json")).each { |f| File.delete(f) }
+        end
+      end
+
+      # Channel cache methods
+      def get_channel_id(workspace_name, channel_name)
+        load_channel_cache(workspace_name)
+        @channel_cache.dig(workspace_name, channel_name)
+      end
+
+      def get_channel_name(workspace_name, channel_id)
+        load_channel_cache(workspace_name)
+        cache = @channel_cache[workspace_name] || {}
+        cache.key(channel_id)
+      end
+
+      def set_channel(workspace_name, channel_name, channel_id)
+        @channel_cache[workspace_name] ||= {}
+        @channel_cache[workspace_name][channel_name] = channel_id
+        save_channel_cache(workspace_name)
+      end
+
+      def clear_channel_cache(workspace_name = nil)
+        if workspace_name
+          @channel_cache.delete(workspace_name)
+          file = channel_cache_file(workspace_name)
+          File.delete(file) if File.exist?(file)
+        else
+          @channel_cache.clear
+          Dir.glob(@paths.cache_file("channels-*.json")).each { |f| File.delete(f) }
+        end
+      end
+
+      # Subteam cache methods
+      def get_subteam(workspace_name, subteam_id)
+        load_subteam_cache(workspace_name)
+        @subteam_cache.dig(workspace_name, subteam_id)
+      end
+
+      def set_subteam(workspace_name, subteam_id, handle)
+        load_subteam_cache(workspace_name)
+        @subteam_cache[workspace_name] ||= {}
+        @subteam_cache[workspace_name][subteam_id] = handle
+        save_subteam_cache(workspace_name)
+      end
+
+      # Cache status
+      def user_cache_size(workspace_name)
+        load_user_cache(workspace_name)
+        @user_cache[workspace_name]&.size || 0
+      end
+
+      def channel_cache_size(workspace_name)
+        load_channel_cache(workspace_name)
+        @channel_cache[workspace_name]&.size || 0
+      end
+
+      def user_cache_file_exists?(workspace_name)
+        File.exist?(user_cache_file(workspace_name))
+      end
+
+      def channel_cache_file_exists?(workspace_name)
+        File.exist?(channel_cache_file(workspace_name))
+      end
+
+      private
+
+      def load_user_cache(workspace_name)
+        return if @user_cache.key?(workspace_name)
+
+        file = user_cache_file(workspace_name)
+        @user_cache[workspace_name] = if File.exist?(file)
+          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] = {}
+      end
+
+      def load_channel_cache(workspace_name)
+        return if @channel_cache.key?(workspace_name)
+
+        file = channel_cache_file(workspace_name)
+        @channel_cache[workspace_name] = if File.exist?(file)
+          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] = {}
+      end
+
+      def save_channel_cache(workspace_name)
+        return if @channel_cache[workspace_name].nil? || @channel_cache[workspace_name].empty?
+
+        @paths.ensure_cache_dir
+        file = channel_cache_file(workspace_name)
+        File.write(file, JSON.pretty_generate(@channel_cache[workspace_name]))
+      end
+
+      def user_cache_file(workspace_name)
+        @paths.cache_file("users-#{workspace_name}.json")
+      end
+
+      def channel_cache_file(workspace_name)
+        @paths.cache_file("channels-#{workspace_name}.json")
+      end
+
+      def load_subteam_cache(workspace_name)
+        return if @subteam_cache.key?(workspace_name)
+
+        file = subteam_cache_file(workspace_name)
+        @subteam_cache[workspace_name] = if File.exist?(file)
+          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] = {}
+      end
+
+      def save_subteam_cache(workspace_name)
+        return if @subteam_cache[workspace_name].nil? || @subteam_cache[workspace_name].empty?
+
+        @paths.ensure_cache_dir
+        file = subteam_cache_file(workspace_name)
+        File.write(file, JSON.pretty_generate(@subteam_cache[workspace_name]))
+      end
+
+      def subteam_cache_file(workspace_name)
+        @paths.cache_file("subteams-#{workspace_name}.json")
+      end
+    end
+  end
+end

data/lib/slack_cli/services/configuration.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Services
+    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
+      end
+
+      def primary_workspace
+        data["primary_workspace"]
+      end
+
+      def primary_workspace=(name)
+        data["primary_workspace"] = name
+        save_config
+      end
+
+      def ssh_key
+        data["ssh_key"]
+      end
+
+      def ssh_key=(path)
+        data["ssh_key"] = path
+        save_config
+      end
+
+      def emoji_dir
+        data["emoji_dir"]
+      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))
+      end
+    end
+  end
+end

data/lib/slack_cli/services/encryption.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module SlackCli
+  module Services
+    class Encryption
+      def available?
+        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?
+
+        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)
+
+        unless status.success?
+          raise EncryptionError, "Failed to encrypt: #{error.strip}"
+        end
+
+        true
+      end
+
+      # Decrypt an age-encrypted file using an SSH key
+      # @param encrypted_file [String] Path to the encrypted file
+      # @param ssh_key_path [String] Path to the SSH private key
+      # @return [String, nil] Decrypted content, or nil if file doesn't exist
+      # @raise [EncryptionError] If age tool not available, key not found, or decryption fails
+      def decrypt(encrypted_file, ssh_key_path)
+        # 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, "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)
+
+        unless status.success?
+          raise EncryptionError, "Failed to decrypt #{encrypted_file}: #{error.strip}"
+        end
+
+        output
+      rescue Errno::ENOENT => e
+        raise EncryptionError, "Decryption failed: #{e.message}"
+      end
+    end
+  end
+end

data/lib/slack_cli/services/preset_store.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Services
+    class PresetStore
+      DEFAULT_PRESETS = {
+        "meeting" => {
+          "text" => "In a meeting",
+          "emoji" => ":calendar:",
+          "duration" => "1h",
+          "presence" => "",
+          "dnd" => ""
+        },
+        "lunch" => {
+          "text" => "Lunch",
+          "emoji" => ":knife_fork_plate:",
+          "duration" => "1h",
+          "presence" => "away",
+          "dnd" => ""
+        },
+        "focus" => {
+          "text" => "Focus time",
+          "emoji" => ":headphones:",
+          "duration" => "2h",
+          "presence" => "",
+          "dnd" => "2h"
+        },
+        "brb" => {
+          "text" => "Be right back",
+          "emoji" => ":brb:",
+          "duration" => "15m",
+          "presence" => "away",
+          "dnd" => ""
+        },
+        "clear" => {
+          "text" => "",
+          "emoji" => "",
+          "duration" => "0",
+          "presence" => "auto",
+          "dnd" => "off"
+        }
+      }.freeze
+
+      attr_accessor :on_warning
+
+      def initialize(paths: nil)
+        @paths = paths || Support::XdgPaths.new
+        @on_warning = nil
+        ensure_default_presets
+      end
+
+      def get(name)
+        data = load_presets[name]
+        return nil unless data
+
+        Models::Preset.from_hash(name, data)
+      end
+
+      def all
+        load_presets.map { |name, data| Models::Preset.from_hash(name, data) }
+      end
+
+      def names
+        load_presets.keys
+      end
+
+      def exists?(name)
+        load_presets.key?(name)
+      end
+
+      def add(preset)
+        presets = load_presets
+        presets[preset.name] = preset.to_h
+        save_presets(presets)
+      end
+
+      def remove(name)
+        presets = load_presets
+        removed = presets.delete(name)
+        save_presets(presets) if removed
+        !removed.nil?
+      end
+
+      private
+
+      def ensure_default_presets
+        return if File.exist?(presets_file)
+
+        @paths.ensure_config_dir
+        save_presets(DEFAULT_PRESETS)
+      end
+
+      def load_presets
+        return {} unless File.exist?(presets_file)
+
+        JSON.parse(File.read(presets_file))
+      rescue JSON::ParserError => e
+        @on_warning&.call("Presets file #{presets_file} is corrupted (#{e.message}). Using defaults.")
+        {}
+      end
+
+      def save_presets(presets)
+        @paths.ensure_config_dir
+        File.write(presets_file, JSON.pretty_generate(presets))
+      end
+
+      def presets_file
+        @paths.config_file("presets.json")
+      end
+    end
+  end
+end

data/lib/slack_cli/services/reaction_enricher.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Services
+    class ReactionEnricher
+      def initialize(activity_api:)
+        @activity_api = activity_api
+      end
+
+      # Enriches messages with reaction timestamps
+      # Returns new array of messages with timestamps added to reactions
+      def enrich_messages(messages, channel_id)
+        return messages if messages.empty?
+
+        # Fetch reaction activity
+        activity_map = fetch_reaction_activity(channel_id, messages.map(&:ts))
+
+        # Enhance messages with timestamps
+        messages.map do |msg|
+          enhanced_reactions = enhance_reactions(msg, activity_map)
+          msg.with_reactions(enhanced_reactions)
+        end
+      end
+
+      private
+
+      def fetch_reaction_activity(channel_id, message_timestamps)
+        # Fetch first page of recent reactions (max 50 per API limit)
+        # Note: This may not cover all historical reactions, but that's acceptable
+        # for performance reasons. Older reactions simply won't have timestamps.
+        response = @activity_api.feed(limit: 50, types: 'message_reaction')
+        return {} unless response['ok']
+
+        # Build map: "channel_id:message_ts:emoji:user" => timestamp
+        activity_map = {}
+        items = response['items'] || []
+
+        items.each do |item|
+          next unless item.dig('item', 'type') == 'message_reaction'
+
+          msg_data = item.dig('item', 'message')
+          reaction_data = item.dig('item', 'reaction')
+          next unless msg_data && reaction_data
+
+          # Only include reactions for messages we care about
+          msg_ts = msg_data['ts']
+          next unless message_timestamps.include?(msg_ts)
+
+          key = [
+            msg_data['channel'],
+            msg_ts,
+            reaction_data['name'],
+            reaction_data['user']
+          ].join(':')
+
+          activity_map[key] = item['feed_ts']
+        end
+
+        activity_map
+      rescue SlackCli::ApiError
+        # If activity API fails, gracefully degrade - return empty map
+        # Messages will still be displayed, just without reaction timestamps
+        {}
+      end
+
+      def enhance_reactions(message, activity_map)
+        return message.reactions if message.reactions.empty?
+
+        message.reactions.map do |reaction|
+          timestamp_map = {}
+
+          reaction.users.each do |user_id|
+            key = [message.channel_id, message.ts, reaction.name, user_id].join(':')
+            timestamp_map[user_id] = activity_map[key] if activity_map[key]
+          end
+
+          # Only create a new reaction with timestamps if we found any
+          if timestamp_map.empty?
+            reaction
+          else
+            reaction.with_timestamps(timestamp_map)
+          end
+        end
+      end
+    end
+  end
+end