slk 0.4.2 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f36dfb6d59a99e348d4bd14d49eea6b3c77c9a7d077a59adc769529eee94a24
-  data.tar.gz: f91ab312427b50df2b0938c8112d9057ab66b78f82eff31857a70b2e1b056a23
+  metadata.gz: 54edc7e40c9bcf891e2d2727c4cf50c4f43de73a70051465da12f3a97bc5282b
+  data.tar.gz: 40bbb5862b982c4e0d87d2a47c18b91a2f0070cac9fe7ad15a68e109114bf977
 SHA512:
-  metadata.gz: 7e8e1ce4a53ead893a1c2275cac500aea5e3b78b46caeee31d8343e33e3598df27a4518fcb1d1322a4780b3b17b8472b2fdd319d740f0d918282a133a010f9d7
-  data.tar.gz: 93d461ceacd6924ecf0b2758609f492a8d16e0919dc8288babbe0717416722e230dfbd991c3e119850c528463831636154fe3259197d8af5b4671b2ac3f53bd8
+  metadata.gz: 96abfcac2a271dccbce0a7b8068d23cf70d62ff68466e2a915fd67474aa9a3b6f648dce14ebaa87718c069993886a309c86490ab865a060586789bf8f8775752
+  data.tar.gz: ece446478a9dfda1dec3fa5dad6feff79c5f7be24e89f9835d61a0f3684e3d7839a94c673859ac5678a1f0f0c8675d31a9673493e744efcdd67433acda1f8fda

data/lib/slk/commands/base.rb

@@ -32,7 +32,8 @@ module Slk
       end
 
       def base_options
-        { workspace: nil, all: false, verbose: false, quiet: false, json: false, markdown: false, width: default_width }
+        { workspace: nil, all: false, verbose: false, quiet: false, json: false, markdown: false,
+          width: default_width, fetch_attachments: false }
       end
 
       def formatting_options
@@ -79,6 +80,7 @@ module Slk
         when '--no-names' then @options[:no_names] = true
         when '--reaction-names' then @options[:reaction_names] = true
         when '--reaction-timestamps' then @options[:reaction_timestamps] = true
+        when '--fetch-attachments' then @options[:fetch_attachments] = true
         else handle_option(arg, args, remaining)
         end
       end
@@ -194,7 +196,8 @@ module Slk
           no_names: @options[:no_names],
           reaction_names: @options[:reaction_names],
           reaction_timestamps: @options[:reaction_timestamps],
-          width: @options[:width]
+          width: @options[:width],
+          fetch_attachments: @options[:fetch_attachments]
         }
       end
     end

data/lib/slk/commands/messages.rb

@@ -124,6 +124,7 @@ module Slk
         section.option('--no-names', 'Skip user name lookups (faster)')
         section.option('--reaction-names', 'Show reactions with user names')
         section.option('--reaction-timestamps', 'Show when each person reacted')
+        section.option('--fetch-attachments', 'Download files/images to local cache (~/.cache/slk/files/)')
         section.option('--width N', 'Wrap text at N columns (default: 72 on TTY, no wrap otherwise)')
         section.option('--no-wrap', 'Disable text wrapping')
       end
@@ -258,15 +259,22 @@ module Slk
       end
 
       def display_messages(messages, workspace, channel_id)
-        formatter = runner.message_formatter
-        opts = format_options.merge(channel_id: channel_id)
+        opts = build_display_options(messages, workspace, channel_id)
 
         messages.each_with_index do |message, index|
-          display_single_message(formatter, message, workspace, opts)
+          display_single_message(runner.message_formatter, message, workspace, opts)
           puts if index < messages.length - 1
 
           show_thread_replies(workspace, channel_id, message, opts) if should_show_thread?(message)
         end
+
+        print_file_summary(messages) unless opts[:fetch_attachments]
+      end
+
+      def build_display_options(messages, workspace, channel_id)
+        opts = format_options.merge(channel_id: channel_id)
+        opts[:file_paths] = fetch_attachment_files(messages, workspace) if opts[:fetch_attachments]
+        opts
       end
 
       def should_show_thread?(message)
@@ -281,12 +289,20 @@ module Slk
       def show_thread_replies(workspace, channel_id, parent_message, opts)
         api = runner.conversations_api(workspace.name)
         replies = fetch_all_thread_replies(api, channel_id, parent_message.ts)
+        reply_messages = replies[1..].map { |r| Models::Message.from_api(r, channel_id: channel_id) }
 
-        replies[1..].each { |reply_data| display_thread_reply(reply_data, workspace, channel_id, opts) }
+        download_reply_files(reply_messages, workspace, opts)
+        reply_messages.each { |reply| display_thread_reply_message(reply, workspace, opts) }
       end
 
-      def display_thread_reply(reply_data, workspace, channel_id, opts)
-        reply = Models::Message.from_api(reply_data, channel_id: channel_id)
+      def download_reply_files(replies, workspace, opts)
+        return unless opts[:fetch_attachments]
+
+        new_paths = fetch_attachment_files(replies, workspace)
+        opts[:file_paths].merge!(new_paths)
+      end
+
+      def display_thread_reply_message(reply, workspace, opts)
         formatted = runner.message_formatter.format(reply, workspace: workspace, options: opts)
 
         lines = formatted.lines
@@ -331,6 +347,28 @@ module Slk
         end
       end
 
+      def print_file_summary(messages)
+        file_count = messages.sum { |m| m.files.size + downloadable_attachment_count(m) }
+        return if file_count.zero?
+
+        label = file_count == 1 ? '1 file' : "#{file_count} files"
+        puts
+        info("#{label} not downloaded. Use --fetch-attachments to download.")
+      end
+
+      def downloadable_attachment_count(message)
+        message.attachments.count { |a| a['image_url'] || a['thumb_url'] }
+      end
+
+      def fetch_attachment_files(messages, workspace)
+        paths = Support::XdgPaths.new
+        downloader = Services::FileDownloader.new(
+          cache_dir: paths.cache_dir,
+          on_debug: ->(msg) { debug(msg) }
+        )
+        downloader.download_message_files(messages, workspace)
+      end
+
       def find_workspace_emoji(workspace_name, emoji_name)
         return nil if emoji_name.empty?
 

data/lib/slk/commands/thread.rb

@@ -10,6 +10,16 @@ module Slk
         result = validate_options
         return result if result
 
+        resolve_and_display_thread
+      rescue ApiError => e
+        error("Failed to fetch messages: #{e.message}")
+        1
+      rescue ArgumentError => e
+        error(e.message)
+        1
+      end
+
+      def resolve_and_display_thread
         target = positional_args.first
         return usage_error unless target
 
@@ -18,12 +28,6 @@ module Slk
 
         resolved = target_resolver.resolve(target, default_workspace: target_workspaces.first)
         fetch_and_display_messages(resolved)
-      rescue ApiError => e
-        error("Failed to fetch messages: #{e.message}")
-        1
-      rescue ArgumentError => e
-        error(e.message)
-        1
       end
 
       def fetch_and_display_messages(resolved)
@@ -75,6 +79,7 @@ module Slk
           s.option('--no-emoji', 'Show :emoji: codes instead of unicode')
           s.option('--no-reactions', 'Hide reactions')
           s.option('--no-names', 'Skip user name lookups (faster)')
+          s.option('--fetch-attachments', 'Download files/images to local cache (~/.cache/slk/files/)')
           s.option('--json', 'Output as JSON')
           s.option('-v, --verbose', 'Show debug information')
         end

data/lib/slk/formatters/attachment_formatter.rb

@@ -9,17 +9,19 @@ module Slk
         @text_processor = text_processor
       end
 
-      def format(attachments, lines, options)
+      def format(attachments, lines, options, message_ts: nil)
         return if attachments.empty?
         return if options[:no_attachments]
 
-        attachments.each { |att| format_attachment(att, lines, options) }
+        attachments.each_with_index do |att, idx|
+          format_attachment(att, lines, options, message_ts: message_ts, index: idx)
+        end
       end
 
       private
 
       # rubocop:disable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      def format_attachment(attachment, lines, options)
+      def format_attachment(attachment, lines, options, message_ts: nil, index: 0)
         att_text = attachment['text'] || attachment['fallback']
         image_url = attachment['image_url'] || attachment['thumb_url']
         block_images = extract_block_images(attachment)
@@ -29,7 +31,7 @@ module Slk
         lines << ''
         format_author(attachment, lines)
         format_text(att_text, lines, options) if att_text && block_images.empty?
-        format_image(attachment, image_url, lines) if image_url
+        format_image(attachment, lines, options, message_ts: message_ts, index: index) if image_url
         block_images.each { |img| lines << "> [Image: #{img}]" }
       end
       # rubocop:enable Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
@@ -64,9 +66,22 @@ module Slk
         Support::TextWrapper.wrap(text, width - 2, width - 2)
       end
 
-      def format_image(attachment, image_url, lines)
-        filename = attachment['title'] || extract_filename(image_url)
-        lines << "> [Image: #{filename}]"
+      def format_image(attachment, lines, options, message_ts: nil, index: 0)
+        local_path = lookup_attachment_path(options, message_ts, index)
+        if local_path
+          lines << "> [Image: #{local_path}]"
+        else
+          image_url = attachment['image_url'] || attachment['thumb_url']
+          filename = attachment['title'] || extract_filename(image_url)
+          lines << "> [Image: #{filename}]"
+        end
+      end
+
+      def lookup_attachment_path(options, message_ts, index)
+        return nil unless message_ts
+
+        key = "att_#{message_ts}_#{index}"
+        options.dig(:file_paths, key)
       end
 
       def extract_filename(url)

data/lib/slk/formatters/message_formatter.rb

@@ -85,8 +85,14 @@ module Slk
         return '' unless message.files? && !options[:no_files]
 
         first_file = message.files.first
-        file_name = first_file['name'] || 'file'
-        @output.blue("[File: #{file_name}]")
+        file_label = file_display_label(first_file, options)
+        @output.blue("[File: #{file_label}]")
+      end
+
+      def file_display_label(file, options)
+        file_id = file['id']
+        local_path = options.dig(:file_paths, file_id) if file_id
+        local_path || file['name'] || 'file'
       end
 
       def build_output_lines(main_line, message, workspace, options, display_text)
@@ -96,7 +102,7 @@ module Slk
         BlockFormatter.new(text_processor: text_processor)
                       .format(message.blocks, message.text, lines, options)
         AttachmentFormatter.new(output: @output, text_processor: text_processor)
-                           .format(message.attachments, lines, options)
+                           .format(message.attachments, lines, options, message_ts: message.ts)
         format_files(message, lines, options, skip_first: display_text.include?('[File:'))
         format_reactions(message, lines, workspace, options)
         format_thread_indicator(message, lines, options)
@@ -128,7 +134,10 @@ module Slk
         return if options[:no_files]
 
         files = files_to_display(message.files, skip_first)
-        files.each { |file| lines << @output.blue("[File: #{file['name'] || 'file'}]") }
+        files.each do |file|
+          label = file_display_label(file, options)
+          lines << @output.blue("[File: #{label}]")
+        end
       end
 
       def files_to_display(files, skip_first)

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/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Slk
-  VERSION = '0.4.2'
+  VERSION = '0.5.0'
 end

data/lib/slk.rb

@@ -49,6 +49,7 @@ module Slk
     autoload :ReactionEnricher, 'slk/services/reaction_enricher'
     autoload :GemojiSync, 'slk/services/gemoji_sync'
     autoload :EmojiDownloader, 'slk/services/emoji_downloader'
+    autoload :FileDownloader, 'slk/services/file_downloader'
     autoload :EmojiSearcher, 'slk/services/emoji_searcher'
     autoload :ActivityEnricher, 'slk/services/activity_enricher'
     autoload :UnreadMarker, 'slk/services/unread_marker'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slk
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.5.0
 platform: ruby
 authors:
 - Eric Boehs
@@ -88,6 +88,7 @@ files:
 - lib/slk/services/emoji_downloader.rb
 - lib/slk/services/emoji_searcher.rb
 - lib/slk/services/encryption.rb
+- lib/slk/services/file_downloader.rb
 - lib/slk/services/gemoji_sync.rb
 - lib/slk/services/message_resolver.rb
 - lib/slk/services/preset_store.rb
@@ -132,7 +133,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.3
+rubygems_version: 4.0.10
 specification_version: 4
 summary: A command-line interface for Slack
 test_files: []