slk 0.1.0 → 0.2.0

data/lib/slk/services/gemoji_sync.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Downloads and caches standard emoji database from gemoji
+    class GemojiSync
+      GEMOJI_URL = 'https://raw.githubusercontent.com/github/gemoji/master/db/emoji.json'
+
+      NETWORK_ERRORS = [
+        SocketError,
+        Errno::ECONNREFUSED,
+        Errno::ETIMEDOUT,
+        Net::OpenTimeout,
+        Net::ReadTimeout,
+        URI::InvalidURIError,
+        OpenSSL::SSL::SSLError
+      ].freeze
+
+      def initialize(cache_dir:, on_progress: nil)
+        @cache_dir = cache_dir
+        @on_progress = on_progress
+      end
+
+      # Download and cache standard emoji database
+      # @return [Hash] Result with :success, :count, :path, or :error
+      def sync
+        @on_progress&.call('Downloading standard emoji database...')
+
+        response = fetch_gemoji_data
+        return response if response[:error]
+
+        emoji_map = parse_and_transform(response[:body])
+        return emoji_map if emoji_map[:error]
+
+        save_result = save_to_cache(emoji_map[:data])
+        return save_result if save_result[:error]
+
+        { success: true, count: emoji_map[:data].size, path: emoji_json_path }
+      end
+
+      def emoji_json_path
+        File.join(@cache_dir, 'gemoji.json')
+      end
+
+      private
+
+      def fetch_gemoji_data
+        http = build_http_client(GEMOJI_URL)
+        request = Net::HTTP::Get.new(URI.parse(GEMOJI_URL))
+        response = http.request(request)
+
+        return { error: "Failed to download: HTTP #{response.code}" } unless response.is_a?(Net::HTTPSuccess)
+
+        { body: response.body }
+      rescue *NETWORK_ERRORS => e
+        { error: "Network error: #{e.message}" }
+      end
+
+      def build_http_client(url)
+        uri = URI.parse(url)
+        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
+      end
+
+      def parse_and_transform(body)
+        emoji_data = JSON.parse(body)
+        emoji_map = extract_emoji_aliases(emoji_data)
+        { data: emoji_map }
+      rescue JSON::ParserError => e
+        { error: "Failed to parse emoji data: #{e.message}" }
+      end
+
+      def extract_emoji_aliases(emoji_data)
+        emoji_map = {}
+        emoji_data.each do |emoji|
+          char = emoji['emoji']
+          next unless char
+
+          (emoji['aliases'] || []).each { |name| emoji_map[name] = char }
+        end
+        emoji_map
+      end
+
+      def save_to_cache(emoji_map)
+        FileUtils.mkdir_p(@cache_dir)
+        File.write(emoji_json_path, JSON.pretty_generate(emoji_map))
+        { success: true }
+      rescue SystemCallError => e
+        { error: "File system error: #{e.message}" }
+      end
+    end
+  end
+end

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

@@ -1,43 +1,44 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Services
+    # Manages saved status presets in JSON format
     class PresetStore
       DEFAULT_PRESETS = {
-        "meeting" => {
-          "text" => "In a meeting",
-          "emoji" => ":calendar:",
-          "duration" => "1h",
-          "presence" => "",
-          "dnd" => ""
+        'meeting' => {
+          'text' => 'In a meeting',
+          'emoji' => ':calendar:',
+          'duration' => '1h',
+          'presence' => '',
+          'dnd' => ''
         },
-        "lunch" => {
-          "text" => "Lunch",
-          "emoji" => ":knife_fork_plate:",
-          "duration" => "1h",
-          "presence" => "away",
-          "dnd" => ""
+        'lunch' => {
+          'text' => 'Lunch',
+          'emoji' => ':knife_fork_plate:',
+          'duration' => '1h',
+          'presence' => 'away',
+          'dnd' => ''
         },
-        "focus" => {
-          "text" => "Focus time",
-          "emoji" => ":headphones:",
-          "duration" => "2h",
-          "presence" => "",
-          "dnd" => "2h"
+        'focus' => {
+          'text' => 'Focus time',
+          'emoji' => ':headphones:',
+          'duration' => '2h',
+          'presence' => '',
+          'dnd' => '2h'
         },
-        "brb" => {
-          "text" => "Be right back",
-          "emoji" => ":brb:",
-          "duration" => "15m",
-          "presence" => "away",
-          "dnd" => ""
+        'brb' => {
+          'text' => 'Be right back',
+          'emoji' => ':brb:',
+          'duration' => '15m',
+          'presence' => 'away',
+          'dnd' => ''
         },
-        "clear" => {
-          "text" => "",
-          "emoji" => "",
-          "duration" => "0",
-          "presence" => "auto",
-          "dnd" => "off"
+        'clear' => {
+          'text' => '',
+          'emoji' => '',
+          'duration' => '0',
+          'presence' => 'auto',
+          'dnd' => 'off'
         }
       }.freeze
 
@@ -74,7 +75,7 @@ module SlackCli
         save_presets(presets)
       end
 
-      def remove(name)
+      def remove(name) # rubocop:disable Naming/PredicateMethod
         presets = load_presets
         removed = presets.delete(name)
         save_presets(presets) if removed
@@ -105,7 +106,7 @@ module SlackCli
       end
 
       def presets_file
-        @paths.config_file("presets.json")
+        @paths.config_file('presets.json')
       end
     end
   end

data/lib/slk/services/reaction_enricher.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Adds timestamps to message reactions via activity API
+    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)
+        response = @activity_api.feed(limit: 50, types: 'message_reaction')
+        return {} unless response['ok']
+
+        build_activity_map(response['items'] || [], message_timestamps)
+      rescue Slk::ApiError
+        # If activity API fails, gracefully degrade - return empty map
+        {}
+      end
+
+      def build_activity_map(items, message_timestamps)
+        activity_map = {}
+        items.each do |item|
+          key, timestamp = extract_reaction_key(item, message_timestamps)
+          activity_map[key] = timestamp if key
+        end
+        activity_map
+      end
+
+      def extract_reaction_key(item, message_timestamps)
+        return nil unless item.dig('item', 'type') == 'message_reaction'
+
+        msg_data = item.dig('item', 'message')
+        reaction_data = item.dig('item', 'reaction')
+        return nil unless msg_data && reaction_data
+
+        msg_ts = msg_data['ts']
+        return nil unless message_timestamps.include?(msg_ts)
+
+        key = [msg_data['channel'], msg_ts, reaction_data['name'], reaction_data['user']].join(':')
+        [key, item['feed_ts']]
+      end
+
+      def enhance_reactions(message, activity_map)
+        return message.reactions if message.reactions.empty?
+
+        message.reactions.map { |reaction| enhance_reaction(message, reaction, activity_map) }
+      end
+
+      def enhance_reaction(message, reaction, activity_map)
+        timestamp_map = build_timestamp_map(message, reaction, activity_map)
+        timestamp_map.empty? ? reaction : reaction.with_timestamps(timestamp_map)
+      end
+
+      def build_timestamp_map(message, reaction, activity_map)
+        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
+        timestamp_map
+      end
+    end
+  end
+end

data/lib/slk/services/setup_wizard.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Interactive setup wizard for configuring workspaces
+    class SetupWizard
+      def initialize(runner:, config:, token_store:, output:)
+        @runner = runner
+        @config = config
+        @token_store = token_store
+        @output = output
+      end
+
+      # Run the setup wizard
+      # @return [Integer] exit code (0 for success, 1 for error)
+      def run
+        print_header
+
+        return 0 if skip_if_configured?
+
+        setup_encryption unless @config.ssh_key
+        result = setup_workspace
+        return result if result != 0
+
+        print_success
+        0
+      end
+
+      private
+
+      def print_header
+        @output.puts 'Slack CLI Setup'
+        @output.puts '==============='
+        @output.puts
+      end
+
+      def skip_if_configured?
+        return false unless @runner.workspaces?
+
+        @output.puts 'You already have workspaces configured.'
+        @output.print 'Add another workspace? (y/n): '
+        answer = $stdin.gets&.chomp&.downcase
+        answer != 'y'
+      end
+
+      def setup_encryption
+        print_encryption_header
+        ssh_key = $stdin.gets&.chomp
+        configure_ssh_key(ssh_key) if ssh_key && !ssh_key.empty?
+      end
+
+      def print_encryption_header
+        @output.puts
+        @output.puts 'Encryption Setup (optional)'
+        @output.puts '----------------------------'
+        @output.puts 'You can encrypt your tokens with age using an SSH key.'
+        @output.print 'SSH key path (or press Enter to skip): '
+      end
+
+      def configure_ssh_key(ssh_key)
+        if File.exist?(ssh_key)
+          @config.ssh_key = ssh_key
+          @output.success('SSH key configured')
+        else
+          @output.warn("File not found: #{ssh_key}")
+        end
+      end
+
+      def setup_workspace
+        print_workspace_header
+        name, token = prompt_credentials
+        return 1 unless name && token
+
+        save_workspace(name, token, prompt_cookie_if_needed(token))
+        0
+      end
+
+      def print_workspace_header
+        @output.puts
+        @output.puts 'Workspace Setup'
+        @output.puts '---------------'
+      end
+
+      def prompt_credentials
+        [prompt_workspace_name, prompt_token]
+      end
+
+      def save_workspace(name, token, cookie)
+        @token_store.add(name, token, cookie)
+        @config.primary_workspace = name if @config.primary_workspace.nil?
+      end
+
+      def prompt_workspace_name
+        @output.print 'Workspace name: '
+        name = $stdin.gets&.chomp
+        return name unless name.nil? || name.empty?
+
+        @output.error('Name is required')
+        nil
+      end
+
+      def prompt_token
+        @output.print 'Token (xoxb-... or xoxc-...): '
+        token = $stdin.gets&.chomp
+        return token unless token.nil? || token.empty?
+
+        @output.error('Token is required')
+        nil
+      end
+
+      def prompt_cookie_if_needed(token)
+        return nil unless token.start_with?('xoxc-')
+
+        @output.puts
+        @output.puts 'xoxc tokens require a cookie for authentication.'
+        @output.print 'Cookie (d=...): '
+        $stdin.gets&.chomp
+      end
+
+      def print_success
+        @output.puts
+        @output.success('Setup complete!')
+        @output.puts
+        @output.puts 'Try these commands:'
+        @output.puts '  slack status           - View your status'
+        @output.puts '  slack messages #general - Read channel messages'
+        @output.puts '  slack help             - See all commands'
+      end
+    end
+  end
+end

data/lib/slk/services/target_resolver.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Resolves message targets (channels, DMs, URLs) to channel IDs
+    class TargetResolver
+      Result = Data.define(:workspace, :channel_id, :thread_ts, :msg_ts)
+
+      def initialize(runner:, cache_store:)
+        @runner = runner
+        @cache = cache_store
+      end
+
+      # Resolve a target string to workspace, channel_id, and optional thread/message ts
+      # @param target [String] Channel name, @user, channel ID, or Slack URL
+      # @param default_workspace [Workspace] Workspace to use if not in URL
+      # @return [Result] Resolved target
+      def resolve(target, default_workspace:)
+        url_result = resolve_url(target)
+        return url_result if url_result
+
+        resolve_non_url(target, default_workspace)
+      end
+
+      private
+
+      def resolve_non_url(target, workspace)
+        return build_result(workspace, target) if channel_id?(target)
+        return resolve_dm_target(workspace, target) if target.start_with?('@')
+
+        # Default: treat as channel name (with or without #)
+        resolve_channel_target(workspace, target)
+      end
+
+      def channel_id?(target)
+        target.match?(/^[CDG][A-Z0-9]+$/)
+      end
+
+      def resolve_channel_target(workspace, target)
+        channel_id = resolve_channel(workspace, target.delete_prefix('#'))
+        build_result(workspace, channel_id)
+      end
+
+      def resolve_dm_target(workspace, target)
+        channel_id = resolve_dm(workspace, target.delete_prefix('@'))
+        build_result(workspace, channel_id)
+      end
+
+      def build_result(workspace, channel_id, thread_ts: nil, msg_ts: nil)
+        Result.new(workspace: workspace, channel_id: channel_id, thread_ts: thread_ts, msg_ts: msg_ts)
+      end
+
+      def resolve_url(target)
+        url_parser = Support::SlackUrlParser.new
+        return nil unless url_parser.slack_url?(target)
+
+        result = url_parser.parse(target)
+        return nil unless result
+
+        ws = @runner.workspace(result.workspace)
+        if result.thread?
+          Result.new(workspace: ws, channel_id: result.channel_id, thread_ts: result.thread_ts, msg_ts: nil)
+        else
+          Result.new(workspace: ws, channel_id: result.channel_id, thread_ts: nil, msg_ts: result.msg_ts)
+        end
+      end
+
+      def resolve_channel(workspace, name)
+        cached = @cache.get_channel_id(workspace.name, name)
+        return cached if cached
+
+        fetch_and_cache_channel(workspace, name)
+      end
+
+      def fetch_and_cache_channel(workspace, name)
+        channels = @runner.conversations_api(workspace.name).list['channels'] || []
+        channel = channels.find { |c| c['name'] == name }
+        raise ConfigError, "Channel not found: ##{name}" unless channel
+
+        @cache.set_channel(workspace.name, name, channel['id'])
+        channel['id']
+      end
+
+      def resolve_dm(workspace, username)
+        user_id = find_user_id(workspace, username)
+        raise ConfigError, "User not found: @#{username}" unless user_id
+
+        api = @runner.conversations_api(workspace.name)
+        response = api.open(users: user_id)
+        response.dig('channel', 'id')
+      end
+
+      def find_user_id(workspace, username)
+        api = @runner.users_api(workspace.name)
+        response = api.list
+        users = response['members'] || []
+
+        user = users.find do |u|
+          u['name'] == username ||
+            u.dig('profile', 'display_name') == username ||
+            u.dig('profile', 'real_name') == username
+        end
+
+        user&.dig('id')
+      end
+    end
+  end
+end

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

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Services
+    # Manages workspace tokens with optional encryption
     class TokenStore
       attr_accessor :on_warning
 
@@ -19,8 +20,8 @@ module SlackCli
 
         Models::Workspace.new(
           name: name,
-          token: data["token"],
-          cookie: data["cookie"]
+          token: data['token'],
+          cookie: data['cookie']
         )
       end
 
@@ -28,8 +29,8 @@ module SlackCli
         load_tokens.map do |name, data|
           Models::Workspace.new(
             name: name,
-            token: data["token"],
-            cookie: data["cookie"]
+            token: data['token'],
+            cookie: data['cookie']
           )
         end
       end
@@ -47,11 +48,11 @@ module SlackCli
         Models::Workspace.new(name: name, token: token, cookie: cookie)
 
         tokens = load_tokens
-        tokens[name] = { "token" => token, "cookie" => cookie }.compact
+        tokens[name] = { 'token' => token, 'cookie' => cookie }.compact
         save_tokens(tokens)
       end
 
-      def remove(name)
+      def remove(name) # rubocop:disable Naming/PredicateMethod
         tokens = load_tokens
         removed = tokens.delete(name)
         save_tokens(tokens) if removed
@@ -82,7 +83,7 @@ module SlackCli
         if @config.ssh_key
           # When encryption is configured, always use it - don't silently fall back
           @encryption.encrypt(JSON.generate(tokens), @config.ssh_key, encrypted_tokens_file)
-          File.delete(plain_tokens_file) if File.exist?(plain_tokens_file)
+          FileUtils.rm_f(plain_tokens_file)
         else
           # Plain text storage (no encryption configured)
           File.write(plain_tokens_file, JSON.pretty_generate(tokens))
@@ -106,11 +107,11 @@ module SlackCli
       end
 
       def encrypted_tokens_file
-        @paths.config_file("tokens.age")
+        @paths.config_file('tokens.age')
       end
 
       def plain_tokens_file
-        @paths.config_file("tokens.json")
+        @paths.config_file('tokens.json')
       end
     end
   end

data/lib/slk/services/unread_marker.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Handles batch marking of unreads as read
+    class UnreadMarker
+      def initialize(conversations_api:, threads_api:, client_api:, users_api:, on_debug: nil)
+        @conversations = conversations_api
+        @threads = threads_api
+        @client = client_api
+        @users = users_api
+        @on_debug = on_debug
+      end
+
+      # Mark all unreads in a workspace, return counts
+      # @param options [Hash] :muted - include muted channels
+      # @return [Hash] { dms: count, channels: count, threads: count }
+      def mark_all(options: {})
+        counts = @client.counts
+
+        {
+          dms: mark_dms(counts['ims'] || []),
+          channels: mark_channels(counts['channels'] || [], muted: options[:muted]),
+          threads: mark_threads
+        }
+      end
+
+      # Mark a single channel as read
+      # @param channel_id [String] Channel ID
+      # @return [Boolean] true if marked successfully
+      def mark_single_channel(channel_id)
+        mark_conversation(channel_id)
+      end
+
+      private
+
+      def mark_dms(ims)
+        count = 0
+        ims.each do |im|
+          next unless im['has_unreads']
+
+          count += 1 if mark_conversation(im['id'])
+        end
+        count
+      end
+
+      def mark_channels(channels, muted: false)
+        muted_ids = muted ? [] : @users.muted_channels
+        count = 0
+
+        channels.each do |channel|
+          next unless channel['has_unreads']
+          next if !muted && muted_ids.include?(channel['id'])
+
+          count += 1 if mark_conversation(channel['id'])
+        end
+        count
+      end
+
+      def mark_conversation(channel_id)
+        history = @conversations.history(channel: channel_id, limit: 1)
+        messages = history['messages']
+        return false unless messages&.any?
+
+        @conversations.mark(channel: channel_id, timestamp: messages.first['ts'])
+        true
+      rescue ApiError => e
+        @on_debug&.call("Could not mark #{channel_id}: #{e.message}")
+        false
+      end
+
+      def mark_threads
+        response = @threads.get_view(limit: 50)
+        return 0 unless response['ok']
+
+        count = 0
+        (response['threads'] || []).each do |thread|
+          count += 1 if mark_thread(thread)
+        end
+        count
+      end
+
+      def mark_thread(thread)
+        unread_replies = thread['unread_replies'] || []
+        return false if unread_replies.empty?
+
+        call_mark_thread(thread, unread_replies)
+      end
+
+      def call_mark_thread(thread, unread_replies)
+        root_msg = thread['root_msg'] || {}
+        @threads.mark(channel: root_msg['channel'], thread_ts: root_msg['thread_ts'],
+                      timestamp: unread_replies.map { |r| r['ts'] }.max)
+        true
+      rescue ApiError => e
+        @on_debug&.call("Could not mark thread #{root_msg['thread_ts']} in #{root_msg['channel']}: #{e.message}")
+        false
+      end
+    end
+  end
+end

data/lib/{slack_cli → slk}/support/error_logger.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Support
+    # Logs errors to a file for debugging
     module ErrorLogger
       # Log an error to the error log file
       # @param error [Exception] The error to log