slk 0.2.0 → 0.4.0

data/lib/slk/commands/config.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-require_relative '../support/help_formatter'
+require_relative 'ssh_key_manager'
 
 module Slk
   module Commands
@@ -21,94 +21,97 @@ module Slk
         in ['setup'] | [_] then run_setup
         in ['get', key] then get_value(key)
         in ['set', key, value] then set_value(key, value)
+        in ['unset', key] then unset_value(key)
         end
       end
 
       protected
 
       def help_text
-        help = Support::HelpFormatter.new('slk config [action]')
-        help.description('Manage configuration.')
-        add_actions_section(help)
-        add_keys_section(help)
-        add_options_section(help)
-        help.render
+        Support::HelpFormatter.new('slk config [action]').tap do |h|
+          h.description('Manage configuration.')
+          h.section('ACTIONS') { |s| add_actions(s) }
+          h.section('CONFIG KEYS') { |s| add_keys(s) }
+          h.section('OPTIONS') { |s| s.option('-q, --quiet', 'Suppress output') }
+        end.render
       end
 
-      def add_actions_section(help)
-        help.section('ACTIONS') do |s|
-          s.action('show', 'Show current configuration')
-          s.action('setup', 'Run setup wizard')
-          s.action('get <key>', 'Get a config value')
-          s.action('set <key> <val>', 'Set a config value')
-        end
+      def add_actions(section)
+        section.action('show', 'Show current configuration')
+        section.action('setup', 'Run setup wizard')
+        section.action('get <key>', 'Get a config value')
+        section.action('set <key> <val>', 'Set a config value')
+        section.action('unset <key>', 'Remove a config value')
       end
 
-      def add_keys_section(help)
-        help.section('CONFIG KEYS') do |s|
-          s.item('primary_workspace', 'Default workspace name')
-          s.item('ssh_key', 'Path to SSH key for encryption')
-          s.item('emoji_dir', 'Custom emoji directory')
-        end
-      end
-
-      def add_options_section(help)
-        help.section('OPTIONS') do |s|
-          s.option('-q, --quiet', 'Suppress output')
-        end
+      def add_keys(section)
+        section.item('primary_workspace', 'Default workspace name')
+        section.item('ssh_key', 'Path to SSH key for encryption')
+        section.item('emoji_dir', 'Custom emoji directory')
       end
 
       private
 
       def show_config
-        display_config_values
-        display_workspace_info
-        display_paths
+        print_config_values
+        print_paths
         0
       end
 
-      def display_config_values
+      def print_config_values
         puts 'Configuration:'
         puts "  Primary workspace: #{config.primary_workspace || '(not set)'}"
         puts "  SSH key: #{config.ssh_key || '(not set)'}"
         puts "  Emoji dir: #{config.emoji_dir || '(default)'}"
-      end
-
-      def display_workspace_info
         puts
         puts "Workspaces: #{runner.workspace_names.join(', ')}"
       end
 
-      def display_paths
-        puts
+      def print_paths
         paths = Support::XdgPaths.new
+        puts
         puts "Config dir: #{paths.config_dir}"
         puts "Cache dir: #{paths.cache_dir}"
       end
 
       def run_setup
-        wizard = Services::SetupWizard.new(
-          runner: runner,
-          config: config,
-          token_store: token_store,
-          output: output
-        )
-        wizard.run
+        Services::SetupWizard.new(runner: runner, config: config, token_store: token_store, output: output).run
       end
 
       def get_value(key)
-        value = config[key]
-        puts value || '(not set)'
-
+        puts config[key] || '(not set)'
         0
       end
 
       def set_value(key, value)
+        return handle_ssh_key_result(ssh_key_manager.set(value)) if key == 'ssh_key'
+
         config[key] = value
         success("Set #{key} = #{value}")
+        0
+      end
 
+      def unset_value(key)
+        return handle_ssh_key_result(ssh_key_manager.unset) if key == 'ssh_key'
+
+        config[key] = nil
+        success("Unset #{key}")
         0
       end
+
+      def ssh_key_manager
+        @ssh_key_manager ||= SshKeyManager.new(config: config, token_store: token_store, output: output).tap do |mgr|
+          mgr.on_info = ->(msg) { success(msg) }
+          mgr.on_warning = ->(msg) { warn(msg) }
+        end
+      end
+
+      def handle_ssh_key_result(result)
+        return success(result[:message]) || 0 if result[:success]
+
+        error(result[:error])
+        1
+      end
     end
   end
 end

data/lib/slk/commands/help.rb

@@ -43,6 +43,7 @@ module Slk
             #{output.cyan('presence')}     Get or set your presence (away/active)
             #{output.cyan('dnd')}          Manage Do Not Disturb
             #{output.cyan('messages')}     Read channel or DM messages
+            #{output.cyan('search')}       Search messages across channels
             #{output.cyan('unread')}       View and clear unread messages
             #{output.cyan('preset')}       Manage and apply status presets
             #{output.cyan('workspaces')}   Manage Slack workspaces

data/lib/slk/commands/messages.rb

@@ -10,6 +10,7 @@ module Slk
     class Messages < Base
       include Support::InlineImages
 
+      # rubocop:disable Metrics/MethodLength
       def execute
         result = validate_options
         return result if result
@@ -22,7 +23,11 @@ module Slk
       rescue ApiError => e
         error("Failed to fetch messages: #{e.message}")
         1
+      rescue ArgumentError => e
+        error(e.message)
+        1
       end
+      # rubocop:enable Metrics/MethodLength
 
       def missing_target_error
         error('Usage: slk messages <channel|@user|url>')
@@ -53,19 +58,28 @@ module Slk
           limit: 500,
           limit_set: false,
           threads: false,
-          workspace_emoji: false
+          workspace_emoji: false,
+          since: nil
         )
       end
 
       def handle_option(arg, args, remaining)
         case arg
         when '-n', '--limit' then handle_limit_option(args)
+        when '--since' then handle_since_option(args)
         when '--threads' then @options[:threads] = true
         when '--workspace-emoji' then @options[:workspace_emoji] = true
         else super
         end
       end
 
+      def handle_since_option(args)
+        value = args.shift
+        raise ArgumentError, '--since requires a duration (1d, 7d, 1w, 1m) or date (YYYY-MM-DD)' unless value
+
+        @options[:since] = value
+      end
+
       def handle_limit_option(args)
         @options[:limit] = args.shift.to_i
         @options[:limit_set] = true
@@ -99,6 +113,7 @@ module Slk
 
       def add_message_options(section)
         section.option('-n, --limit N', 'Number of messages (default: 500, or 50 for message URLs)')
+        section.option('--since DURATION', 'Messages since duration (1d, 7d, 1w, 1m) or date (YYYY-MM-DD)')
         section.option('--threads', 'Show thread replies inline')
         section.option('--workspace-emoji', 'Show workspace emoji as inline images (experimental)')
       end
@@ -132,14 +147,37 @@ module Slk
       end
 
       def output_json_messages(messages, workspace, channel_id)
-        format_options = {
-          no_names: @options[:no_names],
-          reaction_timestamps: @options[:reaction_timestamps],
-          channel_id: channel_id
-        }
-        output_json(messages.map do |m|
-          runner.message_formatter.format_json(m, workspace: workspace, options: format_options)
-        end)
+        format_options = json_format_options(channel_id)
+
+        json_messages = messages.map do |message|
+          format_message_as_json(message, workspace, channel_id, format_options)
+        end
+
+        output_json(json_messages)
+      end
+
+      def json_format_options(channel_id)
+        { no_names: @options[:no_names], reaction_timestamps: @options[:reaction_timestamps], channel_id: channel_id }
+      end
+
+      def format_message_as_json(message, workspace, channel_id, format_options)
+        result = runner.message_formatter.format_json(message, workspace: workspace, options: format_options)
+        if should_show_thread?(message)
+          result[:replies] =
+            fetch_thread_replies_json(workspace, channel_id, message, format_options)
+        end
+        result
+      end
+
+      def fetch_thread_replies_json(workspace, channel_id, parent_message, format_options)
+        api = runner.conversations_api(workspace.name)
+        replies = fetch_all_thread_replies(api, channel_id, parent_message.ts)
+
+        # Skip parent (first element), format each reply as JSON
+        replies[1..].map do |reply_data|
+          reply = Models::Message.from_api(reply_data, channel_id: channel_id)
+          runner.message_formatter.format_json(reply, workspace: workspace, options: format_options)
+        end
       end
 
       # Apply default limit based on target type (50 for message URLs, 500 otherwise)
@@ -172,11 +210,21 @@ module Slk
       end
 
       def fetch_channel_history(api, channel_id, oldest)
-        oldest_adjusted = oldest ? adjust_timestamp(oldest, -0.000001) : nil
-        response = api.history(channel: channel_id, limit: @options[:limit], oldest: oldest_adjusted)
+        oldest_ts = determine_oldest_timestamp(oldest)
+        response = api.history(channel: channel_id, limit: @options[:limit], oldest: oldest_ts)
         response['messages'] || []
       end
 
+      def determine_oldest_timestamp(oldest_from_url)
+        # URL-based oldest takes precedence
+        return adjust_timestamp(oldest_from_url, -0.000001) if oldest_from_url
+
+        # Otherwise use --since if provided
+        return Support::DateParser.to_slack_timestamp(@options[:since]) if @options[:since]
+
+        nil
+      end
+
       # Adjust a Slack timestamp by a small amount while preserving precision
       def adjust_timestamp(timestamp, delta)
         require 'bigdecimal'

data/lib/slk/commands/search.rb

@@ -0,0 +1,223 @@
+# frozen_string_literal: true
+
+require_relative '../support/help_formatter'
+
+module Slk
+  module Commands
+    # Searches messages across channels and DMs
+    # Note: Requires user tokens (xoxc/xoxs), NOT bot tokens (xoxb)
+    # rubocop:disable Metrics/ClassLength
+    class Search < Base
+      def execute
+        result = validate_options
+        return result if result
+
+        query = positional_args.first
+        return missing_query_error unless query
+
+        search_and_display(query)
+      rescue ApiError => e
+        handle_api_error(e)
+      rescue ArgumentError => e
+        error(e.message)
+        1
+      end
+
+      protected
+
+      def default_options
+        super.merge(
+          limit: 20,
+          page: 1,
+          in_channel: nil,
+          from_user: nil,
+          after_date: nil,
+          before_date: nil,
+          on_date: nil,
+          threads: false
+        )
+      end
+
+      # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+      def handle_option(arg, args, remaining)
+        case arg
+        when '-n', '--limit' then @options[:limit] = require_value(arg, args).to_i
+        when '--page' then @options[:page] = require_value(arg, args).to_i
+        when '--in' then @options[:in_channel] = require_value(arg, args)
+        when '--from' then @options[:from_user] = require_value(arg, args)
+        when '--after' then @options[:after_date] = require_value(arg, args)
+        when '--before' then @options[:before_date] = require_value(arg, args)
+        when '--on' then @options[:on_date] = require_value(arg, args)
+        when '--threads' then @options[:threads] = true
+        else super
+        end
+      end
+      # rubocop:enable Metrics/MethodLength, Metrics/CyclomaticComplexity, Metrics/AbcSize
+
+      def require_value(option, args)
+        value = args.shift
+        raise ArgumentError, "#{option} requires a value" unless value
+
+        value
+      end
+
+      def help_text
+        help = Support::HelpFormatter.new('slk search <query> [options]')
+        help.description('Search messages across channels and DMs.')
+        help.note('Requires user token (xoxc/xoxs), not bot tokens.')
+        add_filter_section(help)
+        add_options_section(help)
+        help.render
+      end
+
+      private
+
+      def add_filter_section(help)
+        help.section('FILTERS') do |s|
+          s.option('--in #channel', 'Search in specific channel')
+          s.option('--from @user', 'Messages from specific user')
+          s.option('--after YYYY-MM-DD', 'Messages after date')
+          s.option('--before YYYY-MM-DD', 'Messages before date')
+          s.option('--on YYYY-MM-DD', 'Messages on specific date')
+        end
+      end
+
+      def add_options_section(help)
+        help.section('OPTIONS') do |s|
+          s.option('-n, --limit N', 'Number of results (default: 20, max: 100)')
+          s.option('--page N', 'Page number for pagination')
+          s.option('--threads', 'Show thread replies inline')
+          s.option('--json', 'Output as JSON')
+          s.option('-w, --workspace', 'Specify workspace')
+          s.option('-v, --verbose', 'Show debug information')
+          s.option('-q, --quiet', 'Suppress output')
+        end
+      end
+
+      def missing_query_error
+        error('Usage: slk search <query> [options]')
+        error('Example: slk search "deployment error" --in #engineering')
+        1
+      end
+
+      def handle_api_error(err)
+        if err.message.include?('not_allowed_token_type')
+          error('Search requires a user token (xoxc/xoxs), not a bot token.')
+          error('Re-run `slk config` to set up with a user token.')
+        else
+          error("Search failed: #{err.message}")
+        end
+        1
+      end
+
+      # rubocop:disable Metrics/MethodLength
+      def search_and_display(query)
+        workspace = target_workspaces.first
+        full_query = build_query(query)
+
+        debug("Searching: #{full_query}")
+        response = runner.search_api(workspace.name).messages(
+          query: full_query,
+          count: @options[:limit],
+          page: @options[:page]
+        )
+
+        results = parse_results(response)
+        display_results(results, workspace, response)
+        0
+      end
+      # rubocop:enable Metrics/MethodLength
+
+      def build_query(base_query)
+        parts = [base_query]
+        parts << "in:#{@options[:in_channel]}" if @options[:in_channel]
+        parts << "from:#{@options[:from_user]}" if @options[:from_user]
+        parts << "after:#{@options[:after_date]}" if @options[:after_date]
+        parts << "before:#{@options[:before_date]}" if @options[:before_date]
+        parts << "on:#{@options[:on_date]}" if @options[:on_date]
+        parts.join(' ')
+      end
+
+      def parse_results(response)
+        matches = response.dig('messages', 'matches') || []
+        matches.map { |m| Models::SearchResult.from_api(m) }
+      end
+
+      def display_results(results, workspace, response)
+        if @options[:json]
+          output_json_results(results, response)
+        else
+          display_text_results(results, workspace, response)
+        end
+      end
+
+      def output_json_results(results, response)
+        pagination = response.dig('messages', 'pagination') || {}
+        output_json({
+                      results: results.map(&:to_h),
+                      pagination: {
+                        page: pagination['page'],
+                        page_count: pagination['page_count'],
+                        total_count: pagination['total_count']
+                      }
+                    })
+      end
+
+      def display_text_results(results, workspace, response)
+        show_pagination_info(response) if @options[:verbose]
+
+        if results.empty?
+          puts 'No results found.'
+          return
+        end
+
+        results.each_with_index do |result, index|
+          display_single_result(result, workspace)
+          puts if index < results.length - 1
+        end
+      end
+
+      def display_single_result(result, workspace)
+        runner.search_formatter.display_result(result, workspace, format_options)
+        show_thread_replies(result, workspace) if should_show_thread?(result)
+      end
+
+      def should_show_thread?(result)
+        @options[:threads] && result.thread_ts == result.ts
+      end
+
+      def show_thread_replies(result, workspace)
+        api = runner.conversations_api(workspace.name)
+        replies = fetch_thread_replies(api, result.channel_id, result.ts)
+
+        replies[1..].each { |reply| display_thread_reply(reply, workspace, result.channel_id) }
+      rescue ApiError => e
+        debug("Failed to fetch thread replies for #{result.ts}: #{e.message}")
+      end
+
+      def fetch_thread_replies(api, channel_id, thread_ts)
+        response = api.replies(channel: channel_id, timestamp: thread_ts, limit: 100)
+        response['messages'] || []
+      end
+
+      def display_thread_reply(reply_data, workspace, channel_id)
+        message = Models::Message.from_api(reply_data, channel_id: channel_id)
+        formatted = runner.message_formatter.format(message, workspace: workspace, options: format_options)
+
+        lines = formatted.lines
+        puts "  └ #{lines.first}"
+        lines[1..].each { |line| puts "    #{line}" }
+      end
+
+      def show_pagination_info(response)
+        pagination = response.dig('messages', 'pagination') || {}
+        total = pagination['total_count'] || 0
+        page = pagination['page'] || 1
+        page_count = pagination['page_count'] || 1
+
+        debug("Page #{page}/#{page_count} (#{total} total results)")
+      end
+    end
+    # rubocop:enable Metrics/ClassLength
+  end
+end

data/lib/slk/commands/ssh_key_manager.rb

@@ -0,0 +1,129 @@
+# frozen_string_literal: true
+
+module Slk
+  module Commands
+    # Handles SSH key configuration and token migration.
+    # When the SSH key is changed, existing tokens are decrypted with the old key
+    # and re-encrypted with the new key. Supports prompting for public key location
+    # if not found at the default path (private_key.pub).
+    class SshKeyManager
+      # File system errors mapped to user-friendly messages.
+      # These occur during SSH key file operations (reading keys, migrating tokens).
+      FILE_ERRORS = {
+        Errno::ENOENT => 'File not found',
+        Errno::EACCES => 'Permission denied',
+        Errno::EPERM => 'Permission denied',
+        Errno::ENOSPC => 'Disk full',
+        Errno::EDQUOT => 'Disk quota exceeded',
+        Errno::EROFS => 'Read-only file system'
+      }.freeze
+
+      attr_accessor :on_info, :on_warning
+
+      def initialize(config:, token_store:, output:)
+        @config = config
+        @token_store = token_store
+        @output = output
+      end
+
+      def set(new_path)
+        with_error_handling { perform_set(new_path) }
+      end
+
+      def unset
+        with_error_handling { perform_unset }
+      end
+
+      private
+
+      def perform_set(new_path)
+        new_path = normalize_path(new_path)
+        return error('Please provide the private key path, not the public key (.pub)') if pub_key?(new_path)
+
+        migrate_tokens(@config.ssh_key, new_path)
+        @config['ssh_key'] = new_path
+        success_message(new_path)
+      end
+
+      def perform_unset
+        old_path = resolve_old_path
+        migrate_tokens(old_path, nil)
+        @config['ssh_key'] = nil
+        success('Cleared ssh_key')
+      end
+
+      def with_error_handling
+        yield
+      rescue EncryptionError => e
+        error(e.message)
+      rescue ArgumentError => e
+        error("Invalid path: #{e.message}")
+      rescue *FILE_ERRORS.keys => e
+        error("#{FILE_ERRORS[e.class]}: #{e.message}")
+      end
+
+      def normalize_path(path)
+        path == '' ? nil : File.expand_path(path)
+      end
+
+      def pub_key?(path)
+        path&.end_with?('.pub')
+      end
+
+      def resolve_old_path
+        old_path = @config.ssh_key
+        old_path = nil if old_path.to_s.empty?
+
+        return old_path if old_path || !encrypted_tokens_exist?
+
+        prompt_for_key_path
+      end
+
+      def prompt_for_key_path
+        @output.puts 'Encrypted tokens exist but no ssh_key is configured.'
+        @output.print 'Enter path to SSH key for decryption: '
+        path = $stdin.gets&.chomp
+
+        if path.nil? || path.empty?
+          raise EncryptionError, 'SSH key path required to decrypt existing tokens. Operation cancelled.'
+        end
+
+        File.expand_path(path)
+      end
+
+      def encrypted_tokens_exist?
+        paths = Support::XdgPaths.new
+        File.exist?(paths.config_file('tokens.age'))
+      end
+
+      def migrate_tokens(old_path, new_path)
+        @token_store.on_info = ->(msg) { @on_info&.call(msg) }
+        @token_store.on_warning = ->(msg) { @on_warning&.call(msg) }
+        @token_store.on_prompt_pub_key = method(:prompt_for_pub_key)
+        @token_store.migrate_encryption(old_path, new_path)
+      end
+
+      def prompt_for_pub_key(private_key_path)
+        @output.puts "Public key not found at #{private_key_path}.pub"
+        @output.print 'Enter path to public key (or press Enter to cancel): '
+        path = $stdin.gets&.chomp
+        return nil if path.nil? || path.empty?
+
+        File.expand_path(path)
+      end
+
+      def success_message(new_path)
+        message = new_path ? "Set ssh_key = #{new_path}" : 'Cleared ssh_key'
+        success(message)
+      end
+
+      def success(message)
+        { success: true, message: message }
+      end
+
+      def error(message)
+        { success: false, error: message }
+      end
+    end
+  end
+end

data/lib/slk/formatters/attachment_formatter.rb

@@ -18,16 +18,30 @@ module Slk
 
       private
 
+      # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
       def format_attachment(attachment, lines, options)
         att_text = attachment['text'] || attachment['fallback']
         image_url = attachment['image_url'] || attachment['thumb_url']
+        block_images = extract_block_images(attachment)
 
-        return unless att_text || image_url
+        return unless att_text || image_url || block_images.any?
 
         lines << ''
         format_author(attachment, lines)
-        format_text(att_text, lines, options) if att_text
+        format_text(att_text, lines, options) if att_text && block_images.empty?
         format_image(attachment, image_url, lines) if image_url
+        block_images.each { |img| lines << "> [Image: #{img}]" }
+      end
+      # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+
+      def extract_block_images(attachment)
+        return [] unless attachment['blocks']
+
+        attachment['blocks'].filter_map do |block|
+          next unless block['type'] == 'image'
+
+          block.dig('title', 'text') || 'Image'
+        end
       end
 
       def format_author(attachment, lines)