slk 0.1.0

data/lib/slack_cli/models/message.rb

@@ -0,0 +1,217 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Models
+    Message = Data.define(
+      :ts,
+      :user_id,
+      :text,
+      :reactions,
+      :reply_count,
+      :thread_ts,
+      :files,
+      :attachments,
+      :blocks,
+      :user_profile,
+      :bot_profile,
+      :username,
+      :subtype,
+      :channel_id
+    ) do
+      # Minimum text length before we extract content from Block Kit blocks.
+      # Slack sometimes sends minimal text (like a link preview) with the full
+      # content in blocks. 20 chars catches most of these cases without
+      # unnecessarily processing blocks for normal messages.
+      BLOCK_TEXT_THRESHOLD = 20
+
+      def self.from_api(data, channel_id: nil)
+        text = data["text"] || ""
+        blocks = data["blocks"] || []
+
+        # Extract text from Block Kit blocks if text is empty or minimal
+        if text.length < BLOCK_TEXT_THRESHOLD
+          blocks_text = extract_block_text(blocks)
+          text = blocks_text unless blocks_text.empty?
+        end
+
+        new(
+          ts: data["ts"],
+          user_id: data["user"] || data["bot_id"] || data["username"],
+          text: text,
+          reactions: (data["reactions"] || []).map { |r| Reaction.from_api(r) },
+          reply_count: data["reply_count"] || 0,
+          thread_ts: data["thread_ts"],
+          files: data["files"] || [],
+          attachments: data["attachments"] || [],
+          blocks: blocks,
+          user_profile: data["user_profile"],
+          bot_profile: data["bot_profile"],
+          username: data["username"],
+          subtype: data["subtype"],
+          channel_id: channel_id
+        )
+      end
+
+      def self.extract_block_text(blocks)
+        return "" unless blocks.is_a?(Array)
+
+        blocks.filter_map do |block|
+          case block["type"]
+          when "section"
+            block.dig("text", "text")
+          when "rich_text"
+            extract_rich_text_content(block["elements"])
+          end
+        end.join("\n")
+      end
+
+      def self.extract_rich_text_content(elements)
+        return "" unless elements.is_a?(Array)
+
+        elements.filter_map do |element|
+          next unless element["elements"].is_a?(Array)
+
+          element["elements"].filter_map do |item|
+            item["text"] if item["type"] == "text"
+          end.join
+        end.join
+      end
+
+      def initialize(
+        ts:,
+        user_id:,
+        text: "",
+        reactions: [],
+        reply_count: 0,
+        thread_ts: nil,
+        files: [],
+        attachments: [],
+        blocks: [],
+        user_profile: nil,
+        bot_profile: nil,
+        username: nil,
+        subtype: nil,
+        channel_id: nil
+      )
+        ts_str = ts.to_s.strip
+        user_id_str = user_id.to_s.strip
+
+        raise ArgumentError, "ts cannot be empty" if ts_str.empty?
+        raise ArgumentError, "user_id cannot be empty" if user_id_str.empty?
+
+        super(
+          ts: ts_str.freeze,
+          user_id: user_id_str.freeze,
+          text: text.to_s.freeze,
+          reactions: reactions.freeze,
+          reply_count: reply_count.to_i,
+          thread_ts: thread_ts&.freeze,
+          files: deep_freeze(files),
+          attachments: deep_freeze(attachments),
+          blocks: deep_freeze(blocks),
+          user_profile: deep_freeze(user_profile),
+          bot_profile: deep_freeze(bot_profile),
+          username: username&.freeze,
+          subtype: subtype&.freeze,
+          channel_id: channel_id&.freeze
+        )
+      end
+
+      # Recursively freeze nested structures (arrays and hashes)
+      def self.deep_freeze(obj)
+        case obj
+        when Hash
+          obj.each_value { |v| deep_freeze(v) }
+          obj.freeze
+        when Array
+          obj.each { |v| deep_freeze(v) }
+          obj.freeze
+        else
+          obj.freeze if obj.respond_to?(:freeze)
+        end
+        obj
+      end
+
+      private_class_method :deep_freeze
+
+      # Instance method delegate to class method for use in initialize
+      def deep_freeze(obj)
+        self.class.send(:deep_freeze, obj)
+      end
+
+      def timestamp
+        Time.at(ts.to_f)
+      end
+
+      def has_thread?
+        reply_count > 0
+      end
+
+      def is_reply?
+        thread_ts && thread_ts != ts
+      end
+
+      def has_reactions?
+        !reactions.empty?
+      end
+
+      def has_files?
+        !files.empty?
+      end
+
+      def has_blocks?
+        !blocks.empty?
+      end
+
+      def embedded_username
+        # Try user_profile first (regular users)
+        if user_profile
+          display = user_profile["display_name"]
+          real = user_profile["real_name"]
+
+          return display unless display.to_s.empty?
+          return real unless real.to_s.empty?
+        end
+
+        # Try bot_profile (bot messages)
+        if bot_profile
+          name = bot_profile["name"]
+          return name unless name.to_s.empty?
+        end
+
+        # Fall back to username field (some bots/integrations)
+        return username unless username.to_s.empty?
+
+        nil
+      end
+
+      def bot?
+        user_id.start_with?("B") || subtype == "bot_message"
+      end
+
+      def system_message?
+        %w[channel_join channel_leave channel_topic channel_purpose].include?(subtype)
+      end
+
+      # Create a copy of this message with updated reactions
+      def with_reactions(new_reactions)
+        Message.new(
+          ts: ts,
+          user_id: user_id,
+          text: text,
+          reactions: new_reactions,
+          reply_count: reply_count,
+          thread_ts: thread_ts,
+          files: files,
+          attachments: attachments,
+          blocks: blocks,
+          user_profile: user_profile,
+          bot_profile: bot_profile,
+          username: username,
+          subtype: subtype,
+          channel_id: channel_id
+        )
+      end
+    end
+  end
+end

data/lib/slack_cli/models/preset.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Models
+    Preset = Data.define(:name, :text, :emoji, :duration, :presence, :dnd) do
+      def self.from_hash(name, data)
+        new(
+          name: name,
+          text: data["text"] || "",
+          emoji: data["emoji"] || "",
+          duration: data["duration"] || "0",
+          presence: data["presence"] || "",
+          dnd: data["dnd"] || ""
+        )
+      end
+
+      def initialize(name:, text: "", emoji: "", duration: "0", presence: "", dnd: "")
+        name_str = name.to_s.strip
+        raise ArgumentError, "preset name cannot be empty" if name_str.empty?
+
+        duration_str = duration.to_s
+        # Validate duration at construction time (will raise ArgumentError if invalid)
+        Duration.parse(duration_str) unless duration_str.empty? || duration_str == "0"
+
+        super(
+          name: name_str.freeze,
+          text: text.to_s.freeze,
+          emoji: emoji.to_s.freeze,
+          duration: duration_str.freeze,
+          presence: presence.to_s.freeze,
+          dnd: dnd.to_s.freeze
+        )
+      end
+
+      def to_h
+        {
+          "text" => text,
+          "emoji" => emoji,
+          "duration" => duration,
+          "presence" => presence,
+          "dnd" => dnd
+        }
+      end
+
+      def duration_value
+        Duration.parse(duration)
+      end
+
+      def sets_presence?
+        !presence.empty?
+      end
+
+      def sets_dnd?
+        !dnd.empty?
+      end
+
+      def clears_status?
+        text.empty? && emoji.empty?
+      end
+
+      def to_s
+        parts = []
+        parts << emoji unless emoji.empty?
+        parts << "\"#{text}\"" unless text.empty?
+        parts << "(#{duration})" unless duration == "0" || duration.empty?
+        parts << "[#{presence}]" if sets_presence?
+        parts << "{dnd: #{dnd}}" if sets_dnd?
+
+        "#{name}: #{parts.join(" ")}"
+      end
+    end
+  end
+end

data/lib/slack_cli/models/reaction.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Models
+    Reaction = Data.define(:name, :count, :users, :timestamps) do
+      def self.from_api(data)
+        new(
+          name: data["name"],
+          count: data["count"] || 0,
+          users: data["users"] || [],
+          timestamps: nil  # Will be populated by ReactionEnricher
+        )
+      end
+
+      def initialize(name:, count: 0, users: [], timestamps: nil)
+        count_val = count.to_i
+        count_val = 0 if count_val.negative? # Normalize invalid negative counts
+
+        super(
+          name: name.to_s.freeze,
+          count: count_val,
+          users: users.freeze,
+          timestamps: timestamps&.freeze
+        )
+      end
+
+      # Create a new Reaction with timestamps added
+      def with_timestamps(timestamp_map)
+        Reaction.new(
+          name: name,
+          count: count,
+          users: users,
+          timestamps: timestamp_map
+        )
+      end
+
+      def has_timestamps?
+        !timestamps.nil? && !timestamps.empty?
+      end
+
+      def timestamp_for(user_id)
+        timestamps&.dig(user_id)
+      end
+
+      def emoji_code
+        ":#{name}:"
+      end
+
+      def to_s
+        "#{count} #{emoji_code}"
+      end
+    end
+  end
+end

data/lib/slack_cli/models/status.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Models
+    Status = Data.define(:text, :emoji, :expiration) do
+      def initialize(text: "", emoji: "", expiration: 0)
+        exp_val = expiration.to_i
+        exp_val = 0 if exp_val.negative? # Normalize invalid negative expirations
+
+        super(
+          text: text.to_s.freeze,
+          emoji: emoji.to_s.freeze,
+          expiration: exp_val
+        )
+      end
+
+      def empty?
+        text.empty? && emoji.empty?
+      end
+
+      def expires?
+        expiration > 0
+      end
+
+      def expired?
+        expires? && expiration < Time.now.to_i
+      end
+
+      def time_remaining
+        return nil unless expires?
+
+        remaining = expiration - Time.now.to_i
+        remaining > 0 ? Duration.new(seconds: remaining) : nil
+      end
+
+      def expiration_time
+        return nil unless expires?
+
+        Time.at(expiration)
+      end
+
+      def to_s
+        return "(no status)" if empty?
+
+        parts = []
+        parts << emoji unless emoji.empty?
+        parts << text unless text.empty?
+
+        if (remaining = time_remaining)
+          parts << "(#{remaining})"
+        end
+
+        parts.join(" ")
+      end
+    end
+  end
+end

data/lib/slack_cli/models/user.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Models
+    User = Data.define(:id, :name, :real_name, :display_name, :is_bot) do
+      def self.from_api(data)
+        profile = data["profile"] || {}
+
+        new(
+          id: data["id"],
+          name: data["name"],
+          real_name: profile["real_name"] || data["real_name"],
+          display_name: profile["display_name"] || profile["display_name_normalized"],
+          is_bot: data["is_bot"] || false
+        )
+      end
+
+      # Slack user IDs start with U or W (enterprise grid)
+      USER_ID_PATTERN = /\A[UW][A-Z0-9]+\z/
+
+      def initialize(id:, name: nil, real_name: nil, display_name: nil, is_bot: false)
+        id_str = id.to_s.strip
+        raise ArgumentError, "user id cannot be empty" if id_str.empty?
+
+        # Validate user ID format (starts with U or W followed by alphanumeric)
+        unless id_str.match?(USER_ID_PATTERN)
+          raise ArgumentError, "invalid user id format: #{id_str} (expected U or W prefix)"
+        end
+
+        super(
+          id: id_str.freeze,
+          name: name&.freeze,
+          real_name: real_name&.freeze,
+          display_name: display_name&.freeze,
+          is_bot: is_bot
+        )
+      end
+
+      def best_name
+        return display_name unless display_name.to_s.empty?
+        return real_name unless real_name.to_s.empty?
+        return name unless name.to_s.empty?
+
+        id
+      end
+
+      def mention
+        "@#{best_name}"
+      end
+
+      def to_s
+        best_name
+      end
+    end
+  end
+end

data/lib/slack_cli/models/workspace.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Models
+    Workspace = Data.define(:name, :token, :cookie) do
+      # Valid token prefixes for Slack tokens
+      VALID_TOKEN_PREFIXES = %w[xoxb- xoxc- xoxp-].freeze
+
+      def initialize(name:, token:, cookie: nil)
+        name_str = name.to_s.strip
+        token_str = token.to_s
+        cookie_str = cookie&.to_s
+
+        # Validate name is not empty and doesn't contain path separators
+        raise ArgumentError, "workspace name cannot be empty" if name_str.empty?
+        raise ArgumentError, "workspace name contains invalid characters" if name_str.match?(%r{[/\\]})
+
+        # Validate token format
+        unless VALID_TOKEN_PREFIXES.any? { |prefix| token_str.start_with?(prefix) }
+          raise ArgumentError, "invalid token format (must start with xoxb-, xoxc-, or xoxp-)"
+        end
+
+        # xoxc tokens require a cookie
+        if token_str.start_with?("xoxc-") && (cookie_str.nil? || cookie_str.strip.empty?)
+          raise ArgumentError, "xoxc tokens require a cookie"
+        end
+
+        # Validate cookie doesn't contain newlines (HTTP header injection prevention)
+        if cookie_str && cookie_str.match?(/[\r\n]/)
+          raise ArgumentError, "cookie cannot contain newlines"
+        end
+
+        super(name: name_str.freeze, token: token_str.freeze, cookie: cookie_str&.freeze)
+      end
+
+      def xoxc? = token.start_with?("xoxc-")
+      def xoxb? = token.start_with?("xoxb-")
+      def xoxp? = token.start_with?("xoxp-")
+
+      def to_s = name
+
+      def headers
+        h = {
+          "Authorization" => "Bearer #{token}",
+          "Content-Type" => "application/json; charset=utf-8"
+        }
+        h["Cookie"] = "d=#{cookie}" if cookie
+        h
+      end
+    end
+  end
+end

data/lib/slack_cli/runner.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+module SlackCli
+  class Runner
+    attr_reader :output, :config, :token_store, :api_client, :cache_store, :preset_store
+
+    def initialize(
+      output: nil,
+      config: nil,
+      token_store: nil,
+      api_client: nil,
+      cache_store: nil,
+      preset_store: nil
+    )
+      @output = output || Formatters::Output.new
+      @config = config || Services::Configuration.new
+      @token_store = token_store || Services::TokenStore.new(config: @config)
+      @api_client = api_client || Services::ApiClient.new
+      @cache_store = cache_store || Services::CacheStore.new
+      @preset_store = preset_store || Services::PresetStore.new
+
+      # Wire up warning callbacks to show warnings to users
+      wire_up_warnings
+    end
+
+    # Workspace helpers
+    def workspace(name = nil)
+      name ||= @config.primary_workspace
+      raise ConfigError, "No workspace specified and no primary workspace configured" unless name
+
+      @token_store.workspace(name)
+    end
+
+    def all_workspaces
+      @token_store.all_workspaces
+    end
+
+    def workspace_names
+      @token_store.workspace_names
+    end
+
+    def has_workspaces?
+      !@token_store.empty?
+    end
+
+    # API helpers - create API instances bound to workspace
+    def users_api(ws = nil)
+      Api::Users.new(@api_client, workspace(ws), on_debug: ->(msg) { @output.debug(msg) })
+    end
+
+    def conversations_api(ws = nil)
+      Api::Conversations.new(@api_client, workspace(ws))
+    end
+
+    def dnd_api(ws = nil)
+      Api::Dnd.new(@api_client, workspace(ws))
+    end
+
+    def client_api(ws = nil)
+      Api::Client.new(@api_client, workspace(ws))
+    end
+
+    def emoji_api(ws = nil)
+      Api::Emoji.new(@api_client, workspace(ws))
+    end
+
+    def bots_api(ws = nil)
+      Api::Bots.new(@api_client, workspace(ws), on_debug: ->(msg) { @output.debug(msg) })
+    end
+
+    def threads_api(ws = nil)
+      Api::Threads.new(@api_client, workspace(ws))
+    end
+
+    def activity_api(ws = nil)
+      Api::Activity.new(@api_client, workspace(ws))
+    end
+
+    # Formatter helpers
+    def message_formatter
+      @message_formatter ||= Formatters::MessageFormatter.new(
+        output: @output,
+        mention_replacer: mention_replacer,
+        emoji_replacer: emoji_replacer,
+        cache_store: @cache_store,
+        api_client: @api_client,
+        on_debug: ->(msg) { @output.debug(msg) }
+      )
+    end
+
+    def mention_replacer
+      @mention_replacer ||= Formatters::MentionReplacer.new(
+        cache_store: @cache_store,
+        api_client: @api_client,
+        on_debug: ->(msg) { @output.debug(msg) }
+      )
+    end
+
+    def emoji_replacer
+      @emoji_replacer ||= Formatters::EmojiReplacer.new
+    end
+
+    def duration_formatter
+      @duration_formatter ||= Formatters::DurationFormatter.new
+    end
+
+    # Logging
+    def log_error(error)
+      Support::ErrorLogger.log(error)
+    end
+
+    private
+
+    def wire_up_warnings
+      warning_handler = ->(message) { @output.warn(message) }
+
+      @config.on_warning = warning_handler
+      @token_store.on_warning = warning_handler
+      @preset_store.on_warning = warning_handler
+      @cache_store.on_warning = warning_handler
+    end
+  end
+end