slk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: '09f740d5f0c6a9290031f4e94edff1bb118c85c80df51ccc4ef98b1dea6800a2'
+  data.tar.gz: 298d8188fd6bf43a07c8672523d9df253eff44dfe9481a0801d01062b161c8fd
+SHA512:
+  metadata.gz: dca5ad190d8155a4312bbafc39def037d1dfc9401170a58cc9adc2f22d6bbb4645efc7bcfd383e2be5d29b31c4f794da518f182df62182c47445fe3deec5d625
+  data.tar.gz: cba53cbbf73ed98c220bc984150792bd44e832992be70e62e62d425e2f0a6885f1414a1fe027d1d07ad449c1bef374f12aa2cc12814fda4cfe5bde9844df9f46

data/CHANGELOG.md

@@ -0,0 +1,46 @@
+# Changelog
+
+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).
+
+## [0.1.0] - 2025-01-14
+
+Initial release of the Ruby rewrite. Pure Ruby, no external dependencies.
+
+### Added
+
+- **Commands**
+  - `status` - Get or set your Slack status with emoji and duration
+  - `presence` - Toggle between active/away presence
+  - `dnd` - Manage Do Not Disturb (enable, disable, with duration)
+  - `messages` - Read channel or DM messages with reactions and threads
+  - `thread` - View message threads directly from URL
+  - `unread` - View and clear unread messages across workspaces
+  - `catchup` - Quick summary of mentions and DMs
+  - `activity` - View recent workspace activity (mentions, reactions, threads)
+  - `preset` - Define and apply status presets (status + presence + DND)
+  - `workspaces` - Manage multiple Slack workspaces
+  - `cache` - Manage user/channel name cache
+  - `emoji` - Download and search workspace custom emoji
+  - `config` - Interactive setup and configuration
+
+- **Features**
+  - Multi-workspace support with easy switching (`-w` flag or `--all`)
+  - Encrypted token storage using `age` with SSH keys
+  - XDG-compliant configuration directories
+  - HTTP connection reuse for better performance
+  - Inline emoji images in supported terminals (iTerm2, tmux)
+  - Reaction timestamps showing when users reacted
+  - Block Kit message rendering
+  - User and channel mention resolution
+  - Verbose mode (`-v`) for API call debugging
+  - JSON output mode (`--json`) for scripting
+
+- **Developer Experience**
+  - 542 tests with 1082 assertions
+  - 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

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Eric Boehs
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,190 @@
+# slk - Slack CLI
+
+A command-line interface for Slack. Manage your status, presence, DND, read messages, and more from the terminal.
+
+**Pure Ruby. No dependencies.**
+
+## Installation
+
+```bash
+gem install slk
+```
+
+Requires Ruby 3.2+.
+
+## Setup
+
+Run the setup wizard:
+
+```bash
+slk config setup
+```
+
+You'll need a Slack token. Get one from:
+- **User token (xoxp-)**: https://api.slack.com/apps → OAuth & Permissions
+- **Bot token (xoxb-)**: Create a Slack App with bot scopes
+- **Session token (xoxc-)**: Extract from browser (requires cookie too)
+
+## Usage
+
+### Status
+
+```bash
+slk status                              # Show current status
+slk status "Working from home" :house:  # Set status with emoji
+slk status "In a meeting" :calendar: 1h # Set status for 1 hour
+slk status clear                        # Clear status
+```
+
+### Presence
+
+```bash
+slk presence              # Show current presence
+slk presence away         # Set to away
+slk presence active       # Set to active
+```
+
+### Do Not Disturb
+
+```bash
+slk dnd                   # Show DND status
+slk dnd 1h                # Enable DND for 1 hour
+slk dnd on 30m            # Enable DND for 30 minutes
+slk dnd off               # Disable DND
+```
+
+### Messages
+
+```bash
+slk messages #general           # Read channel messages
+slk messages @username          # Read DM with user
+slk messages #general -n 50     # Show 50 messages
+slk messages #general --json    # Output as JSON
+```
+
+### Activity
+
+```bash
+slk activity              # Show recent activity feed
+slk activity -n 50        # Show 50 items
+slk activity -m           # Show message previews
+slk activity --reactions  # Filter: reactions only
+slk activity --mentions   # Filter: mentions only
+slk activity --threads    # Filter: thread replies only
+```
+
+Displays your recent activity feed including:
+- Reactions to your messages
+- Mentions (@user, @channel, @here, etc.)
+- Thread replies
+- Bot messages (reminders, notifications)
+
+Use `--show-messages` (or `-m`) to preview the actual message content for each activity.
+
+### Unread
+
+```bash
+slk unread                # Show unread counts
+slk unread clear          # Mark all as read
+slk unread clear #general # Mark channel as read
+```
+
+### Catchup (Interactive Triage)
+
+```bash
+slk catchup               # Interactively review unread channels
+slk catchup --batch       # Non-interactive, mark all as read
+```
+
+### Presets
+
+```bash
+slk preset list           # List all presets
+slk preset meeting        # Apply preset
+slk preset add            # Add new preset (interactive)
+slk meeting               # Shortcut: use preset name as command
+```
+
+Built-in presets: `meeting`, `lunch`, `focus`, `brb`, `clear`
+
+### Workspaces
+
+```bash
+slk workspaces list       # List configured workspaces
+slk workspaces add        # Add a workspace
+slk workspaces primary    # Show/set primary workspace
+```
+
+### Cache Management
+
+```bash
+slk cache status          # Show cache status
+slk cache populate        # Pre-populate user cache
+slk cache clear           # Clear all caches
+```
+
+### Global Options
+
+```bash
+-w, --workspace NAME   # Use specific workspace
+--all                  # Apply to all workspaces
+-v, --verbose          # Show debug output
+-q, --quiet            # Suppress output
+--json                 # Output as JSON (where supported)
+```
+
+## Multi-Workspace
+
+Configure multiple workspaces and switch between them:
+
+```bash
+slk workspaces add                    # Add another workspace
+slk status -w work                    # Check status on 'work' workspace
+slk status "OOO" --all                # Set status on all workspaces
+```
+
+## Token Encryption
+
+Optionally encrypt your tokens with [age](https://github.com/FiloSottile/age) using an SSH key:
+
+```bash
+slk config set ssh_key ~/.ssh/id_ed25519
+```
+
+Tokens will be stored encrypted in `~/.config/slack-cli/tokens.age`.
+
+## Configuration
+
+Files are stored in XDG-compliant locations:
+
+- **Config**: `~/.config/slack-cli/`
+  - `config.json` - Settings
+  - `tokens.json` or `tokens.age` - Workspace tokens
+  - `presets.json` - Status presets
+- **Cache**: `~/.cache/slack-cli/`
+  - `users-{workspace}.json` - User cache
+  - `channels-{workspace}.json` - Channel cache
+
+## Development
+
+```bash
+# Clone the repo
+git clone https://github.com/ericboehs/slack-cli.git
+cd slack-cli
+
+# Run from source
+ruby -Ilib bin/slk --version
+
+# Run tests
+rake test
+
+# Build gem
+gem build slk.gemspec
+
+# Install locally
+gem install ./slk-0.1.0.gem
+```
+
+## License
+
+MIT License. See [LICENSE](LICENSE) for details.

data/bin/slk

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

data/lib/slack_cli/api/activity.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Api
+    class Activity
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      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[:types] = types if types
+        params[:cursor] = cursor if cursor
+
+        @api.post_form(@workspace, 'activity.feed', params)
+      end
+    end
+  end
+end

data/lib/slack_cli/api/bots.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Api
+    class Bots
+      def initialize(api_client, workspace, on_debug: nil)
+        @api = api_client
+        @workspace = workspace
+        @on_debug = on_debug
+      end
+
+      # Look up bot information by ID
+      # @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"]
+      rescue ApiError => e
+        @on_debug&.call("Bot lookup failed for #{bot_id}: #{e.message}")
+        nil
+      end
+
+      # Get bot name by ID
+      # @param bot_id [String] Bot ID starting with "B"
+      # @return [String, nil] Bot name or nil if not found
+      def get_name(bot_id)
+        bot = info(bot_id)
+        bot&.dig("name")
+      end
+    end
+  end
+end

data/lib/slack_cli/api/client.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Api
+    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.dig("channels") || []
+
+        channels.select { |ch| (ch["mention_count"] || 0) > 0 || ch["has_unreads"] }
+      end
+
+      def unread_dms
+        response = counts
+        dms = response.dig("ims") || []
+        mpims = response.dig("mpims") || []
+
+        (dms + mpims).select { |dm| (dm["mention_count"] || 0) > 0 || dm["has_unreads"] }
+      end
+
+      def total_unread_count
+        response = counts
+
+        channel_count = (response.dig("channels") || []).sum { |c| c["mention_count"] || 0 }
+        dm_count = (response.dig("ims") || []).sum { |d| d["mention_count"] || 0 }
+        mpim_count = (response.dig("mpims") || []).sum { |m| m["mention_count"] || 0 }
+
+        channel_count + dm_count + mpim_count
+      end
+    end
+  end
+end

data/lib/slack_cli/api/conversations.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Api
+    class Conversations
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      end
+
+      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)
+      end
+
+      def history(channel:, limit: 20, cursor: nil, oldest: nil, latest: nil)
+        params = { channel: channel, limit: limit }
+        params[:cursor] = cursor if cursor
+        params[:oldest] = oldest if oldest
+        params[:latest] = latest if latest
+        @api.post(@workspace, "conversations.history", params)
+      end
+
+      def replies(channel:, ts:, limit: 100, cursor: nil)
+        params = { channel: channel, ts: ts, limit: limit }
+        params[:cursor] = cursor if cursor
+        # Use form encoding - some workspaces (Enterprise Grid) require it
+        @api.post_form(@workspace, "conversations.replies", params)
+      end
+
+      def open(users:)
+        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 })
+      end
+
+      def info(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)
+      end
+    end
+  end
+end

data/lib/slack_cli/api/dnd.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Api
+    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)
+        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 > 0 ? Models::Duration.new(seconds: remaining) : nil
+      end
+    end
+  end
+end

data/lib/slack_cli/api/emoji.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Api
+    class Emoji
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      end
+
+      def list
+        @api.post(@workspace, "emoji.list")
+      end
+
+      def custom_emoji
+        response = list
+        response["emoji"] || {}
+      end
+    end
+  end
+end

data/lib/slack_cli/api/threads.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Api
+    class Threads
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      end
+
+      # Get unread threads
+      # @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 })
+      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
+        })
+      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
+      end
+
+      # Check if there are unread threads
+      # @return [Boolean]
+      def has_unreads?
+        unread_count > 0
+      end
+    end
+  end
+end

data/lib/slack_cli/api/usergroups.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Api
+    class Usergroups
+      def initialize(api_client, workspace)
+        @api = api_client
+        @workspace = workspace
+      end
+
+      def list
+        @api.post(@workspace, 'usergroups.list')
+      end
+
+      def get_handle(subteam_id)
+        response = list
+        return nil unless response['ok']
+
+        usergroups = response['usergroups'] || []
+        group = usergroups.find { |g| g['id'] == subteam_id }
+        group&.dig('handle')
+      end
+    end
+  end
+end

data/lib/slack_cli/api/users.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module SlackCli
+  module Api
+    class Users
+      def initialize(api_client, workspace, on_debug: nil)
+        @api = api_client
+        @workspace = workspace
+        @on_debug = on_debug
+      end
+
+      def get_profile
+        response = @api.post(@workspace, "users.profile.get")
+        response["profile"]
+      end
+
+      def get_status
+        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
+        response = @api.post(@workspace, "users.getPresence")
+        {
+          presence: response["presence"],
+          manual_away: response["manual_away"],
+          online: response["online"]
+        }
+      end
+
+      def set_presence(presence)
+        @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
+        @api.post(@workspace, "users.prefs.get")
+      end
+
+      def muted_channels
+        prefs = get_prefs
+
+        # First try the legacy muted_channels format (comma-separated string)
+        muted = prefs.dig("prefs", "muted_channels")
+        if muted.is_a?(String) && !muted.empty?
+          return muted.split(",").reject(&:empty?)
+        end
+
+        # New format: muted channels are in all_notifications_prefs JSON string
+        # Structure: {"channels": {"C123": {"muted": true}, ...}}
+        notifications_prefs = prefs.dig("prefs", "all_notifications_prefs")
+        if notifications_prefs.is_a?(String) && !notifications_prefs.empty?
+          begin
+            parsed = JSON.parse(notifications_prefs)
+            channels = parsed["channels"] || {}
+            return channels.select { |_id, opts| opts["muted"] == true }.keys
+          rescue JSON::ParserError => e
+            @on_debug&.call("Failed to parse notification prefs: #{e.message}")
+          end
+        end
+
+        []
+      end
+
+      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