slk 0.1.0

data/lib/slack_cli/services/token_store.rb

@@ -0,0 +1,117 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Services
+    class TokenStore
+      attr_accessor :on_warning
+
+      def initialize(config: nil, encryption: nil, paths: nil)
+        @config = config || Configuration.new
+        @encryption = encryption || Encryption.new
+        @paths = paths || Support::XdgPaths.new
+        @on_warning = nil
+      end
+
+      def workspace(name)
+        tokens = load_tokens
+        data = tokens[name]
+        raise WorkspaceNotFoundError, "Workspace '#{name}' not found" unless data
+
+        Models::Workspace.new(
+          name: name,
+          token: data["token"],
+          cookie: data["cookie"]
+        )
+      end
+
+      def all_workspaces
+        load_tokens.map do |name, data|
+          Models::Workspace.new(
+            name: name,
+            token: data["token"],
+            cookie: data["cookie"]
+          )
+        end
+      end
+
+      def workspace_names
+        load_tokens.keys
+      end
+
+      def exists?(name)
+        load_tokens.key?(name)
+      end
+
+      def add(name, token, cookie = nil)
+        # Validate by constructing a Workspace (will raise ArgumentError if invalid)
+        Models::Workspace.new(name: name, token: token, cookie: cookie)
+
+        tokens = load_tokens
+        tokens[name] = { "token" => token, "cookie" => cookie }.compact
+        save_tokens(tokens)
+      end
+
+      def remove(name)
+        tokens = load_tokens
+        removed = tokens.delete(name)
+        save_tokens(tokens) if removed
+        !removed.nil?
+      end
+
+      def empty?
+        load_tokens.empty?
+      end
+
+      private
+
+      def load_tokens
+        if encrypted_file_exists?
+          decrypt_tokens
+        elsif plain_file_exists?
+          JSON.parse(File.read(plain_tokens_file))
+        else
+          {}
+        end
+      rescue JSON::ParserError => e
+        raise TokenStoreError, "Tokens file #{plain_tokens_file} is corrupted: #{e.message}"
+      end
+
+      def save_tokens(tokens)
+        @paths.ensure_config_dir
+
+        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)
+        else
+          # Plain text storage (no encryption configured)
+          File.write(plain_tokens_file, JSON.pretty_generate(tokens))
+          File.chmod(0o600, plain_tokens_file)
+        end
+      end
+
+      def decrypt_tokens
+        content = @encryption.decrypt(encrypted_tokens_file, @config.ssh_key)
+        content ? JSON.parse(content) : {}
+      rescue JSON::ParserError => e
+        raise TokenStoreError, "Encrypted tokens file is corrupted: #{e.message}"
+      end
+
+      def encrypted_file_exists?
+        File.exist?(encrypted_tokens_file)
+      end
+
+      def plain_file_exists?
+        File.exist?(plain_tokens_file)
+      end
+
+      def encrypted_tokens_file
+        @paths.config_file("tokens.age")
+      end
+
+      def plain_tokens_file
+        @paths.config_file("tokens.json")
+      end
+    end
+  end
+end

data/lib/slack_cli/support/error_logger.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Support
+    module ErrorLogger
+      # Log an error to the error log file
+      # @param error [Exception] The error to log
+      # @param paths [XdgPaths] Path helper (for testing)
+      # @return [String, nil] Path to the log file, or nil if logging failed
+      def self.log(error, paths: XdgPaths.new)
+        paths.ensure_cache_dir
+
+        log_file = paths.cache_file('error.log')
+        File.open(log_file, 'a') do |f|
+          f.puts "#{Time.now.iso8601} - #{error.class}: #{error.message}"
+          f.puts error.backtrace.first(10).map { |line| "  #{line}" }.join("\n") if error.backtrace
+          f.puts
+        end
+
+        log_file
+      rescue SystemCallError, IOError
+        # If we can't write to the log, fail silently rather than crashing
+        # The user will still see the error message in the console
+        nil
+      end
+    end
+  end
+end

data/lib/slack_cli/support/help_formatter.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Support
+    # Formats help text with auto-aligned columns
+    #
+    # Example usage:
+    #   help = HelpFormatter.new("slk status [text] [emoji] [options]")
+    #   help.description("Get or set your Slack status.")
+    #   help.note("GET shows all workspaces by default. SET applies to primary only.")
+    #
+    #   help.section("EXAMPLES") do |s|
+    #     s.example("slk status", "Show status (all workspaces)")
+    #     s.example("slk status clear", "Clear status")
+    #   end
+    #
+    #   help.section("OPTIONS") do |s|
+    #     s.option("-n, --limit N", "Messages per channel (default: 10)")
+    #     s.option("--muted", "Include muted channels")
+    #   end
+    #
+    #   puts help.render
+    #
+    class HelpFormatter
+      def initialize(usage)
+        @usage = usage
+        @description = nil
+        @notes = []
+        @sections = []
+      end
+
+      def description(text)
+        @description = text
+        self
+      end
+
+      def note(text)
+        @notes << text
+        self
+      end
+
+      def section(title, &block)
+        section = Section.new(title)
+        block.call(section)
+        @sections << section
+        self
+      end
+
+      def render
+        lines = []
+        lines << "USAGE: #{@usage}"
+        lines << ""
+
+        if @description
+          lines << @description
+        end
+
+        @notes.each do |note|
+          lines << note
+        end
+
+        lines << "" if @description || @notes.any?
+
+        @sections.each do |section|
+          lines << "#{section.title}:"
+          lines.concat(section.render)
+          lines << ""
+        end
+
+        # Remove trailing blank line
+        lines.pop if lines.last == ""
+
+        lines.join("\n")
+      end
+
+      class Section
+        attr_reader :title
+
+        def initialize(title)
+          @title = title
+          @items = []
+        end
+
+        def option(flags, description)
+          @items << [:option, flags, description]
+          self
+        end
+
+        def action(name, description)
+          @items << [:action, name, description]
+          self
+        end
+
+        def example(command, description = nil)
+          @items << [:example, command, description]
+          self
+        end
+
+        def item(left, right)
+          @items << [:item, left, right]
+          self
+        end
+
+        def text(content)
+          @items << [:text, content, nil]
+          self
+        end
+
+        def render
+          return [] if @items.empty?
+
+          # Calculate max width of left column
+          max_left = @items
+            .reject { |type, _, _| type == :text }
+            .map { |_, left, _| left.length }
+            .max || 0
+
+          # Add padding (2 spaces between columns)
+          padding = 2
+
+          @items.map do |type, left, right|
+            case type
+            when :text
+              "  #{left}"
+            when :example
+              if right
+                "  #{left.ljust(max_left + padding)}#{right}"
+              else
+                "  #{left}"
+              end
+            else
+              "  #{left.ljust(max_left + padding)}#{right}"
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/slack_cli/support/inline_images.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Support
+    # Shared module for inline image display in iTerm2/WezTerm/Mintty terminals
+    # Includes special handling for tmux passthrough sequences
+    module InlineImages
+      # Check if terminal supports iTerm2 inline image protocol
+      def inline_images_supported?
+        # iTerm2, WezTerm, Mintty support inline images
+        # LC_TERMINAL persists through tmux/ssh
+        ENV["TERM_PROGRAM"] == "iTerm.app" ||
+          ENV["TERM_PROGRAM"] == "WezTerm" ||
+          ENV["LC_TERMINAL"] == "iTerm2" ||
+          ENV["LC_TERMINAL"] == "WezTerm" ||
+          ENV["TERM"] == "mintty"
+      end
+
+      # Check if running inside tmux
+      def in_tmux?
+        # tmux sets TERM to screen-* or tmux-*
+        ENV["TERM"]&.include?("screen") || ENV["TERM"]&.start_with?("tmux")
+      end
+
+      # Print an inline image using iTerm2 protocol
+      # In tmux, uses passthrough sequence and cursor positioning
+      def print_inline_image(path, height: 1)
+        return unless File.exist?(path)
+
+        data = File.binread(path)
+        encoded = [data].pack("m0") # Base64 encode
+
+        if in_tmux?
+          # tmux passthrough: \n + space required for image to render
+          printf "\ePtmux;\e\e]1337;File=inline=1;preserveAspectRatio=0;size=%d;height=%d:%s\a\e\\\n ",
+                 encoded.length, height, encoded
+        else
+          # Standard iTerm2 format
+          printf "\e]1337;File=inline=1;height=%d:%s\a", height, encoded
+        end
+      end
+
+      # Print inline image with name on same line
+      # Handles tmux cursor positioning to keep image and text on same line
+      def print_inline_image_with_text(path, text, height: 1)
+        return false unless inline_images_supported? && File.exist?(path)
+
+        print_inline_image(path, height: height)
+
+        if in_tmux?
+          # tmux: image ends with \n + space, cursor on next line
+          # Move up 1 line, right 3 cols (past image), then print text
+          print "\e[1A\e[3C#{text}\n"
+        else
+          puts " #{text}"
+        end
+
+        true
+      end
+    end
+  end
+end

data/lib/slack_cli/support/slack_url_parser.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Support
+    class SlackUrlParser
+      # Patterns for Slack URLs
+      # Channel IDs: C=channel, G=group DM, D=direct message
+      URL_PATTERNS = [
+        # https://workspace.slack.com/archives/C123ABC/p1234567890123456
+        %r{https?://([^.]+)\.slack\.com/archives/([CDG][A-Z0-9]+)/p(\d+)(?:\?thread_ts=(\d+\.\d+))?},
+        # https://workspace.slack.com/archives/C123ABC (no message)
+        %r{https?://([^.]+)\.slack\.com/archives/([CDG][A-Z0-9]+)/?$}
+      ].freeze
+
+      Result = Data.define(:workspace, :channel_id, :msg_ts, :thread_ts) do
+        def message?
+          !msg_ts.nil?
+        end
+
+        def thread?
+          !thread_ts.nil?
+        end
+
+        # Returns the thread parent timestamp if this URL points to a threaded message.
+        # Use this when fetching thread replies - pass this as the thread_ts parameter.
+        # Returns nil if the URL does not contain a thread_ts query parameter.
+        def ts
+          thread_ts
+        end
+      end
+
+      def parse(input)
+        return nil unless input.to_s.include?("slack.com")
+
+        URL_PATTERNS.each do |pattern|
+          match = input.match(pattern)
+          next unless match
+
+          workspace = match[1]
+          channel_id = match[2]
+          msg_ts = match[3] ? format_ts(match[3]) : nil
+          thread_ts = match[4]
+
+          return Result.new(
+            workspace: workspace,
+            channel_id: channel_id,
+            msg_ts: msg_ts,
+            thread_ts: thread_ts
+          )
+        end
+
+        nil
+      end
+
+      def slack_url?(input)
+        input.to_s.include?("slack.com/archives")
+      end
+
+      private
+
+      # Convert Slack URL timestamp format to API format
+      # URL: p1234567890123456 -> API: 1234567890.123456
+      def format_ts(url_ts)
+        return nil unless url_ts
+
+        # Remove 'p' prefix if present
+        ts = url_ts.sub(/^p/, "")
+
+        # Insert decimal point
+        if ts.length > 6
+          "#{ts[0..-7]}.#{ts[-6..]}"
+        else
+          ts
+        end
+      end
+    end
+  end
+end

data/lib/slack_cli/support/user_resolver.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Support
+    # Shared logic for resolving user and channel names from Slack data.
+    # Include this module in commands that need to look up user/channel names.
+    #
+    # == Required Interface
+    # Including classes must provide these methods:
+    # - runner: Returns the Runner instance for API access
+    # - cache_store: Returns the CacheStore for name lookups
+    # - debug(message): Logs debug messages (can be a no-op)
+    module UserResolver
+      # Resolves a DM channel ID to the user's display name
+      # @param workspace [Models::Workspace] The workspace to look up in
+      # @param channel_id [String] The DM channel ID (starts with D)
+      # @param conversations [Api::Conversations] API client for conversation info
+      # @return [String] User name or channel ID if not found
+      def resolve_dm_user_name(workspace, channel_id, conversations)
+        info = conversations.info(channel: channel_id)
+        return channel_id unless info["ok"] && info["channel"]
+
+        user_id = info["channel"]["user"]
+        return channel_id unless user_id
+
+        # Try cache first
+        cached = cache_store.get_user(workspace.name, user_id)
+        return cached if cached
+
+        # Try users API lookup
+        begin
+          users_api = runner.users_api(workspace.name)
+          user_info = users_api.info(user_id)
+          if user_info["ok"] && user_info["user"]
+            profile = user_info["user"]["profile"] || {}
+            name = profile["display_name"]
+            name = profile["real_name"] if name.to_s.empty?
+            name = user_info["user"]["name"] if name.to_s.empty?
+            if name && !name.empty?
+              cache_store.set_user(workspace.name, user_id, name, persist: true)
+              return name
+            end
+          end
+        rescue ApiError => e
+          debug("User lookup failed for #{user_id}: #{e.message}")
+        end
+
+        user_id
+      rescue ApiError => e
+        debug("DM info lookup failed for #{channel_id}: #{e.message}")
+        channel_id
+      end
+
+      # Resolves a channel ID to a formatted label (@username or #channel)
+      # @param workspace [Models::Workspace] The workspace to look up in
+      # @param channel_id [String] The channel ID
+      # @return [String] Formatted label like "@username" or "#channel"
+      def resolve_conversation_label(workspace, channel_id)
+        # DM channels start with D
+        if channel_id.start_with?("D")
+          conversations = runner.conversations_api(workspace.name)
+          user_name = resolve_dm_user_name(workspace, channel_id, conversations)
+          return "@#{user_name}"
+        end
+
+        # Try cache first
+        cached_name = cache_store.get_channel_name(workspace.name, channel_id)
+        return "##{cached_name}" if cached_name
+
+        # Try API lookup
+        begin
+          conversations = runner.conversations_api(workspace.name)
+          response = conversations.info(channel: channel_id)
+          if response["ok"] && response["channel"]
+            name = response["channel"]["name"]
+            if name
+              cache_store.set_channel(workspace.name, name, channel_id)
+              return "##{name}"
+            end
+          end
+        rescue ApiError => e
+          debug("Channel info lookup failed for #{channel_id}: #{e.message}")
+        end
+
+        "##{channel_id}"
+      end
+
+      # Extracts the user name from a message hash
+      # @param msg [Hash] The message data from API
+      # @param workspace [Models::Workspace] The workspace context
+      # @return [String] User name, user_id as fallback, or "unknown" if neither found
+      def extract_user_from_message(msg, workspace)
+        # Try user_profile embedded in message
+        if msg["user_profile"]
+          name = msg["user_profile"]["display_name"]
+          name = msg["user_profile"]["real_name"] if name.to_s.empty?
+          return name unless name.to_s.empty?
+        end
+
+        # Try username field
+        return msg["username"] unless msg["username"].to_s.empty?
+
+        # Try cache
+        user_id = msg["user"] || msg["bot_id"]
+        if user_id
+          cached = cache_store.get_user(workspace.name, user_id)
+          return cached if cached
+        end
+
+        user_id || "unknown"
+      end
+    end
+  end
+end

data/lib/slack_cli/support/xdg_paths.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Support
+    class XdgPaths
+      def config_dir
+        @config_dir ||= File.join(
+          ENV.fetch("XDG_CONFIG_HOME", File.join(Dir.home, ".config")),
+          "slack-cli"
+        )
+      end
+
+      def cache_dir
+        @cache_dir ||= File.join(
+          ENV.fetch("XDG_CACHE_HOME", File.join(Dir.home, ".cache")),
+          "slack-cli"
+        )
+      end
+
+      def config_file(filename)
+        File.join(config_dir, filename)
+      end
+
+      def cache_file(filename)
+        File.join(cache_dir, filename)
+      end
+
+      def ensure_config_dir
+        FileUtils.mkdir_p(config_dir)
+      end
+
+      def ensure_cache_dir
+        FileUtils.mkdir_p(cache_dir)
+      end
+    end
+  end
+end

data/lib/slack_cli/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module SlackCli
+  VERSION = "0.1.0"
+end

data/lib/slack_cli.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "uri"
+require "json"
+require "fileutils"
+require "optparse"
+require "time"
+require "io/console"
+
+module SlackCli
+  class Error < StandardError; end
+  class ApiError < Error; end
+  class ConfigError < Error; end
+  class EncryptionError < Error; end
+  class TokenStoreError < Error; end
+  class WorkspaceNotFoundError < ConfigError; end
+  class PresetNotFoundError < ConfigError; end
+
+  autoload :VERSION, "slack_cli/version"
+  autoload :CLI, "slack_cli/cli"
+  autoload :Runner, "slack_cli/runner"
+
+  module Models
+    autoload :Duration, "slack_cli/models/duration"
+    autoload :Workspace, "slack_cli/models/workspace"
+    autoload :Status, "slack_cli/models/status"
+    autoload :Message, "slack_cli/models/message"
+    autoload :Reaction, "slack_cli/models/reaction"
+    autoload :User, "slack_cli/models/user"
+    autoload :Channel, "slack_cli/models/channel"
+    autoload :Preset, "slack_cli/models/preset"
+  end
+
+  module Services
+    autoload :ApiClient, "slack_cli/services/api_client"
+    autoload :Configuration, "slack_cli/services/configuration"
+    autoload :TokenStore, "slack_cli/services/token_store"
+    autoload :CacheStore, "slack_cli/services/cache_store"
+    autoload :PresetStore, "slack_cli/services/preset_store"
+    autoload :Encryption, "slack_cli/services/encryption"
+    autoload :ReactionEnricher, "slack_cli/services/reaction_enricher"
+  end
+
+  module Formatters
+    autoload :Output, "slack_cli/formatters/output"
+    autoload :DurationFormatter, "slack_cli/formatters/duration_formatter"
+    autoload :MentionReplacer, "slack_cli/formatters/mention_replacer"
+    autoload :EmojiReplacer, "slack_cli/formatters/emoji_replacer"
+    autoload :MessageFormatter, "slack_cli/formatters/message_formatter"
+  end
+
+  module Commands
+    autoload :Base, "slack_cli/commands/base"
+    autoload :Status, "slack_cli/commands/status"
+    autoload :Presence, "slack_cli/commands/presence"
+    autoload :Dnd, "slack_cli/commands/dnd"
+    autoload :Messages, "slack_cli/commands/messages"
+    autoload :Thread, "slack_cli/commands/thread"
+    autoload :Unread, "slack_cli/commands/unread"
+    autoload :Catchup, "slack_cli/commands/catchup"
+    autoload :Activity, "slack_cli/commands/activity"
+    autoload :Preset, "slack_cli/commands/preset"
+    autoload :Workspaces, "slack_cli/commands/workspaces"
+    autoload :Cache, "slack_cli/commands/cache"
+    autoload :Emoji, "slack_cli/commands/emoji"
+    autoload :Config, "slack_cli/commands/config"
+    autoload :Help, "slack_cli/commands/help"
+  end
+
+  module Api
+    autoload :Users, "slack_cli/api/users"
+    autoload :Conversations, "slack_cli/api/conversations"
+    autoload :Dnd, "slack_cli/api/dnd"
+    autoload :Emoji, "slack_cli/api/emoji"
+    autoload :Client, "slack_cli/api/client"
+    autoload :Bots, "slack_cli/api/bots"
+    autoload :Threads, "slack_cli/api/threads"
+    autoload :Usergroups, "slack_cli/api/usergroups"
+    autoload :Activity, "slack_cli/api/activity"
+  end
+
+  module Support
+    autoload :XdgPaths, "slack_cli/support/xdg_paths"
+    autoload :SlackUrlParser, "slack_cli/support/slack_url_parser"
+    autoload :InlineImages, "slack_cli/support/inline_images"
+    autoload :HelpFormatter, "slack_cli/support/help_formatter"
+    autoload :ErrorLogger, "slack_cli/support/error_logger"
+    autoload :UserResolver, "slack_cli/support/user_resolver"
+  end
+end