slk 0.13.0 → 0.15.0

data/lib/slk/formatters/mention_replacer.rb

@@ -109,14 +109,20 @@ module Slk
         response = Api::Conversations.new(@api, workspace).info(channel: channel_id)
         return nil unless response['ok'] && response['channel']
 
-        name = response['channel']['name']
-        @cache.set_channel(workspace.name, name, channel_id) if name
-        name
+        remember_channel_name(workspace, channel_id, response['channel'])
       rescue ApiError => e
         @on_debug&.call("Channel lookup failed for #{channel_id}: #{e.message}")
         nil
       end
 
+      # Group DMs stay out of the name cache: a named one can be renamed or
+      # share a real channel's name, and an mpdm-* slug isn't a name.
+      def remember_channel_name(workspace, channel_id, channel)
+        name = channel['name']
+        @cache.set_channel(workspace.name, name, channel_id) if name && !channel['is_mpim']
+        name
+      end
+
       def lookup_subteam_handle(workspace, subteam_id)
         cached = @cache.get_subteam(workspace.name, subteam_id)
         return cached if cached

data/lib/slk/formatters/profile_formatter.rb

@@ -25,6 +25,7 @@ module Slk
         render_header(profile)
         return emit_rows(@rows.external(profile)) if profile.external?
 
+        emit_huddle(profile)
         render_section('Contact information', @rows.contact(profile))
         render_section('People', @rows.people(profile))
         render_section('About me', @rows.about(profile))
@@ -70,6 +71,14 @@ module Slk
         @output.gray("external — #{profile.home_team_name || 'external workspace'}")
       end
 
+      def emit_huddle(profile)
+        rows = @rows.huddle(profile)
+        return if rows.reject { |_, value| value.nil? || value.to_s.empty? }.empty?
+
+        emit_rows(rows)
+        @output.puts
+      end
+
       def render_section(title, rows)
         return if rows.reject { |_, v| v.nil? || v.to_s.empty? }.empty?
 

data/lib/slk/formatters/profile_rows.rb

@@ -21,11 +21,16 @@ module Slk
       def base(profile)
         [
           ['Presence', profile.presence_label],
+          ['Huddle', huddle_text(profile)],
           ['Status', status_text(profile)],
           ['Local', local_time(profile)]
         ]
       end
 
+      def huddle(profile)
+        [['Huddle', huddle_text(profile)]]
+      end
+
       def people(profile)
         profile.people_fields.flat_map do |field|
           field.user_ids.map { |uid| [field.label, @fields.render_user_reference(uid, profile)] }
@@ -39,7 +44,7 @@ module Slk
       end
 
       def external(profile)
-        contact(profile) + [['Workspace', profile.home_team_name]]
+        contact(profile) + [['Workspace', profile.home_team_name]] + huddle(profile)
       end
 
       private
@@ -48,6 +53,14 @@ module Slk
         field.label.casecmp('Title').zero? && field.value.to_s == profile.title.to_s
       end
 
+      def huddle_text(profile)
+        label = profile.huddle_label
+        return nil unless label
+        return label if profile.huddle_channel.to_s.empty?
+
+        "#{label} · #{profile.huddle_channel}"
+      end
+
       def status_text(profile)
         return nil if profile.status_text.empty? && profile.status_emoji.empty?
 

data/lib/slk/formatters/search_formatter.rb

@@ -37,7 +37,11 @@ module Slk
         channel_label_for(result.channel_type, result.channel_name, workspace)
       end
 
+      # Named group DMs show as #name; their name is not a user ID to resolve.
       def channel_label_for(type, name, workspace)
+        named = type == 'mpim' && Support::GroupDmName.label(name)
+        return named if named
+
         if %w[im mpim].include?(type)
           @mentions.replace("<@#{name}>", workspace)
         else

data/lib/slk/models/huddle.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Slk
+  module Models
+    HuddleParticipant = Data.define(:id, :name)
+
+    # One active huddle. `channel` is a display label filled in after the
+    # scan (`#name`, `DM`, `group DM`); `channel_id` is what Slack sent.
+    Huddle = Data.define(:call_id, :channel_id, :channel, :participants) do
+      def place
+        channel || channel_id
+      end
+    end
+
+    WorkspaceHuddles = Data.define(:workspace, :huddles)
+  end
+end

data/lib/slk/models/profile.rb

@@ -15,8 +15,15 @@ module Slk
       :tz, :tz_label, :tz_offset, :start_date,
       :is_admin, :is_owner, :is_bot, :is_external, :deleted,
       :team_id, :home_team_name,
-      :presence, :sections, :custom_fields, :resolved_users
+      :presence, :huddle_state, :huddle_channel_id, :huddle_call_id, :huddle_channel,
+      :sections, :custom_fields, :resolved_users
     ) do
+      # Existing constructors predate huddle fields. Default them so a card
+      # without a live read still builds, and so the row stays blank.
+      def initialize(huddle_state: nil, huddle_channel_id: nil, huddle_call_id: nil, huddle_channel: nil, **rest)
+        super
+      end
+
       def presence_label
         case presence
         when 'active' then 'Active'
@@ -24,6 +31,14 @@ module Slk
         end
       end
 
+      # `default_unset` is Slack's empty value, not a state worth printing.
+      def huddle_label
+        case huddle_state
+        when 'in_a_huddle' then 'In a huddle'
+        when 'available_for_huddle' then 'Available for a huddle'
+        end
+      end
+
       def best_name
         return display_name unless display_name.to_s.empty?
         return real_name unless real_name.to_s.empty?

data/lib/slk/models/search_result.rb

@@ -106,6 +106,9 @@ module Slk
       end
 
       def display_channel
+        named = channel_type == 'mpim' && Support::GroupDmName.label(channel_name)
+        return named if named
+
         if dm?
           "@#{channel_name}"
         else

data/lib/slk/services/activity_enricher.rb

@@ -2,11 +2,14 @@
 
 module Slk
   module Services
-    # Enriches activity feed items with resolved user/channel names
+    # Enriches activity feed items with resolved user/channel names.
+    # Group DMs show as "#name" when named, else "@other, members" (given a
+    # GroupDmLabel), never as their mpdm-* slug, and are never cached by name.
     class ActivityEnricher
-      def initialize(cache_store:, conversations_api:, on_debug: nil)
+      def initialize(cache_store:, conversations_api:, group_dm_label: nil, on_debug: nil)
         @cache = cache_store
         @conversations_api = conversations_api
+        @group_dm_label = group_dm_label
         @on_debug = on_debug
       end
 
@@ -40,15 +43,16 @@ module Slk
         @cache.get_user(workspace.name, user_id) || user_id
       end
 
-      # Resolve channel ID to name (with API fallback)
+      # Resolve channel ID to a label (with API fallback). Legacy G ids are
+      # group DMs or old private channels; they read "Group DM" if Slack
+      # won't say which.
       def resolve_channel(workspace, channel_id, with_hash: true)
         return 'DM' if channel_id.start_with?('D')
-        return 'Group DM' if channel_id.start_with?('G')
 
-        name = fetch_channel_name(workspace, channel_id)
-        return channel_id unless name
+        label = channel_label(workspace, channel_id)
+        return channel_id.start_with?('G') ? 'Group DM' : channel_id unless label
 
-        with_hash ? "##{name}" : name
+        with_hash ? label : label.delete_prefix('#')
       end
 
       private
@@ -101,21 +105,37 @@ module Slk
         data['channel_name'] = resolve_channel(workspace, channel_id, with_hash: false) if channel_id
       end
 
-      def fetch_channel_name(workspace, channel_id)
+      def channel_label(workspace, channel_id)
+        known = @group_dm_label&.known(workspace, channel_id)
+        return known if known
+
         cached = @cache.get_channel_name(workspace.name, channel_id)
-        return cached if cached
+        return "##{cached}" if cached
+
+        fetch_channel_label(workspace, channel_id)
+      end
 
+      def fetch_channel_label(workspace, channel_id)
         response = @conversations_api.info(channel: channel_id)
-        return nil unless response['ok'] && response['channel']
+        channel = response['channel'] if response['ok']
+        return nil unless channel
+        return group_dm_label(workspace, channel_id, channel) if channel['is_mpim']
+        return nil unless channel['name']
 
-        name = response['channel']['name']
-        @cache.set_channel(workspace.name, name, channel_id)
-        name
+        @cache.set_channel(workspace.name, channel['name'], channel_id)
+        "##{channel['name']}"
       rescue ApiError => e
         @on_debug&.call("Could not resolve channel #{channel_id}: #{e.message}")
         nil
       end
 
+      def group_dm_label(workspace, channel_id, channel)
+        return @group_dm_label.label_from(workspace, channel_id, channel) if @group_dm_label
+
+        named = Support::GroupDmName.custom(channel)
+        named ? "##{named}" : 'Group DM'
+      end
+
       def debug_missing(item_type, missing_data)
         @on_debug&.call("Could not enrich #{item_type} item - missing #{missing_data} data")
       end

data/lib/slk/services/api_client.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'stringio'
+require 'zlib'
+
 module Slk
   module Services
     # HTTP client for Slack API with connection pooling
@@ -24,6 +27,7 @@ module Slk
 
       def initialize
         @call_count = 0
+        @count_mutex = Mutex.new
         @on_request = nil
         @on_response = nil
         @on_request_body = nil
@@ -32,6 +36,23 @@ module Slk
         @rate_resets = {}
       end
 
+      # A second client with its own connection. Net::HTTP is not safe to
+      # share across threads, and one connection can only fetch one roster
+      # at a time. Callbacks are copied now, so set them before isolating.
+      def isolated
+        child = self.class.new
+        child.on_request = @on_request
+        child.on_response = @on_response
+        child.on_request_body = @on_request_body
+        child.on_response_body = @on_response_body
+        child.share_counter(self)
+        child
+      end
+
+      def share_counter(parent)
+        @counter = parent
+      end
+
       # Close all cached HTTP connections
       def close
         @http_cache.each_value { |http| safe_close(http) }
@@ -43,6 +64,7 @@ module Slk
         execute_request(method, body: body) do |uri, http|
           request = Net::HTTP::Post.new(uri)
           workspace.headers.each { |k, v| request[k] = v }
+          accept_gzip(request)
           request.body = body
           http.request(request)
         end
@@ -52,6 +74,7 @@ module Slk
         execute_request(method, params) do |uri, http|
           request = Net::HTTP::Get.new(uri)
           apply_auth_headers(request, workspace)
+          accept_gzip(request)
           http.request(request)
         end
       end
@@ -62,6 +85,7 @@ module Slk
         execute_request(method, body: body) do |uri, http|
           request = Net::HTTP::Post.new(uri)
           apply_auth_headers(request, workspace)
+          accept_gzip(request)
           request.set_form_data(params) unless params.empty?
           http.request(request)
         end
@@ -98,6 +122,7 @@ module Slk
         log_request_body(method, body)
         uri = build_uri(method, query_params)
         response, elapsed_ms = timed_request(uri, &)
+        decode_body!(response)
         track_rate_limit(method, response)
         log_response(method, response, elapsed_ms)
         log_response_body(method, response.body)
@@ -157,8 +182,39 @@ module Slk
       end
 
       def log_request(method)
-        @call_count += 1
-        @on_request&.call(method, @call_count)
+        count = tally
+        @on_request&.call(method, count)
+      end
+
+      def tally
+        (@counter || self).bump_call_count
+      end
+
+      def bump_call_count
+        @count_mutex.synchronize { @call_count += 1 }
+      end
+      public :bump_call_count
+
+      def accept_gzip(request)
+        request['Accept-Encoding'] = 'gzip'
+      end
+
+      # A users.list page is a large JSON document. Slack compresses it when
+      # asked, which is most of the time a roster scan spends on the wire.
+      def decode_body!(response)
+        return unless gzip_encoded?(response)
+
+        response.body = inflate_gzip(response.body.to_s)
+      end
+
+      def gzip_encoded?(response)
+        response['Content-Encoding'].to_s.downcase.split(',').map(&:strip).include?('gzip')
+      end
+
+      def inflate_gzip(body)
+        Zlib::GzipReader.new(StringIO.new(body)).read
+      rescue Zlib::Error
+        raise ApiError.new('Invalid gzip response from Slack API', code: :invalid_response)
       end
 
       def log_request_body(method, body)

data/lib/slk/services/cache_store.rb

@@ -110,16 +110,23 @@ module Slk
         result
       end
 
+      # Group DM mpdm-* slugs are never returned (older versions cached them),
+      # so callers fall through to a real label.
       def get_channel_name(workspace_name, channel_id)
         load_channel_cache(workspace_name)
         cache = @channel_cache[workspace_name] || {}
-        result = cache.key(channel_id)
+        result = cache.find { |name, id| id == channel_id && !group_dm_slug?(name) }&.first
         log_cache_access('channel_name', workspace_name, channel_id, result)
         result
       end
 
+      # Refuses group DM mpdm-* slugs: they are Slack's internal names, not
+      # what people type or see. Writing drops any slugs cached before this.
       def set_channel(workspace_name, channel_name, channel_id)
-        @channel_cache[workspace_name] ||= {}
+        return if group_dm_slug?(channel_name)
+
+        load_channel_cache(workspace_name)
+        @channel_cache[workspace_name].reject! { |name, _id| group_dm_slug?(name) }
         @channel_cache[workspace_name][channel_name] = channel_id
         save_channel_cache(workspace_name)
       end
@@ -184,6 +191,10 @@ module Slk
 
       private
 
+      def group_dm_slug?(name)
+        name.to_s.match?(Support::GroupDmName::SLUG)
+      end
+
       def load_user_cache(workspace_name)
         return if @user_cache.key?(workspace_name)
 

data/lib/slk/services/channel_lookup.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Finds a conversation id from a name typed as `#name`.
+    #
+    # Order: the channel cache, then every page of the conversations you
+    # belong to (users.conversations: public and private channels plus group
+    # DMs, so a named group DM such as "ifams review" resolves), then one page
+    # of conversations.list for public channels you have not joined. That
+    # last step is only one page, as before: the full workspace list runs to
+    # thousands of channels at 100 per page.
+    #
+    # A channel wins over a named group DM with the same name. A group DM is
+    # cached only after a full scan finds no channel of that name among yours.
+    class ChannelLookup
+      MEMBER_TYPES = 'public_channel,private_channel,mpim'
+      MAX_PAGES = 50
+
+      def initialize(runner:, cache_store:)
+        @runner = runner
+        @cache = cache_store
+      end
+
+      # @param workspace [Models::Workspace]
+      # @param name [String] channel or group DM name, without the leading #
+      # @return [String, nil] the conversation id, or nil if none matches
+      def find_id(workspace, name)
+        @cache.get_channel_id(workspace.name, name) || lookup(workspace, name)
+      end
+
+      private
+
+      def lookup(workspace, name)
+        channel = member_conversation(workspace, name) || listed_channel(workspace, name)
+        return nil unless channel
+
+        @cache.set_channel(workspace.name, channel['name'], channel['id'])
+        channel['id']
+      end
+
+      def member_conversation(workspace, name)
+        group_dm = nil
+        each_member_page(workspace) do |conversations|
+          conversations.each do |conversation|
+            next unless name_matches?(conversation, name)
+            return conversation unless conversation['is_mpim']
+
+            group_dm ||= conversation
+          end
+        end
+        group_dm
+      end
+
+      def each_member_page(workspace)
+        api = @runner.users_api(workspace.name)
+        cursor = nil
+        MAX_PAGES.times do
+          response = api.conversations(cursor: cursor, types: MEMBER_TYPES, exclude_archived: true)
+          yield response['channels'] || []
+          cursor = response.dig('response_metadata', 'next_cursor').to_s
+          break if cursor.empty?
+        end
+      end
+
+      def listed_channel(workspace, name)
+        channels = @runner.conversations_api(workspace.name).list['channels'] || []
+        channels.find { |channel| name_matches?(channel, name) }
+      end
+
+      # Channel names are lowercase; a group DM's name keeps whatever case
+      # it was given, so "#IFAMS Review" and "#ifams review" both find it.
+      def name_matches?(conversation, name)
+        conversation['name'].to_s.casecmp?(name)
+      end
+    end
+  end
+end

data/lib/slk/services/group_dm_label.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Header label for a group DM in unread and catchup (conversation and
+    # thread headers). A named group DM
+    # shows its name ("#ifams review"); any other shows the people in it
+    # besides you ("@Ada Lovelace, Grace Hopper") rather than the opaque
+    # mpdm-* slug. One conversations.info per chat, remembered for the run.
+    class GroupDmLabel
+      def initialize(runner:, on_debug: nil)
+        @runner = runner
+        @on_debug = on_debug
+        @labels = {}
+        @self_ids = {}
+      end
+
+      # @return [String] "#name", "@names", or "#<channel id>" if Slack refuses
+      def label(workspace, channel_id)
+        @labels[[workspace.name, channel_id]] ||= fetch_label(workspace, channel_id)
+      end
+
+      # @return [String, nil] a label already worked out this run, if any
+      def known(workspace, channel_id)
+        @labels[[workspace.name, channel_id]]
+      end
+
+      # Same label when the caller already holds conversations.info's channel.
+      def label_from(workspace, channel_id, channel)
+        @labels[[workspace.name, channel_id]] ||= label_for(workspace, channel) || "##{channel_id}"
+      end
+
+      private
+
+      def fetch_label(workspace, channel_id)
+        channel = @runner.conversations_api(workspace.name).info(channel: channel_id)['channel'] || {}
+        label_for(workspace, channel) || "##{channel_id}"
+      rescue ApiError => e
+        @on_debug&.call("Group DM lookup failed for #{channel_id}: #{e.message}")
+        "##{channel_id}"
+      end
+
+      def label_for(workspace, channel)
+        named = Support::GroupDmName.custom(channel)
+        return "##{named}" if named
+
+        names = member_names(workspace, channel['members'] || [])
+        return "@#{names.join(', ')}" if names.any?
+
+        "##{channel['name']}" unless channel['name'].to_s.empty?
+      end
+
+      def member_names(workspace, members)
+        self_id = self_user_id(workspace)
+        others = members.reject { |id| id == self_id }
+        others = members if others.empty?
+        others.map { |id| user_name(workspace, id) }
+      end
+
+      def user_name(workspace, user_id)
+        UserLookup.new(cache_store: @runner.cache_store, workspace: workspace,
+                       api_client: @runner.api_client, on_debug: @on_debug).resolve_name_or_bot(user_id) || user_id
+      end
+
+      # Same meta key the sent and who commands use, so one auth.test serves all.
+      def self_user_id(workspace)
+        @self_ids.fetch(workspace.name) do
+          @self_ids[workspace.name] = @runner.cache_store.get_meta(workspace.name, 'self_user_id') ||
+                                      fetch_self_user_id(workspace)
+        end
+      end
+
+      def fetch_self_user_id(workspace)
+        id = @runner.client_api(workspace.name).auth_test['user_id']
+        @runner.cache_store.set_meta(workspace.name, 'self_user_id', id) if id
+        id
+      rescue ApiError => e
+        @on_debug&.call("Could not identify self in #{workspace.name}: #{e.message}")
+        nil
+      end
+    end
+  end
+end

data/lib/slk/services/huddle_channel_label.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Turns a huddle channel id into a display label. A failed lookup is not
+    # a failed command: private channels and DMs the token cannot see still
+    # belong in the list, just without a name.
+    class HuddleChannelLabel
+      def initialize(runner:, cache_store:, on_debug: nil)
+        @runner = runner
+        @cache = cache_store
+        @on_debug = on_debug
+      end
+
+      def label(workspace, channel_id)
+        return nil if channel_id.to_s.empty?
+
+        cached_label(workspace, channel_id) || fetch_label(workspace, channel_id)
+      end
+
+      private
+
+      def cached_label(workspace, channel_id)
+        name = @cache.get_channel_name(workspace.name, channel_id)
+        "##{name}" if name
+      end
+
+      def fetch_label(workspace, channel_id)
+        label_from(workspace, channel_id, channel_info(workspace, channel_id))
+      rescue ApiError => e
+        @on_debug&.call("Channel lookup failed for #{channel_id}: #{e.message}")
+        nil
+      end
+
+      def channel_info(workspace, channel_id)
+        @runner.conversations_api(workspace.name).info(channel: channel_id)['channel'] || {}
+      end
+
+      def label_from(workspace, channel_id, channel)
+        return 'DM' if channel['is_im']
+        return group_label(channel) if channel['is_mpim']
+
+        named_label(workspace, channel_id, channel['name'])
+      end
+
+      # A named group DM shows its name but stays out of the channel cache:
+      # the name can be changed at any time and can match a real channel's
+      # name, and the cache maps names to ids, so `#name` would go to the chat.
+      def group_label(channel)
+        name = Support::GroupDmName.custom(channel)
+        name ? "##{name}" : 'group DM'
+      end
+
+      def named_label(workspace, channel_id, name)
+        return nil if name.to_s.empty?
+
+        @cache.set_channel(workspace.name, name, channel_id)
+        "##{name}"
+      end
+    end
+  end
+end