slk 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '09f740d5f0c6a9290031f4e94edff1bb118c85c80df51ccc4ef98b1dea6800a2'
-  data.tar.gz: 298d8188fd6bf43a07c8672523d9df253eff44dfe9481a0801d01062b161c8fd
+  metadata.gz: f633ce48448a37653aed188faa126b5f5d009a3c393128602ee5cb3ac01ff469
+  data.tar.gz: a9a342b35df6960696c800e6007c3cdab422edd0d3132e82e3bd7f91d4a8aeb4
 SHA512:
-  metadata.gz: dca5ad190d8155a4312bbafc39def037d1dfc9401170a58cc9adc2f22d6bbb4645efc7bcfd383e2be5d29b31c4f794da518f182df62182c47445fe3deec5d625
-  data.tar.gz: cba53cbbf73ed98c220bc984150792bd44e832992be70e62e62d425e2f0a6885f1414a1fe027d1d07ad449c1bef374f12aa2cc12814fda4cfe5bde9844df9f46
+  metadata.gz: 3422fcd166300be8a976c6996107c9e95623a1ee24d6850c365c8da8f14e57e81d089902405b027fc5552006ad38468a326b79a8fdfc49916abef875f36c5b6a
+  data.tar.gz: 23def7efe41b31edbe1791e8baf603676d4250ff04d92d0ef90932ae8682bcf3a6babdc9c514f40f64e980703afc9d1057bb70ab9a46380b8a038520ba9de160

data/CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [Unreleased]
+
+<!-- TODO: Remove post_install_message from slk.gemspec before releasing 0.3.0 -->
+
+## [0.2.0] - 2025-01-15
+
+### Added
+
+- `--workspace-emoji` flag for messages command to display custom workspace emoji as inline images (experimental, requires iTerm2/WezTerm/Mintty)
+- JSON output now includes resolved user and channel names for `messages`, `activity`, and `unread` commands
+
+### Changed
+
+- Config/cache directories renamed from `slack-cli` to `slk`
+- Repository renamed from `slack-cli` to `slk`
+
+### Fixed
+
+- `error()` helper now returns exit code 1 for proper shell exit status
+
 ## [0.1.0] - 2025-01-14
 
 Initial release of the Ruby rewrite. Pure Ruby, no external dependencies.
@@ -43,4 +63,5 @@ Initial release of the Ruby rewrite. Pure Ruby, no external dependencies.
   - Pure Ruby stdlib - no gem dependencies
   - Ruby 3.2+ with modern features (Data.define, pattern matching)
 
-[0.1.0]: https://github.com/ericboehs/slack-cli/releases/tag/v0.1.0
+[0.2.0]: https://github.com/ericboehs/slk/releases/tag/v0.2.0
+[0.1.0]: https://github.com/ericboehs/slk/releases/tag/v0.1.0

data/README.md

@@ -151,17 +151,17 @@ Optionally encrypt your tokens with [age](https://github.com/FiloSottile/age) us
 slk config set ssh_key ~/.ssh/id_ed25519
 ```
 
-Tokens will be stored encrypted in `~/.config/slack-cli/tokens.age`.
+Tokens will be stored encrypted in `~/.config/slk/tokens.age`.
 
 ## Configuration
 
 Files are stored in XDG-compliant locations:
 
-- **Config**: `~/.config/slack-cli/`
+- **Config**: `~/.config/slk/`
   - `config.json` - Settings
   - `tokens.json` or `tokens.age` - Workspace tokens
   - `presets.json` - Status presets
-- **Cache**: `~/.cache/slack-cli/`
+- **Cache**: `~/.cache/slk/`
   - `users-{workspace}.json` - User cache
   - `channels-{workspace}.json` - Channel cache
 
@@ -169,8 +169,8 @@ Files are stored in XDG-compliant locations:
 
 ```bash
 # Clone the repo
-git clone https://github.com/ericboehs/slack-cli.git
-cd slack-cli
+git clone https://github.com/ericboehs/slk.git
+cd slk
 
 # Run from source
 ruby -Ilib bin/slk --version

data/bin/slk

@@ -1,7 +1,7 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-$LOAD_PATH.unshift(File.expand_path("../lib", __dir__))
-require "slack_cli"
+$LOAD_PATH.unshift(File.expand_path('../lib', __dir__))
+require 'slk'
 
-exit SlackCli::CLI.new(ARGV).run
+exit Slk::CLI.new(ARGV).run

data/lib/{slack_cli → slk}/api/activity.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Api
+    # Wrapper for the Slack activity.feed API endpoint
     class Activity
       def initialize(api_client, workspace)
         @api = api_client
@@ -9,20 +10,18 @@ module SlackCli
       end
 
       def feed(limit: 50, types: nil, cursor: nil, mode: 'priority_reads_and_unreads_v1')
-        params = {
-          mode: mode,
-          limit: limit.to_s,
-          archive_only: 'false',
-          snooze_only: 'false',
-          unread_only: 'false',
-          priority_only: 'false',
-          is_activity_inbox: 'false'
-        }
+        params = build_feed_params(mode, limit)
         params[:types] = types if types
         params[:cursor] = cursor if cursor
-
         @api.post_form(@workspace, 'activity.feed', params)
       end
+
+      private
+
+      def build_feed_params(mode, limit)
+        { mode: mode, limit: limit.to_s, archive_only: 'false', snooze_only: 'false',
+          unread_only: 'false', priority_only: 'false', is_activity_inbox: 'false' }
+      end
     end
   end
 end

data/lib/{slack_cli → slk}/api/bots.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Api
+    # Wrapper for Slack bots.info API endpoint
     class Bots
       def initialize(api_client, workspace, on_debug: nil)
         @api = api_client
@@ -13,8 +14,8 @@ module SlackCli
       # @param bot_id [String] Bot ID starting with "B"
       # @return [Hash, nil] Bot info hash or nil if not found
       def info(bot_id)
-        response = @api.post_form(@workspace, "bots.info", { bot: bot_id })
-        response["bot"] if response["ok"]
+        response = @api.post_form(@workspace, 'bots.info', { bot: bot_id })
+        response['bot'] if response['ok']
       rescue ApiError => e
         @on_debug&.call("Bot lookup failed for #{bot_id}: #{e.message}")
         nil
@@ -25,7 +26,7 @@ module SlackCli
       # @return [String, nil] Bot name or nil if not found
       def get_name(bot_id)
         bot = info(bot_id)
-        bot&.dig("name")
+        bot&.dig('name')
       end
     end
   end

data/lib/slk/api/client.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Slk
+  module Api
+    # Wrapper for Slack client.counts and auth.test API endpoints
+    class Client
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      end
+
+      def counts
+        @api.post(@workspace, 'client.counts')
+      end
+
+      def auth_test
+        @api.post(@workspace, 'auth.test')
+      end
+
+      def team_id
+        @team_id ||= auth_test['team_id']
+      end
+
+      def unread_channels
+        response = counts
+        channels = response['channels'] || []
+
+        channels.select { |ch| (ch['mention_count'] || 0).positive? || ch['has_unreads'] }
+      end
+
+      def unread_dms
+        response = counts
+        dms = response['ims'] || []
+        mpims = response['mpims'] || []
+
+        (dms + mpims).select { |dm| (dm['mention_count'] || 0).positive? || dm['has_unreads'] }
+      end
+
+      def total_unread_count
+        response = counts
+        sum_mentions(response, 'channels') + sum_mentions(response, 'ims') + sum_mentions(response, 'mpims')
+      end
+
+      private
+
+      def sum_mentions(response, key)
+        (response[key] || []).sum { |item| item['mention_count'] || 0 }
+      end
+    end
+  end
+end

data/lib/{slack_cli → slk}/api/conversations.rb

@@ -1,17 +1,18 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Api
+    # Wrapper for Slack conversations.* API endpoints
     class Conversations
       def initialize(api_client, workspace)
         @api = api_client
         @workspace = workspace
       end
 
-      def list(cursor: nil, limit: 1000, types: "public_channel,private_channel")
+      def list(cursor: nil, limit: 1000, types: 'public_channel,private_channel')
         params = { limit: limit, types: types }
         params[:cursor] = cursor if cursor
-        @api.post(@workspace, "conversations.list", params)
+        @api.post(@workspace, 'conversations.list', params)
       end
 
       def history(channel:, limit: 20, cursor: nil, oldest: nil, latest: nil)
@@ -19,33 +20,33 @@ module SlackCli
         params[:cursor] = cursor if cursor
         params[:oldest] = oldest if oldest
         params[:latest] = latest if latest
-        @api.post(@workspace, "conversations.history", params)
+        @api.post(@workspace, 'conversations.history', params)
       end
 
-      def replies(channel:, ts:, limit: 100, cursor: nil)
-        params = { channel: channel, ts: ts, limit: limit }
+      def replies(channel:, timestamp:, limit: 100, cursor: nil)
+        params = { channel: channel, ts: timestamp, limit: limit }
         params[:cursor] = cursor if cursor
         # Use form encoding - some workspaces (Enterprise Grid) require it
-        @api.post_form(@workspace, "conversations.replies", params)
+        @api.post_form(@workspace, 'conversations.replies', params)
       end
 
       def open(users:)
-        user_list = Array(users).join(",")
-        @api.post(@workspace, "conversations.open", { users: user_list })
+        user_list = Array(users).join(',')
+        @api.post(@workspace, 'conversations.open', { users: user_list })
       end
 
-      def mark(channel:, ts:)
-        @api.post(@workspace, "conversations.mark", { channel: channel, ts: ts })
+      def mark(channel:, timestamp:)
+        @api.post(@workspace, 'conversations.mark', { channel: channel, ts: timestamp })
       end
 
       def info(channel:)
-        @api.post_form(@workspace, "conversations.info", { channel: channel })
+        @api.post_form(@workspace, 'conversations.info', { channel: channel })
       end
 
       def members(channel:, cursor: nil, limit: 100)
         params = { channel: channel, limit: limit }
         params[:cursor] = cursor if cursor
-        @api.post(@workspace, "conversations.members", params)
+        @api.post(@workspace, 'conversations.members', params)
       end
     end
   end

data/lib/slk/api/dnd.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Slk
+  module Api
+    # Wrapper for Slack dnd.* (Do Not Disturb) API endpoints
+    class Dnd
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      end
+
+      def info
+        @api.post(@workspace, 'dnd.info')
+      end
+
+      def set_snooze(duration) # rubocop:disable Naming/AccessorMethodName
+        minutes = duration.to_minutes
+        @api.post(@workspace, 'dnd.setSnooze', { num_minutes: minutes })
+      end
+
+      def end_snooze
+        @api.post(@workspace, 'dnd.endSnooze')
+      end
+
+      def snoozing?
+        info['snooze_enabled'] == true
+      end
+
+      def snooze_remaining
+        data = info
+        return nil unless data['snooze_enabled']
+
+        endtime = data['snooze_endtime']
+        return nil unless endtime
+
+        remaining = endtime - Time.now.to_i
+        remaining.positive? ? Models::Duration.new(seconds: remaining) : nil
+      end
+    end
+  end
+end

data/lib/{slack_cli → slk}/api/emoji.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Api
+    # Wrapper for Slack emoji.list API endpoint
     class Emoji
       def initialize(api_client, workspace)
         @api = api_client
@@ -9,12 +10,12 @@ module SlackCli
       end
 
       def list
-        @api.post(@workspace, "emoji.list")
+        @api.post(@workspace, 'emoji.list')
       end
 
       def custom_emoji
         response = list
-        response["emoji"] || {}
+        response['emoji'] || {}
       end
     end
   end

data/lib/{slack_cli → slk}/api/threads.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Api
+    # Wrapper for Slack thread subscription API endpoints
     class Threads
       def initialize(api_client, workspace)
         @api = api_client
@@ -12,32 +13,32 @@ module SlackCli
       # @param limit [Integer] Max threads to return
       # @return [Hash] Response with threads and total_unread_replies
       def get_view(limit: 20)
-        @api.post(@workspace, "subscriptions.thread.getView", { limit: limit })
+        @api.post(@workspace, 'subscriptions.thread.getView', { limit: limit })
       end
 
       # Mark a thread as read
       # @param channel [String] Channel ID
       # @param thread_ts [String] Thread timestamp
-      # @param ts [String] Latest reply timestamp to mark as read
-      def mark(channel:, thread_ts:, ts:)
-        @api.post_form(@workspace, "subscriptions.thread.mark", {
-          channel: channel,
-          thread_ts: thread_ts,
-          ts: ts
-        })
+      # @param timestamp [String] Latest reply timestamp to mark as read
+      def mark(channel:, thread_ts:, timestamp:)
+        @api.post_form(@workspace, 'subscriptions.thread.mark', {
+                         channel: channel,
+                         thread_ts: thread_ts,
+                         ts: timestamp
+                       })
       end
 
       # Get unread thread count
       # @return [Integer] Number of unread thread replies
       def unread_count
         response = get_view(limit: 1)
-        response["total_unread_replies"] || 0
+        response['total_unread_replies'] || 0
       end
 
       # Check if there are unread threads
       # @return [Boolean]
-      def has_unreads?
-        unread_count > 0
+      def unreads?
+        unread_count.positive?
       end
     end
   end

data/lib/{slack_cli → slk}/api/usergroups.rb

@@ -1,7 +1,8 @@
 # frozen_string_literal: true
 
-module SlackCli
+module Slk
   module Api
+    # Wrapper for Slack usergroups.list API endpoint
     class Usergroups
       def initialize(api_client, workspace)
         @api = api_client

data/lib/slk/api/users.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Slk
+  module Api
+    # Wrapper for Slack users.* API endpoints
+    class Users
+      def initialize(api_client, workspace, on_debug: nil)
+        @api = api_client
+        @workspace = workspace
+        @on_debug = on_debug
+      end
+
+      def get_profile # rubocop:disable Naming/AccessorMethodName
+        response = @api.post(@workspace, 'users.profile.get')
+        response['profile']
+      end
+
+      def get_status # rubocop:disable Naming/AccessorMethodName
+        profile = get_profile
+        Models::Status.new(
+          text: profile['status_text'] || '',
+          emoji: profile['status_emoji'] || '',
+          expiration: profile['status_expiration'] || 0
+        )
+      end
+
+      def set_status(text:, emoji: nil, duration: nil)
+        expiration = duration&.to_expiration || 0
+
+        @api.post(@workspace, 'users.profile.set', {
+                    profile: {
+                      status_text: text,
+                      status_emoji: emoji || '',
+                      status_expiration: expiration
+                    }
+                  })
+      end
+
+      def clear_status
+        set_status(text: '', emoji: '', duration: nil)
+      end
+
+      def get_presence # rubocop:disable Naming/AccessorMethodName
+        response = @api.post(@workspace, 'users.getPresence')
+        {
+          presence: response['presence'],
+          manual_away: response['manual_away'],
+          online: response['online']
+        }
+      end
+
+      def set_presence(presence) # rubocop:disable Naming/AccessorMethodName
+        @api.post(@workspace, 'users.setPresence', { presence: presence })
+      end
+
+      def list(cursor: nil, limit: 1000)
+        params = { limit: limit }
+        params[:cursor] = cursor if cursor
+        @api.post(@workspace, 'users.list', params)
+      end
+
+      def info(user_id)
+        @api.post_form(@workspace, 'users.info', { user: user_id })
+      end
+
+      def get_prefs # rubocop:disable Naming/AccessorMethodName
+        @api.post(@workspace, 'users.prefs.get')
+      end
+
+      def muted_channels
+        prefs = get_prefs
+        parse_legacy_muted_channels(prefs) || parse_new_muted_channels(prefs) || []
+      end
+
+      private
+
+      def parse_legacy_muted_channels(prefs)
+        muted = prefs.dig('prefs', 'muted_channels')
+        return nil unless muted.is_a?(String) && !muted.empty?
+
+        muted.split(',').reject(&:empty?)
+      end
+
+      def parse_new_muted_channels(prefs)
+        notifications_prefs = prefs.dig('prefs', 'all_notifications_prefs')
+        return nil unless notifications_prefs.is_a?(String) && !notifications_prefs.empty?
+
+        parsed = JSON.parse(notifications_prefs)
+        channels = parsed['channels'] || {}
+        channels.select { |_id, opts| opts['muted'] == true }.keys
+      rescue JSON::ParserError => e
+        @on_debug&.call("Failed to parse notification prefs: #{e.message}")
+        nil
+      end
+
+      public
+
+      def conversations(cursor: nil, limit: 1000)
+        params = { limit: limit, types: 'public_channel,private_channel,mpim,im' }
+        params[:cursor] = cursor if cursor
+        @api.post_form(@workspace, 'users.conversations', params)
+      end
+    end
+  end
+end

data/lib/slk/cli.rb

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+module Slk
+  # Command-line interface entry point that dispatches to commands
+  # rubocop:disable Metrics/ClassLength
+  class CLI
+    COMMANDS = {
+      'status' => Commands::Status,
+      'presence' => Commands::Presence,
+      'dnd' => Commands::Dnd,
+      'messages' => Commands::Messages,
+      'thread' => Commands::Thread,
+      'unread' => Commands::Unread,
+      'catchup' => Commands::Catchup,
+      'activity' => Commands::Activity,
+      'preset' => Commands::Preset,
+      'workspaces' => Commands::Workspaces,
+      'cache' => Commands::Cache,
+      'emoji' => Commands::Emoji,
+      'config' => Commands::Config,
+      'help' => Commands::Help
+    }.freeze
+
+    def initialize(argv, output: nil)
+      @argv = argv.dup
+      @output = output || Formatters::Output.new
+    end
+
+    def run
+      command_name, *args = @argv
+
+      return show_help if help_requested?(command_name)
+      return show_version if version_requested?(command_name)
+
+      dispatch_command(command_name, args)
+    rescue Interrupt
+      handle_interrupt
+    rescue StandardError => e
+      handle_error(e)
+    end
+
+    private
+
+    def help_requested?(command_name)
+      command_name.nil? || command_name == '--help' || command_name == '-h'
+    end
+
+    def version_requested?(command_name)
+      ['--version', '-V', 'version'].include?(command_name)
+    end
+
+    def show_help
+      run_command('help', [])
+    end
+
+    def show_version
+      @output.puts "slk v#{VERSION}"
+      0
+    end
+
+    def dispatch_command(command_name, args)
+      if COMMANDS[command_name]
+        run_command(command_name, args)
+      elsif preset_exists?(command_name)
+        run_command('preset', [command_name] + args)
+      else
+        show_unknown_command(command_name)
+      end
+    rescue ConfigError, EncryptionError, ApiError => e
+      handle_known_error(e)
+    end
+
+    def show_unknown_command(command_name)
+      @output.error("Unknown command: #{command_name}")
+      @output.puts
+      @output.puts "Run 'slk help' for available commands."
+      1
+    end
+
+    def handle_known_error(error)
+      label = error_label(error)
+      @output.error(label ? "#{label}: #{error.message}" : error.message)
+      log_error(error)
+      1
+    end
+
+    def error_label(error)
+      case error
+      when EncryptionError then 'Encryption error'
+      when ApiError then 'API error'
+      end
+    end
+
+    def handle_interrupt
+      @output.puts
+      @output.puts 'Interrupted.'
+      130
+    end
+
+    def handle_error(error)
+      @output.error("Unexpected error: #{error.message}")
+      log_path = log_error(error)
+      @output.puts "Details logged to: #{log_path}" if log_path
+      1
+    end
+
+    def run_command(name, args)
+      command_class = COMMANDS[name]
+      return 1 unless command_class
+
+      runner = build_runner(args)
+      execute_command(command_class, args, runner)
+    ensure
+      runner&.api_client&.close
+    end
+
+    def build_runner(args)
+      verbose = args.include?('-v') || args.include?('--verbose')
+      output = Formatters::Output.new(verbose: verbose)
+      runner = Runner.new(output: output)
+      setup_verbose_logging(runner, output) if verbose
+      runner
+    end
+
+    def setup_verbose_logging(runner, output)
+      runner.api_client.on_request = lambda { |method, count|
+        output.debug("[API ##{count}] #{method}")
+      }
+    end
+
+    def execute_command(command_class, args, runner)
+      command = command_class.new(args, runner: runner)
+      result = command.execute
+      log_api_call_count(runner) if verbose_mode?(args)
+      result
+    end
+
+    def verbose_mode?(args)
+      args.include?('-v') || args.include?('--verbose')
+    end
+
+    def log_api_call_count(runner)
+      return unless runner.api_client.call_count.positive?
+
+      runner.output.debug("Total API calls: #{runner.api_client.call_count}")
+    end
+
+    def preset_exists?(name)
+      Services::PresetStore.new.exists?(name)
+    end
+
+    def log_error(error)
+      Support::ErrorLogger.log(error)
+    end
+  end
+  # rubocop:enable Metrics/ClassLength
+end