slk 0.14.0 → 0.16.0

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

@@ -38,11 +38,19 @@ module Slk
 
       def label_from(workspace, channel_id, channel)
         return 'DM' if channel['is_im']
-        return 'group DM' if channel['is_mpim']
+        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?
 

data/lib/slk/services/huddle_fetch.rb

@@ -13,6 +13,7 @@ module Slk
         @output = output
         @counts = {}
         @mutex = Mutex.new
+        @cache_mutex = Mutex.new
       end
 
       def call(workspaces)
@@ -30,7 +31,8 @@ module Slk
       def fetch(workspace)
         client = scan_client
         users = Api::Users.new(client, workspace, on_debug: debug_logger)
-        HuddleScanner.group(collect(workspace, users))
+        huddles = HuddleScanner.group(collect(workspace, users))
+        enricher(workspace, client).call(huddles)
       ensure
         close_client(client)
       end
@@ -49,6 +51,13 @@ module Slk
         Models::WorkspaceHuddles.new(workspace: workspace.name, huddles: labeled)
       end
 
+      def enricher(workspace, client)
+        HuddleRoomEnricher.new(
+          workspace: workspace, client: client, cache_store: @runner.cache_store,
+          cache_mutex: @cache_mutex, on_debug: debug_logger
+        )
+      end
+
       def scan_client
         return @runner.api_client.isolated if @parallel
 

data/lib/slk/services/huddle_room.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Fills in what a profile no longer says about a huddle.
+    #
+    # Slack stopped sending huddle_state_channel_id; profiles carry only the
+    # state and the call id. huddles.get maps the call id to its channel and
+    # the full participant list, which includes Slack Connect guests who are
+    # missing from users.list. A huddle the token cannot see is left as is.
+    class HuddleRoom
+      Room = Data.define(:channel_id, :participant_ids)
+
+      def initialize(api_client:, workspace:, on_debug: nil)
+        @api = Api::Huddles.new(api_client, workspace)
+        @on_debug = on_debug
+      end
+
+      # @return [Room, nil]
+      def lookup(call_id)
+        return nil if call_id.to_s.empty?
+
+        room = @api.get(call_id)
+        return nil if room.empty? || room['has_ended']
+
+        Room.new(channel_id: single_channel(room), participant_ids: Array(room['participants']))
+      rescue ApiError => e
+        @on_debug&.call("huddles.get #{call_id} failed: #{e.message}")
+        nil
+      end
+
+      # A profile's channel id if Slack sent one, else the room's.
+      def channel_for(profile)
+        return profile.huddle_channel_id unless profile.huddle_channel_id.to_s.empty?
+
+        lookup(profile.huddle_call_id)&.channel_id
+      end
+
+      private
+
+      def single_channel(room)
+        channels = Array(room['channels']).reject { |id| id.to_s.empty? }.uniq
+        channels.first if channels.one?
+      end
+    end
+  end
+end

data/lib/slk/services/huddle_room_enricher.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Adds what profiles no longer say to one workspace's huddles: the
+    # channel, and Slack Connect guests missing from users.list.
+    #
+    # huddles.get runs once per call id, and users.info once per guest whose
+    # name is not cached, both on a small worker pool so a busy workspace
+    # does not wait on dozens of requests in a row. Workspaces are scanned
+    # concurrently too, so cache reads and writes go through cache_mutex.
+    class HuddleRoomEnricher
+      WORKERS = 4
+
+      def initialize(workspace:, client:, cache_store:, cache_mutex:, on_debug: nil)
+        @workspace = workspace
+        @client = client
+        @cache = cache_store
+        @cache_mutex = cache_mutex
+        @on_debug = on_debug
+      end
+
+      def call(huddles)
+        rooms = fan_out(huddles) { |huddle, client| room_for(huddle, client) }
+        names = guest_names(guest_ids(huddles, rooms))
+        HuddleScanner.sort(huddles.zip(rooms).map { |huddle, room| apply(huddle, room, names) })
+      end
+
+      private
+
+      def fan_out(items, &)
+        PooledFanout.call(items, workers: WORKERS, client: @client, &)
+      end
+
+      def room_for(huddle, client)
+        return nil if huddle.channel_id || huddle.call_id.nil?
+
+        HuddleRoom.new(api_client: client, workspace: @workspace, on_debug: @on_debug).lookup(huddle.call_id)
+      end
+
+      def guest_ids(huddles, rooms)
+        huddles.zip(rooms).flat_map do |huddle, room|
+          room ? room.participant_ids - huddle.participants.map(&:id) : []
+        end.uniq
+      end
+
+      def guest_names(ids)
+        cached = cached_names(ids)
+        missing = ids - cached.keys
+        fetched = missing.zip(fan_out(missing) { |id, client| fetch_name(id, client) }).to_h.compact
+        remember(fetched)
+        cached.merge(fetched)
+      end
+
+      def cached_names(ids)
+        @cache_mutex.synchronize { ids.to_h { |id| [id, @cache.get_user(@workspace.name, id)] }.compact }
+      end
+
+      def fetch_name(user_id, client)
+        user = Api::Users.new(client, @workspace, on_debug: @on_debug).info(user_id)['user']
+        user && Models::User.from_api(user).best_name
+      rescue ApiError => e
+        @on_debug&.call("User lookup failed for #{user_id}: #{e.message}")
+        nil
+      end
+
+      def remember(names)
+        return if names.empty?
+
+        @cache_mutex.synchronize do
+          names.each { |id, name| @cache.set_user(@workspace.name, id, name) }
+          @cache.save_user_cache(@workspace.name)
+        end
+      end
+
+      def apply(huddle, room, names)
+        return huddle unless room
+
+        known = huddle.participants.map(&:id)
+        added = (room.participant_ids - known).map do |id|
+          Models::HuddleParticipant.new(id: id, name: names[id] || id)
+        end
+        huddle.with(channel_id: room.channel_id,
+                    participants: HuddleScanner.sort_participants(huddle.participants + added))
+      end
+    end
+  end
+end

data/lib/slk/services/huddle_scanner.rb

@@ -26,12 +26,22 @@ module Slk
         member.dig('profile', 'huddle_state') == IN_HUDDLE
       end
 
+      def self.sort(huddles)
+        huddles.sort_by do |huddle|
+          [-huddle.participants.size, huddle.participants.first.name.downcase, huddle.call_id.to_s]
+        end
+      end
+
+      def self.sort_participants(people)
+        people.sort_by { |person| [person.name.downcase, person.id] }
+      end
+
       def initialize(members)
         @members = members
       end
 
       def group
-        huddles.sort_by { |huddle| sort_key(huddle) }
+        self.class.sort(huddles)
       end
 
       private
@@ -67,7 +77,7 @@ module Slk
       end
 
       def sorted_participants(people)
-        people.map { |member| participant(member) }.sort_by { |person| [person.name.downcase, person.id] }
+        self.class.sort_participants(people.map { |member| participant(member) })
       end
 
       def participant(member)
@@ -92,10 +102,6 @@ module Slk
         text = value.to_s
         text.empty? ? nil : text
       end
-
-      def sort_key(huddle)
-        [-huddle.participants.size, huddle.participants.first.name.downcase, huddle.call_id.to_s]
-      end
     end
   end
 end

data/lib/slk/services/pooled_fanout.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Slk
+  module Services
+    # Runs a block per item on a few worker threads, each with its own
+    # connection, and returns the results in the original order.
+    #
+    # Net::HTTP is not safe to share across threads, so every worker gets an
+    # isolated client and closes it when the queue is empty. A client that
+    # cannot isolate (a test double) runs the items one at a time on itself.
+    # A failure waits for the other workers, then raises.
+    module PooledFanout
+      module_function
+
+      def call(items, workers:, client:, &block)
+        return items.map { |item| block.call(item, client) } unless pooled?(items, workers, client)
+
+        queue = Queue.new
+        items.each_with_index { |item, index| queue << [item, index] }
+        queue.close
+        results = Array.new(items.size)
+        threads = Array.new([workers, items.size].min) { start(queue, results, client, &block) }
+        wait_for_all(threads)
+        threads.each(&:value)
+        results
+      end
+
+      # Thread#join re-raises a worker's exception at once, which would
+      # return before the other workers close their connections.
+      def wait_for_all(threads)
+        threads.each do |thread|
+          thread.join
+        rescue StandardError
+          nil
+        end
+      end
+
+      def pooled?(items, workers, client)
+        workers > 1 && items.size > 1 && client.respond_to?(:isolated)
+      end
+
+      def start(queue, results, client, &block)
+        worker_client = client.isolated
+        Thread.new { drain(queue, results, worker_client, &block) }.tap do |thread|
+          thread.report_on_exception = false
+        end
+      end
+
+      def drain(queue, results, client, &block)
+        while (job = queue.pop)
+          item, index = job
+          results[index] = block.call(item, client)
+        end
+      ensure
+        client.close if client.respond_to?(:close)
+      end
+    end
+  end
+end

data/lib/slk/services/sent_channel_label.rb

@@ -5,6 +5,7 @@ module Slk
     # Resolves sent-conversation destinations while retaining raw channel IDs
     # and names in JSON. Group DMs need member lookup: their Slack name is an
     # opaque mpdm-* slug, not a user ID that MentionReplacer can resolve.
+    # Named group DMs ("named chats") skip that and show as #name.
     class SentChannelLabel
       USER_ID_PATTERN = /\A[UW][A-Z0-9]+\z/
 
@@ -28,6 +29,9 @@ module Slk
       private
 
       def group_label(workspace, channel_id, name, self_user_id, self_username)
+        named = Support::GroupDmName.label(name)
+        return named if named
+
         names = group_member_names(workspace, channel_id, self_user_id)
         return "@#{names.join(', ')}" if names.any?
 

data/lib/slk/services/target_resolver.rb

@@ -66,19 +66,8 @@ module Slk
       end
 
       def resolve_channel(workspace, name)
-        cached = @cache.get_channel_id(workspace.name, name)
-        return cached if cached
-
-        fetch_and_cache_channel(workspace, name)
-      end
-
-      def fetch_and_cache_channel(workspace, name)
-        channels = @runner.conversations_api(workspace.name).list['channels'] || []
-        channel = channels.find { |c| c['name'] == name }
-        raise ConfigError, "Channel not found: ##{name}" unless channel
-
-        @cache.set_channel(workspace.name, name, channel['id'])
-        channel['id']
+        ChannelLookup.new(runner: @runner, cache_store: @cache).find_id(workspace, name) ||
+          raise(ConfigError, "Channel not found: ##{name}")
       end
 
       def resolve_dm(workspace, username)

data/lib/slk/services/unread_marker.rb

@@ -14,13 +14,15 @@ module Slk
 
       # Mark all unreads in a workspace, return counts
       # @param options [Hash] :muted - include muted channels
-      # @return [Hash] { dms: count, channels: count, threads: count }
+      # @return [Hash] { dms: count, group_dms: count, channels: count, threads: count }
       def mark_all(options: {})
         counts = @client.counts
+        muted_ids = options[:muted] ? [] : @users.muted_channels
 
         {
           dms: mark_dms(counts['ims'] || []),
-          channels: mark_channels(counts['channels'] || [], muted: options[:muted]),
+          group_dms: mark_channels(counts['mpims'] || [], muted_ids),
+          channels: mark_channels(counts['channels'] || [], muted_ids),
           threads: mark_threads
         }
       end
@@ -44,13 +46,14 @@ module Slk
         count
       end
 
-      def mark_channels(channels, muted: false)
-        muted_ids = muted ? [] : @users.muted_channels
+      # Channels and group DMs (client.counts `mpims`): a muted group DM is
+      # skipped the same way a muted channel is.
+      def mark_channels(channels, muted_ids)
         count = 0
 
         channels.each do |channel|
           next unless channel['has_unreads']
-          next if !muted && muted_ids.include?(channel['id'])
+          next if muted_ids.include?(channel['id'])
 
           count += 1 if mark_conversation(channel['id'])
         end

data/lib/slk/support/group_dm_name.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Slk
+  module Support
+    # Group DMs can be given a name in Slack ("named chats"). They are still
+    # mpims, but `name` holds what the user typed ("ifams review") rather
+    # than the generated mpdm-alice--bob-1 slug. conversations.info flags them
+    # with properties.has_custom_mpdm_name; search.messages sends no
+    # properties, so a name that isn't an mpdm-* slug counts as custom too.
+    module GroupDmName
+      SLUG = /\Ampdm-/
+
+      module_function
+
+      # @param channel [Hash] conversation payload from Slack
+      # @return [String, nil] the custom name, or nil for anything else
+      def custom(channel)
+        return nil unless channel.is_a?(Hash) && channel['is_mpim']
+
+        name = channel['name'].to_s
+        return nil if name.empty?
+        return name if channel.dig('properties', 'has_custom_mpdm_name')
+
+        custom_name?(name) ? name : nil
+      end
+
+      # @param name [String, nil] a group DM's Slack name
+      # @return [Boolean] true when the name was set by a person
+      def custom_name?(name)
+        !name.to_s.empty? && !name.to_s.match?(SLUG)
+      end
+
+      # @return [String, nil] "#name" for a named group DM, else nil
+      def label(name)
+        "##{name}" if custom_name?(name)
+      end
+    end
+  end
+end

data/lib/slk/support/user_resolver.rb

@@ -68,6 +68,8 @@ module Slk
       public
 
       # Resolves a channel ID to a formatted label (@username or #channel)
+      # Group DMs get "#name" when named, else "@other, members", never the
+      # mpdm-* slug that other lookups may have put in the channel cache.
       # @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"
@@ -97,8 +99,11 @@ module Slk
       end
 
       def resolve_channel_label(workspace, channel_id)
+        known = group_dm_label.known(workspace, channel_id)
+        return known if known
+
         cached_name = cache_store.get_channel_name(workspace.name, channel_id)
-        return "##{cached_name}" if cached_name
+        return "##{cached_name}" if cached_name && !cached_name.match?(Support::GroupDmName::SLUG)
 
         fetch_channel_label(workspace, channel_id)
       end
@@ -108,16 +113,27 @@ module Slk
         response = conversations.info(channel: channel_id)
         return "##{channel_id}" unless response['ok'] && response['channel']
 
-        name = response['channel']['name']
-        return "##{channel_id}" unless name
+        channel = response['channel']
+        return group_dm_label.label_from(workspace, channel_id, channel) if channel['is_mpim']
 
-        cache_store.set_channel(workspace.name, name, channel_id)
-        "##{name}"
+        named_channel_label(workspace, channel_id, channel['name'])
       rescue ApiError => e
         debug("Channel info lookup failed for #{channel_id}: #{e.message}")
         "##{channel_id}"
       end
 
+      def named_channel_label(workspace, channel_id, name)
+        return "##{channel_id}" unless name
+
+        cache_store.set_channel(workspace.name, name, channel_id)
+        "##{name}"
+      end
+
+      # One per command run, so a group DM is looked up once for all headers.
+      def group_dm_label
+        @group_dm_label ||= Services::GroupDmLabel.new(runner: runner, on_debug: ->(msg) { debug(msg) })
+      end
+
       def name_from_user_profile(msg)
         return nil unless msg['user_profile']
 

data/lib/slk/version.rb

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