slk 0.6.0 → 0.8.0

data/lib/slk/models/scheduled_status.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module Slk
+  module Models
+    # A status queued to turn on later, from users.customStatus.list.
+    #
+    # Slack derives `duration` server-side from the window, so it is not
+    # modelled here — the window itself is the source of truth.
+    ScheduledStatus = Data.define(:id, :text, :emoji, :date_scheduled, :date_expire, :dnd, :active) do
+      def self.from_api(data)
+        validate!(data)
+
+        new(
+          id: data['id'].to_s,
+          text: data['text'].to_s,
+          emoji: data['emoji'].to_s,
+          date_scheduled: data['date_scheduled'].to_i,
+          date_expire: data['date_expire'].to_i,
+          dnd: truthy?(data['is_dnd']),
+          active: truthy?(data['is_active'])
+        )
+      end
+
+      # Every field is coerced, so without this guard any payload at all —
+      # a bare string, nil, a hash of unexpected keys — becomes a valid-looking
+      # record with an empty id that prints as a blank line and never matches
+      # the id the user asked about. An unusable record is a protocol change,
+      # not a status.
+      def self.validate!(data)
+        return if data.is_a?(Hash) && !data['id'].to_s.empty?
+
+        raise ApiError.new("Slack returned a scheduled status with no id: #{data.inspect[0, 120]}",
+                           code: :malformed_scheduled_status)
+      end
+      private_class_method :validate!
+
+      # These endpoints are string-typed on the way in — Api::CustomStatus sends
+      # is_dnd as 'true' — so a strict `== true` would quietly read a scheduled
+      # DND back as off. Accept the shapes Slack actually uses.
+      def self.truthy?(value) = [true, 'true', 1, '1'].include?(value)
+      private_class_method :truthy?
+
+      def starts_at = date_scheduled.positive? ? Time.at(date_scheduled) : nil
+      def ends_at = date_expire.positive? ? Time.at(date_expire) : nil
+
+      def to_s
+        span = window
+        [
+          emoji,
+          text,
+          span.empty? ? '' : "(#{span})",
+          ('[dnd]' if dnd),
+          # Slack marks the one that has already turned on. Worth showing: it
+          # is the difference between "will happen" and "is happening".
+          ('[active]' if active)
+        ].reject { |part| part.to_s.empty? }.join(' ')
+      end
+
+      # Human-readable window; the end date is only repeated when it differs
+      # from the start date, which makes multi-day windows obvious.
+      def window
+        dated = '%a %b %-d %-l:%M%P'
+        start_time = starts_at or return ''
+        formatted = start_time.strftime(dated)
+        finish = ends_at or return formatted
+
+        "#{formatted} -> #{finish.strftime(same_day?(start_time, finish) ? '%-l:%M%P' : dated)}"
+      end
+
+      private
+
+      def same_day?(start_time, finish)
+        start_time.to_date == finish.to_date
+      end
+    end
+  end
+end

data/lib/slk/models/status_snapshot.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module Slk
+  module Models
+    # Everything `slk status` knows about one workspace at one moment: the
+    # status itself, plus the two things that decide whether anyone can reach
+    # you (presence, DND) and whatever is queued to replace the status later.
+    #
+    # Every part but the status is optional, and nil means "not checked" —
+    # skipped by a flag, or a lookup that failed. That is deliberately distinct
+    # from checked-and-empty: `scheduled: []` says nothing is queued, while
+    # `scheduled: nil` says nobody looked.
+    StatusSnapshot = Data.define(:workspace, :status, :presence, :dnd, :scheduled) do
+      def initialize(workspace:, status:, presence: nil, dnd: nil, scheduled: nil)
+        super
+      end
+
+      def workspace_name = workspace.name
+
+      def away? = presence ? presence[:presence] == 'away' : false
+
+      # Short suffixes for the status line. Only the exceptional states appear:
+      # active presence and DND-off are the common case, and repeating them on
+      # every line would bury the workspace that differs.
+      def labels
+        [('[away]' if away?), dnd&.to_s].reject { |label| label.to_s.empty? }
+      end
+    end
+  end
+end

data/lib/slk/runner.rb

@@ -88,6 +88,10 @@ module Slk
       Api::Saved.new(@api_client, workspace(workspace_name))
     end
 
+    def custom_status_api(workspace_name = nil)
+      Api::CustomStatus.new(@api_client, workspace(workspace_name))
+    end
+
     def team_api(workspace_name = nil)
       Api::Team.new(@api_client, workspace(workspace_name))
     end

data/lib/slk/services/encryption.rb

@@ -104,8 +104,15 @@ module Slk
               'Please provide the correct public key for this private key.'
       end
 
+      # `-P ''` supplies the passphrase up front so ssh-keygen cannot ask for
+      # one. Without it, an encrypted key makes ssh-keygen prompt — and it
+      # prompts on the console directly, not on the stdin capture3 hands it, so
+      # closing stdin does not help. On Windows that read blocks forever; this
+      # hung the CI job until its timeout with no output. An empty passphrase
+      # fails an encrypted key with the same message it already reported, which
+      # is the right answer regardless: slk cannot use such a key anyway.
       def derive_public_key(private_key_path)
-        output, error, status = Open3.capture3('ssh-keygen', '-y', '-f', private_key_path)
+        output, error, status = Open3.capture3('ssh-keygen', '-y', '-P', '', '-f', private_key_path)
         return output.strip if status.success?
 
         # Check if ssh-keygen is missing vs other failures

data/lib/slk/support/time_parser.rb

@@ -0,0 +1,120 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'date'
+
+module Slk
+  module Support
+    # Resolves a single clock time ("1:30p", "2026-08-12 8a") to a Unix
+    # timestamp. A bare time at or before now rolls to tomorrow; an explicit
+    # YYYY-MM-DD date is honoured as given.
+    #
+    # TimeRangeParser builds the two-sided form on the clock arithmetic here.
+    class TimeParser
+      TIME = /(\d{1,2})(?::(\d{2}))?\s*([ap]m?)?/i
+      PATTERN = /\A(?:(\d{4}-\d{2}-\d{2})\s+)?#{TIME}\z/i
+
+      EXAMPLE = '1:30p or 2026-08-12 8:00'
+
+      MINUTES_PER_DAY = 24 * 60
+
+      # A bare hour of 0 or 13-23 can only be 24-hour notation, so no am/pm was
+      # omitted. Anything in 1..12 is genuinely ambiguous without one.
+      CLOCK_HOURS = (1..12)
+
+      # @param now [Time] reference point for rolling bare times forward
+      # @return [Integer] Unix timestamp
+      def self.parse(input, now: Time.now) = new(now: now).parse(input)
+
+      def initialize(now: Time.now)
+        @now = now
+      end
+
+      def parse(input)
+        match = PATTERN.match(input.to_s.strip)
+        raise TimeFormatError, "Invalid time: #{input}. Use #{EXAMPLE}" unless match
+
+        parts = match.captures[1..3]
+        date = match[1] ? parse_date(match[1]) : roll_forward(parts)
+        at(date, *parts).to_i
+      end
+
+      # The rest of this class is clock arithmetic shared with TimeRangeParser,
+      # which needs to place the same parts on dates it works out itself.
+
+      # @param example [String] format hint, so a caller with its own syntax
+      #   (TimeRangeParser) does not advertise this class's example
+      def parse_date(text, example: EXAMPLE)
+        Date.parse(text)
+      rescue Date::Error
+        raise TimeFormatError, "Invalid date: #{text}. Use #{example}"
+      end
+
+      def at(date, *parts)
+        hours, minutes = to_24_hour(*parts)
+        time = build(date, hours, minutes)
+        # Ruby silently shifts a local time that DST skips (2:30a on a
+        # spring-forward date becomes 3:30a), which would move the window
+        # rather than fail. Reject it instead.
+        return time if time.hour == hours && time.min == minutes
+
+        raise TimeFormatError,
+              format('%<clock>s does not exist on %<date>s (clocks skip forward for DST).',
+                     clock: format('%<h>02d:%<m>02d', h: hours, m: minutes), date: date)
+      end
+
+      # Same placement without the existence check, for callers asking a
+      # question a nonexistent time still answers. `at` would raise, which for
+      # the roll-forward probe would reject "2:30a" outright on a spring-forward
+      # date instead of rolling it to the next day, where it does exist.
+      def place(date, *parts) = build(date, *to_24_hour(*parts))
+
+      # Minutes since midnight, for comparing two times before either has a date.
+      def minutes(parts)
+        hours, mins = to_24_hour(*parts)
+        (hours * 60) + mins
+      end
+
+      # True when these parts could have meant either am or pm — no meridiem
+      # given, and an hour small enough that both readings are plausible.
+      def ambiguous?(parts) = parts[2].nil? && CLOCK_HOURS.cover?(parts[0].to_i)
+
+      # The opposite: a bare hour too large to be a 12-hour clock reading, so
+      # the writer was plainly using 24-hour notation. TimeRangeParser treats
+      # one of these as settling how to read the *other* side of a range.
+      def twenty_four_hour?(parts) = parts[2].nil? && !CLOCK_HOURS.cover?(parts[0].to_i)
+
+      private
+
+      def build(date, hours, minutes) = Time.new(date.year, date.month, date.day, hours, minutes, 0)
+
+      def roll_forward(parts)
+        today = @now.to_date
+        place(today, *parts) <= @now ? today + 1 : today
+      end
+
+      def to_24_hour(hour, minute, meridiem)
+        hours = hour.to_i
+        minutes = minute.to_i
+        raise TimeFormatError, "Invalid minute: #{minute}" if minutes > 59
+        return [validate_24_hour(hours), minutes] unless meridiem
+
+        [apply_meridiem(hours, meridiem), minutes]
+      end
+
+      def validate_24_hour(hours)
+        raise TimeFormatError, "Invalid hour: #{hours}" if hours > 23
+
+        hours
+      end
+
+      def apply_meridiem(hours, meridiem)
+        raise TimeFormatError, "Invalid hour for 12-hour time: #{hours}" if hours.zero? || hours > 12
+
+        # 12am is hour 0 and 12pm is hour 12, so fold 12 down before shifting.
+        base = hours % 12
+        meridiem[0].casecmp?('p') ? base + 12 : base
+      end
+    end
+  end
+end

data/lib/slk/support/time_range_parser.rb

@@ -0,0 +1,166 @@
+# frozen_string_literal: true
+
+require 'time'
+require 'date'
+
+module Slk
+  module Support
+    # Parses a scheduling window ("1:30p-3:30p", "2026-08-04 13:30-15:30")
+    # into a [start, end] pair of Unix timestamps.
+    #
+    # Unlike DateParser, which resolves an input to a point in the past, this
+    # always resolves forward: a bare time at or before now rolls to tomorrow,
+    # and an end before the start rolls to the next day so overnight windows
+    # ("11p-1a") work.
+    #
+    # The start date is written once and the end can only reach the following
+    # day, so this cannot express a multi-day window — `slk status schedule
+    # --start/--end` is the general form for that.
+    class TimeRangeParser
+      RANGE_PATTERN = /\A(?:(\d{4}-\d{2}-\d{2})\s+)?#{TimeParser::TIME}\s*-\s*#{TimeParser::TIME}\z/i
+
+      EXAMPLE = '1:30p-3:30p or 2026-08-04 13:30-15:30'
+
+      # Longest overnight window accepted when a reading had to be guessed.
+      # Twelve hours is not a policy about window length — an explicit
+      # "8p-9a" is longer and fine — it is the point past which a guessed
+      # crossing can no longer be what the user meant.
+      MAX_GUESSED_OVERNIGHT_MINUTES = 12 * 60
+
+      # @param input [String] the range to parse
+      # @param now [Time] reference point for rolling bare times forward
+      # @return [Array(Integer, Integer)] start and end Unix timestamps
+      def self.parse(input, now: Time.now) = new(now: now).parse(input)
+
+      # True when input looks like a time range, used to pick it out of argv.
+      def self.match?(input) = RANGE_PATTERN.match?(input.to_s.strip)
+
+      def initialize(now: Time.now)
+        @now = now
+        @clock = TimeParser.new(now: now)
+      end
+
+      def parse(input)
+        match = RANGE_PATTERN.match(input.to_s.strip)
+        raise TimeFormatError, "Invalid time range: #{input}. Use #{EXAMPLE}" unless match
+
+        start_parts, end_parts = infer_meridiems(match)
+        validate_range(input, start_parts, end_parts)
+
+        date = start_date(match, start_parts)
+        start_at = @clock.at(date, *start_parts)
+
+        [start_at.to_i, end_time(date, start_at, end_parts).to_i]
+      end
+
+      private
+
+      # `match.captures` layout: 0 is the optional date, 1..3 the start time,
+      # 4..6 the end. Note the date is `match[1]` in the 1-indexed MatchData form.
+      #
+      # "1-3p" means 1pm, not 1am: when only one side names a meridiem the
+      # other borrows it. The borrow is skipped when it would invert the range
+      # ("9-5p" is 9am to 5pm, not 9pm to 5pm).
+      def infer_meridiems(match)
+        start_parts = match.captures[1..3]
+        end_parts = match.captures[4..6]
+
+        if borrowable?(start_parts, end_parts)
+          borrowed = with_meridiem(start_parts, end_parts[2])
+          return [borrowed, end_parts] if @clock.minutes(borrowed) < @clock.minutes(end_parts)
+        elsif borrowable?(end_parts, start_parts)
+          borrowed = with_meridiem(end_parts, start_parts[2])
+          return [start_parts, borrowed] if @clock.minutes(start_parts) < @clock.minutes(borrowed)
+        end
+
+        [start_parts, end_parts]
+      end
+
+      def borrowable?(parts, source) = !source[2].nil? && @clock.ambiguous?(parts)
+
+      def with_meridiem(parts, meridiem) = [parts[0], parts[1], meridiem]
+
+      # An explicit date is honoured as given; a bare time at or before now
+      # refers to tomorrow.
+      def start_date(match, start_parts)
+        return @clock.parse_date(match[1], example: EXAMPLE) if match[1]
+
+        today = @now.to_date
+        # `place`, not `at`: this only asks "is that time already past today?",
+        # and on a spring-forward date `at` would reject a skipped time outright
+        # instead of letting it roll to tomorrow, where it exists.
+        @clock.place(today, *start_parts) <= @now ? today + 1 : today
+      end
+
+      def end_time(date, start_at, end_parts)
+        end_at = @clock.at(date, *end_parts)
+        # An end before the start means the window crosses midnight.
+        end_at < start_at ? @clock.at(date + 1, *end_parts) : end_at
+      end
+
+      def validate_range(input, start_parts, end_parts)
+        if @clock.minutes(start_parts) == @clock.minutes(end_parts)
+          raise TimeFormatError, "Time range #{input} starts and ends at the same time."
+        end
+
+        validate_overnight(input, start_parts, end_parts)
+      end
+
+      # "9-5" almost always means 9am-5pm, but reads literally as 09:00 to
+      # 05:00 the next morning — a 20-hour window nobody asked for. So is
+      # "9a-5", where the am/pm is there but on the wrong side to help.
+      #
+      # Only guessed readings are checked, and only past 12 hours, which is
+      # what separates the mistake from the intent. An overnight shift written
+      # with a pm start ("9p-5", "10p-2") can only come out 12 hours or less;
+      # a dropped meridiem ("9-5", "9a-5", "10-5a") can only come out longer.
+      def validate_overnight(input, start_parts, end_parts)
+        return unless guessed?(start_parts, end_parts)
+
+        span = overnight_minutes(start_parts, end_parts)
+        return if span.nil? || span <= MAX_GUESSED_OVERNIGHT_MINUTES
+
+        raise TimeFormatError,
+              "Time range #{input} reads as crossing midnight and spans #{format_span(span)}. " \
+              'Add am/pm to both sides (9a-5p), use 24-hour times (9:00-17:00), ' \
+              'or --start/--end for a multi-day window.'
+      end
+
+      # True when a side's reading had to be guessed.
+      #
+      # A leftover ambiguous side is not enough on its own: in "20:00-6" the
+      # 24-hour start settles the whole range, so "6" is 6am and was not
+      # guessed. Without such an anchor, any side still bare after
+      # `infer_meridiems` was read as 24-hour for want of anything better —
+      # either because no meridiem was given at all ("9-5"), or because
+      # borrowing the one that was given would have inverted the range
+      # ("9a-5", where 5am precedes 9am).
+      def guessed?(start_parts, end_parts)
+        return false if @clock.twenty_four_hour?(start_parts) || @clock.twenty_four_hour?(end_parts)
+
+        @clock.ambiguous?(start_parts) || @clock.ambiguous?(end_parts)
+      end
+
+      # Wall-clock minutes from start to end across midnight, or nil when the
+      # window stays on one date.
+      #
+      # Deliberately not `end_at - start_at`: elapsed seconds stretch or shrink
+      # by an hour across a DST boundary, so the same text would report a
+      # different span depending on the date it happened to land on.
+      def overnight_minutes(start_parts, end_parts)
+        start_minutes = @clock.minutes(start_parts)
+        end_minutes = @clock.minutes(end_parts)
+        return nil if end_minutes > start_minutes
+
+        TimeParser::MINUTES_PER_DAY - start_minutes + end_minutes
+      end
+
+      # Whole hours read better, but rounding them would report a 12h01m window
+      # as "12 hours" against a 12-hour limit.
+      def format_span(minutes)
+        hours, mins = minutes.divmod(60)
+        mins.zero? ? "#{hours} hours" : format('%<h>dh%<m>02dm', h: hours, m: mins)
+      end
+    end
+  end
+end

data/lib/slk/version.rb

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

data/lib/slk.rb

@@ -12,6 +12,17 @@ require 'io/console'
 module Slk
   class Error < StandardError; end
 
+  # The invocation itself was wrong (a flag with no value, an unparseable
+  # time). The message is written for the user and is printed verbatim, with
+  # no "Error type:" label, because there is no internal fault to report.
+  class UsageError < Error; end
+
+  # A time or range the user typed that cannot be understood. Separate from
+  # UsageError so callers can rescue *only* malformed input: a blanket
+  # `rescue ArgumentError` around a parse call also swallows arity and range
+  # errors from the code itself and presents them as if the user mistyped.
+  class TimeFormatError < UsageError; end
+
   # Errors from any Slack-API-shaped failure: HTTP errors, network errors,
   # logical Slack errors (user_not_found, missing_scope, etc.), JSON parse
   # failures. The optional `code` symbol lets callers match specific cases
@@ -55,6 +66,9 @@ module Slk
     autoload :Duration, 'slk/models/duration'
     autoload :Workspace, 'slk/models/workspace'
     autoload :Status, 'slk/models/status'
+    autoload :ScheduledStatus, 'slk/models/scheduled_status'
+    autoload :DndState, 'slk/models/dnd_state'
+    autoload :StatusSnapshot, 'slk/models/status_snapshot'
     autoload :Message, 'slk/models/message'
     autoload :Reaction, 'slk/models/reaction'
     autoload :User, 'slk/models/user'
@@ -105,6 +119,7 @@ module Slk
     autoload :MessageFormatter, 'slk/formatters/message_formatter'
     autoload :ReactionFormatter, 'slk/formatters/reaction_formatter'
     autoload :JsonMessageFormatter, 'slk/formatters/json_message_formatter'
+    autoload :JsonStatusFormatter, 'slk/formatters/json_status_formatter'
     autoload :ActivityFormatter, 'slk/formatters/activity_formatter'
     autoload :AttachmentFormatter, 'slk/formatters/attachment_formatter'
     autoload :BlockFormatter, 'slk/formatters/block_formatter'
@@ -153,6 +168,7 @@ module Slk
     autoload :Activity, 'slk/api/activity'
     autoload :Search, 'slk/api/search'
     autoload :Saved, 'slk/api/saved'
+    autoload :CustomStatus, 'slk/api/custom_status'
     autoload :Team, 'slk/api/team'
   end
 
@@ -167,5 +183,7 @@ module Slk
     autoload :TextWrapper, 'slk/support/text_wrapper'
     autoload :InteractivePrompt, 'slk/support/interactive_prompt'
     autoload :DateParser, 'slk/support/date_parser'
+    autoload :TimeParser, 'slk/support/time_parser'
+    autoload :TimeRangeParser, 'slk/support/time_range_parser'
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: slk
 version: !ruby/object:Gem::Version
-  version: 0.6.0
+  version: 0.8.0
 platform: ruby
 authors:
 - Eric Boehs
@@ -30,6 +30,7 @@ files:
 - lib/slk/api/bots.rb
 - lib/slk/api/client.rb
 - lib/slk/api/conversations.rb
+- lib/slk/api/custom_status.rb
 - lib/slk/api/dnd.rb
 - lib/slk/api/emoji.rb
 - lib/slk/api/saved.rb
@@ -66,6 +67,7 @@ files:
 - lib/slk/formatters/duration_formatter.rb
 - lib/slk/formatters/emoji_replacer.rb
 - lib/slk/formatters/json_message_formatter.rb
+- lib/slk/formatters/json_status_formatter.rb
 - lib/slk/formatters/markdown_output.rb
 - lib/slk/formatters/mention_replacer.rb
 - lib/slk/formatters/message_formatter.rb
@@ -78,6 +80,7 @@ files:
 - lib/slk/formatters/search_formatter.rb
 - lib/slk/formatters/text_processor.rb
 - lib/slk/models/channel.rb
+- lib/slk/models/dnd_state.rb
 - lib/slk/models/duration.rb
 - lib/slk/models/message.rb
 - lib/slk/models/preset.rb
@@ -85,8 +88,10 @@ files:
 - lib/slk/models/profile_field.rb
 - lib/slk/models/reaction.rb
 - lib/slk/models/saved_item.rb
+- lib/slk/models/scheduled_status.rb
 - lib/slk/models/search_result.rb
 - lib/slk/models/status.rb
+- lib/slk/models/status_snapshot.rb
 - lib/slk/models/user.rb
 - lib/slk/models/workspace.rb
 - lib/slk/runner.rb
@@ -123,6 +128,8 @@ files:
 - lib/slk/support/platform.rb
 - lib/slk/support/slack_url_parser.rb
 - lib/slk/support/text_wrapper.rb
+- lib/slk/support/time_parser.rb
+- lib/slk/support/time_range_parser.rb
 - lib/slk/support/user_resolver.rb
 - lib/slk/support/xdg_paths.rb
 - lib/slk/version.rb
@@ -148,7 +155,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 4.0.10
+rubygems_version: 4.0.16
 specification_version: 4
 summary: A command-line interface for Slack
 test_files: []