teems 0.2.0 → 0.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 644504d1f8d334a4ddec54ef8f099424d1251dd6d15beef3c1b713da93f0ce0e
-  data.tar.gz: 9c93db615cbe58642f127856e6c70d8b9cd0eefd81625b666cdfab736095a4cd
+  metadata.gz: 5932afeb278892c20e7e3fbb92980da31ff45cd9a528a3e2463de38ee7ea3f70
+  data.tar.gz: 331a38b48c8bb1d87ff770a0579e1846aa643b5d1d1daf5061c0bbf8f0589264
 SHA512:
-  metadata.gz: b72dbf0beb2fc14d5af939699526bcc060f7dab85afd9ee4f49d7fa5272add46fcda9f3a345afd67db81e8bc01ce40ca0e3b739d6dfed65d279be0ecb4172d8d
-  data.tar.gz: 537ef91ebb3e91424172d4c3e17b8fb884cadccb5c670deaa62ee41737ffef59f650edde0cb068a81b4271983ac94fcc05befd82cd0cb1d6077803c8a488f817
+  metadata.gz: 5d750e3b09de3a6ce07612398e0e00a7eb5ac647aa9cd38d45023cd0605777625a9ec212aa81c111b69118d068ffd3b4bd946280d4194cc1ecd34f40708adf7f
+  data.tar.gz: 355288361bbfa4e21166b18b248793403a023411e3588be731e205c9fe4f6994684426ae7037a09cf009bdb699e9a17caf932572aea9ab1588449c3298224624

data/CHANGELOG.md

@@ -1,5 +1,41 @@
 # Changelog
 
+## [0.3.1] - 2026-09-02
+
+### Added
+- `teems meeting --date YYYY-MM-DD` - Pick a single occurrence of a recurring meeting series by date. Filters call events, recordings, transcripts, and chat messages to that day in the user's local timezone, so iterating multiple days from the same series is a one-liner shell loop. Errors when nothing matches.
+- `teems meeting --date` automatically paginates the chat thread via `_metadata.backwardLink` until the page covers the requested date — using `lastCompleteSegmentStartTime` as the boundary cursor so pages with interleaved old replies/system messages don't terminate pagination prematurely. Capped at 50 pages of 200 messages as a safety net; cap-hit surfaces a user-visible error. API errors mid-pagination now exit non-zero instead of rendering partial data as success.
+- `teems messages <teams-url>` now treats a message permalink as a thread root: it fetches the linked message and its replies and renders them with a `--- N replies ---` separator (modelled after `slk view`). Falls back to listing recent messages when the URL has no message ID.
+
+### Fixed
+- `teems auth login` no longer hangs and then fails on a first login. The Safari OAuth flow read its tenant from `tokens.json` and bailed when it was absent, so the flow that obtains tokens required tokens to already exist; it now falls back to the `common` tenant. The redirect poll also assumed silent SSO with a 12-second budget, which never survived an account picker, MFA, or a PIV/CAC certificate prompt — it now polls every tab for three minutes and prints a visible "waiting for sign-in" notice instead of sitting silent
+- `teems auth login` records the tenant the token was actually issued for instead of the placeholder used to start the flow, so refreshes and the headless helper use the tenant-specific endpoint
+- Interrupting a command that is waiting on a child process (Safari sign-in, the headless helper, or the Swift compile) no longer prints `Open3` reader-thread `IOError` backtraces before exiting
+- `teems org` no longer hangs when the manager chain contains a cycle; cycle detection breaks the walk on the first repeated manager
+
+## [0.3.0] - 2026-04-23
+
+### Added
+- `teems meeting --audio` - Download audio-only M4A alongside or instead of video (ideal for transcription)
+- `teems meeting --no-video` - Skip the video download for audio-only output
+- `teems ooo` now supports timed schedules via `--start`/`--end` (e.g., "today 14:00") in addition to all-day dates
+- `teems ooo --invite` - Override the configured notify list for a single invocation
+
+### Changed
+- Recording, audio, and transcript files share a common base name derived from the SharePoint file (e.g., `2026-01-20 - Team Sync.mp4`/`.m4a`/`.vtt`)
+
+### Fixed
+- `teems meeting` shows call duration once on the event header instead of repeating it per participant
+
+## [0.2.0] - 2026-04-14
+
+### Added
+- `teems meeting` - View meeting details, download transcripts, and download recordings
+- Auto-authentication when tokens are missing or expired (no manual `auth login` needed)
+
+### Fixed
+- `teems cal delete` now uses configured endpoints instead of hardcoded defaults
+
 ## [0.1.0] - 2026-04-10
 
 ### Added

data/lib/teems/api/messages.rb

@@ -39,6 +39,12 @@ module Teems
         get("/v1/users/ME/conversations/#{encoded_id}/messages", params: params)
       end
 
+      # Get a single message by ID
+      def message(thread_id:, message_id:)
+        encoded_id = URI.encode_www_form_component(thread_id)
+        get("/v1/users/ME/conversations/#{encoded_id}/messages/#{message_id}")
+      end
+
       # Get replies to a message
       def replies(thread_id:, message_id:, limit: 50)
         encoded_id = URI.encode_www_form_component(thread_id)

data/lib/teems/commands/auth.rb

@@ -221,8 +221,8 @@ module Teems
 
       def print_login_banner
         puts 'Starting Teams authentication...'
-        puts 'Safari will open to teams.microsoft.com'
-        puts 'Please complete the login process'
+        puts 'Safari will open so you can sign in (PIV/CAC or MFA prompts appear there).'
+        puts 'Leave this running - it captures the tokens as soon as sign-in completes.'
         puts
       end
 
@@ -238,7 +238,9 @@ module Teems
 
       def suggest_manual_auth
         error('Failed to extract tokens automatically')
-        puts "\nTry manual extraction instead:\n  teems auth manual"
+        puts "\nRerun with -v to see where it stopped:\n  teems auth login -v"
+        puts "\nOn VPN with a PIV card, try:\n  teems auth login --certauth"
+        puts "\nOr extract the tokens by hand:\n  teems auth manual"
         1
       end
 

data/lib/teems/commands/cal.rb

@@ -477,56 +477,6 @@ module Teems
       end
     end
 
-    # Time parsing for create subcommand
-    module CalTimeParsing
-      private
-
-      def parse_time_input(raw)
-        date, time_str = split_time_input(raw)
-        return unless time_str
-
-        date.is_a?(String) ? parse_absolute_time(date, time_str) : parse_relative_time(date, time_str)
-      end
-
-      def split_time_input(raw)
-        base = Date.today
-        split_tomorrow_time(raw, base) || split_today_time(raw, base) || split_absolute_time(raw)
-      end
-
-      def split_tomorrow_time(raw, base)
-        return unless raw.start_with?('tomorrow ')
-
-        [base + 1, raw.delete_prefix('tomorrow ')]
-      end
-
-      def split_today_time(raw, base)
-        return unless raw.match?(/\A(?:today\s+)?\d{1,2}:\d{2}\z/)
-
-        [base, raw.delete_prefix('today ')]
-      end
-
-      def split_absolute_time(raw)
-        return unless raw.match?(/\A\d{4}-\d{2}-\d{2}\s+\d{1,2}:\d{2}\z/)
-
-        raw.split(/\s+/, 2)
-      end
-
-      def parse_relative_time(date, time_str)
-        hour, min = time_str.split(':').map(&:to_i)
-        debug("Parsing time #{hour}:#{min} for #{@options[:date]}") if @options[:verbose]
-        Time.new(date.year, date.month, date.day, hour, min, 0)
-      rescue ArgumentError
-        nil
-      end
-
-      def parse_absolute_time(date_str, time_str)
-        date = Date.parse(date_str)
-        parse_relative_time(date, time_str)
-      rescue Date::Error
-        nil
-      end
-    end
-
     # Builds the event body hash fields for create requests
     module CalEventFields
       private
@@ -640,7 +590,7 @@ module Teems
 
     # Event creation subcommand
     module CalCreateActions
-      include CalTimeParsing
+      include Support::TimeParsing
       include CalEventFields
       include CalCreateValidation
 

data/lib/teems/commands/meeting.rb

@@ -19,7 +19,11 @@ module Teems
         --transcript     Download meeting transcript (WebVTT)
         --recording      Download meeting recording (MP4, requires ffmpeg)
                          Combine with --transcript to embed subtitles
+        --audio          Also save a separate audio file (M4A) — ideal for transcription
+        --no-video       Skip the video file; with --audio produces audio-only output
         --chat           Show meeting chat messages
+        --date YYYY-MM-DD  Pick a single occurrence of a recurring meeting by date
+                           (filters call events, recordings, and transcripts)
         -o, --output-dir Directory for downloads (default: current directory)
         -v, --verbose    Show debug output
         -q, --quiet      Suppress output
@@ -30,8 +34,11 @@ module Teems
         teems meeting 19:meeting_abc123@thread.v2
         teems meeting 19:meeting_abc123@thread.v2 --chat
         teems meeting 19:meeting_abc123@thread.v2 --transcript
+        teems meeting 19:meeting_abc123@thread.v2 --audio -o ~/Downloads          # video + audio
+        teems meeting 19:meeting_abc123@thread.v2 --audio --no-video -o ~/Downloads  # audio only
         teems meeting 19:meeting_abc123@thread.v2 --recording -o ~/Downloads
         teems meeting 19:meeting_abc123@thread.v2 --recording --transcript -o ~/Downloads
+        teems meeting "<recurring-url>" --date 2026-05-04 --audio --no-video --transcript
         teems meeting AAMkAGVmMDEz...        # By calendar event ID
     HELP
 
@@ -40,7 +47,10 @@ module Teems
       ALL = {
         '--transcript' => ->(opts, _args) { opts[:transcript] = true },
         '--recording' => ->(opts, _args) { opts[:recording] = true },
+        '--audio' => ->(opts, _args) { opts[:audio] = true },
+        '--no-video' => ->(opts, _args) { opts[:no_video] = true },
         '--chat' => ->(opts, _args) { opts[:chat] = true },
+        '--date' => ->(opts, args) { opts[:date] = args.shift },
         '-o' => ->(opts, args) { opts[:output_dir] = args.shift },
         '--output-dir' => ->(opts, args) { opts[:output_dir] = args.shift }
       }.freeze
@@ -158,6 +168,16 @@ module Teems
       CALLID_RE = %r{<callId>([^<]+)</callId>}
       INSTANCE_ICAL_RE = %r{<instanceDetails>.*?<iCalUid>([^<]+)</iCalUid>}m
 
+      # Public helper: parses an ISO/RFC time string, returning nil for nil/garbage input.
+      # Shared with MeetingPage which doesn't include the module.
+      def self.safe_parse_time(time_str)
+        return nil unless time_str
+
+        Time.parse(time_str)
+      rescue ArgumentError, TypeError
+        nil
+      end
+
       private
 
       def classify_meeting_messages(messages_data)
@@ -187,10 +207,12 @@ module Teems
 
       def parse_call_event(msg)
         content = msg['content'].to_s
+        parts = extract_partlist(content)
         build_msg_hash(msg).merge(
           call_id: content.match(CALLID_RE)&.captures&.first,
           ical_uid: content.match(INSTANCE_ICAL_RE)&.captures&.first,
-          participants: extract_partlist(content)
+          duration: parts.first&.dig(:duration),
+          participants: parts
         )
       end
 
@@ -272,7 +294,8 @@ module Teems
 
       def display_single_call_event(event)
         puts
-        puts "  #{output.bold('Call Event')} #{format_time_str(event[:time])}"
+        header = "  #{output.bold('Call Event')} #{format_time_str(event[:time])}"
+        puts "#{header} (#{format_call_duration(event[:duration])})"
         display_participants(event[:participants])
       end
 
@@ -280,12 +303,12 @@ module Teems
         return if parts.empty?
 
         puts "  Participants (#{parts.length}):"
-        parts.each { |entry| puts format_participant_line(entry[:name], entry[:identity], entry[:duration]) }
+        parts.each { |entry| puts format_participant_line(entry[:name], entry[:identity]) }
       end
 
-      def format_participant_line(name, identity, duration)
+      def format_participant_line(name, identity)
         resolved = needs_resolution?(name) ? resolve_participant_name(identity) : name
-        "    #{resolved} (#{format_call_duration(duration)})"
+        "    #{resolved}"
       end
 
       def needs_resolution?(name)
@@ -355,6 +378,200 @@ module Teems
       end
     end
 
+    # A single page of meeting chat messages with the cursor to the page before it.
+    # Constructor normalizes a blank backward_link to nil so `last?` is a simple nil check.
+    # Date comparisons use the user's local timezone to match `--date` semantics.
+    #
+    # `segment_cursor` is `_metadata.lastCompleteSegmentStartTime` (a Time) — the API's
+    # boundary marker for "all messages from here on are fully loaded." Prefer it for
+    # `covers_through?` because pages can intersperse old replies/system messages, making
+    # the message-level `oldest_local_date` an unreliable stop signal. Falls back to the
+    # oldest message when the cursor is absent (e.g. in synthetic test data).
+    MeetingPage = Data.define(:messages, :backward_link, :segment_cursor) do
+      def self.from_response(response)
+        msgs, value_msgs, meta_or_nil = response.values_at('messages', 'value', '_metadata')
+        meta = meta_or_nil || {}
+        new(messages: msgs || value_msgs || [],
+            backward_link: meta['backwardLink'],
+            segment_cursor: cursor_from_millis(meta['lastCompleteSegmentStartTime']))
+      end
+
+      def self.cursor_from_millis(millis)
+        return nil unless millis.is_a?(Numeric)
+
+        Time.at(millis / 1000.0)
+      end
+
+      def initialize(messages:, backward_link:, segment_cursor: nil)
+        super(messages: messages,
+              backward_link: backward_link.to_s.empty? ? nil : backward_link,
+              segment_cursor: segment_cursor)
+      end
+
+      def empty? = messages.empty?
+      def last? = !backward_link
+
+      def oldest_local_date
+        oldest_message_time&.localtime&.to_date
+      end
+
+      # Strict `<` is load-bearing: when the cursor equals target_date, we must keep
+      # paginating to ensure we've fetched all of target_date's messages.
+      def covers_through?(target_date)
+        cursor = segment_cursor || oldest_message_time
+        cursor && cursor.localtime.to_date < target_date
+      end
+
+      def terminal_for?(target_date)
+        empty? || last? || covers_through?(target_date)
+      end
+
+      private
+
+      def oldest_message_time
+        messages.filter_map { |msg| MeetingMessageParser.safe_parse_time(msg['composetime']) }.min
+      end
+    end
+
+    # Pages backward through chat messages until we've fetched past the target date.
+    # The ng.msg wrapper requests 200 messages per page and exposes no messageType filter,
+    # so for recurring meetings we paginate via _metadata.backwardLink.
+    module MeetingPagination
+      # Per-page request size used by Api::Messages#chat_messages_page.
+      PAGE_SIZE = 200
+
+      # Safety net: 50 pages × 200 = 10K messages worst case (~25s with the rate-limit
+      # cushion). Beyond this we assume the requested date is older than retained history
+      # and surface a user-visible error.
+      MAX_PAGES = 50
+
+      # Polite pause between page fetches. Matches Services::SyncEngine::API_DELAY_SECONDS.
+      PAGE_DELAY_SECONDS = 0.5
+
+      private
+
+      # Returns the accumulated messages, or nil if the API errored mid-pagination
+      # (so callers can fail loudly instead of rendering partial data as success).
+      def paginate_meeting_messages(thread_id, target_date)
+        @page_count = 0
+        @pagination_link = nil
+        @paginated_messages = []
+        return nil unless run_pagination_loop(thread_id, target_date)
+
+        @paginated_messages
+      end
+
+      def run_pagination_loop(thread_id, target_date)
+        loop do
+          page = fetch_meeting_page(thread_id, @pagination_link)
+          return false unless page
+
+          merge_meeting_page(page)
+          return true if pagination_done?(page, target_date)
+
+          @pagination_link = page.backward_link
+          page_pause
+        end
+      end
+
+      def page_pause
+        sleep(PAGE_DELAY_SECONDS)
+      end
+
+      def fetch_meeting_page(thread_id, backward_link)
+        response = with_token_refresh do
+          runner.messages_api.chat_messages_page(
+            chat_id: thread_id, limit: PAGE_SIZE, backward_link: backward_link
+          )
+        end
+        MeetingPage.from_response(response)
+      rescue ApiError => e
+        error("Failed to fetch meeting messages: #{e.message}")
+        nil
+      end
+
+      def merge_meeting_page(page)
+        page_messages = page.messages
+        @paginated_messages.concat(page_messages)
+        @page_count += 1
+        debug("Page #{@page_count}: #{page_messages.length} message(s) " \
+              "(oldest #{page.oldest_local_date}); total #{@paginated_messages.length}")
+      end
+
+      def pagination_done?(page, target_date)
+        return true if page.terminal_for?(target_date)
+
+        reached_pagination_cap?
+      end
+
+      def reached_pagination_cap?
+        return false if @page_count < MAX_PAGES
+
+        error("Stopped after #{MAX_PAGES} pages (~#{MAX_PAGES * PAGE_SIZE} messages); " \
+              '--date may predate available history')
+        true
+      end
+    end
+
+    # Filters classified call events, recordings, transcripts, and chat messages to a
+    # single date. Used to select one occurrence of a recurring meeting series.
+    # Date comparison uses the user's local timezone.
+    module MeetingDateFilter
+      # All four classification buckets are date-filtered. Parsed buckets (call_events,
+      # recordings, transcripts) carry :time (symbol); raw chat_messages carry
+      # 'composetime' (string) — `item_on_date?` accepts either shape.
+      DATE_KEYS = %i[call_events recordings transcripts chat_messages].freeze
+
+      private
+
+      def validate_date_option
+        raw = @options[:date]
+        return nil unless raw
+
+        @options[:target_date] = Date.parse(raw)
+        nil
+      rescue ArgumentError, TypeError
+        error("Invalid --date value: #{raw.inspect} (expected YYYY-MM-DD)")
+        1
+      end
+
+      def apply_date_option(classified)
+        target_date = @options[:target_date]
+        return classified unless target_date
+
+        filtered = filter_classified_by_date(classified, target_date)
+        return filtered unless date_filter_empty?(filtered)
+
+        error("No meeting activity found for #{@options[:date]}")
+        nil
+      end
+
+      def date_filter_empty?(classified)
+        DATE_KEYS.all? { |key| classified[key].empty? }
+      end
+
+      def filter_classified_by_date(classified, target_date)
+        classified.to_h { |key, val| [key, filter_classified_value(key, val, target_date)] }
+      end
+
+      def filter_classified_value(key, val, target_date)
+        DATE_KEYS.include?(key) ? items_on_date(val, target_date) : val
+      end
+
+      def items_on_date(items, target_date)
+        items.select { |item| item_on_date?(item, target_date) }
+      end
+
+      def item_on_date?(item, target_date)
+        time_str = item[:time] || item['composetime']
+        return false unless time_str
+
+        Time.parse(time_str).localtime.to_date == target_date
+      rescue ArgumentError, TypeError
+        false
+      end
+    end
+
     # Filters classified messages to a specific call instance by callId
     module MeetingCallFilter
       private
@@ -394,6 +611,8 @@ module Teems
       include MeetingDisplay
       include MeetingChatDisplay
       include MeetingCallFilter
+      include MeetingDateFilter
+      include MeetingPagination
       include MeetingTranscript
       include MeetingRecording
 
@@ -413,6 +632,13 @@ module Teems
         target ? process_meeting(target) : 1
       end
 
+      def validate_options
+        result = super
+        return result if result
+
+        validate_date_option
+      end
+
       protected
 
       MEETING_OPTIONS = MeetingOptionDefs::ALL
@@ -433,11 +659,21 @@ module Teems
         return 1 unless messages_data
 
         classified = classify_and_filter(messages_data, target)
+        classified = apply_date_option(classified)
+        return 1 unless classified
+
         dispatch_mode(target, classified)
       end
 
       def fetch_meeting_messages(thread_id)
         debug("Fetching messages for thread: #{thread_id}")
+        target_date = @options[:target_date]
+        return paginate_meeting_messages(thread_id, target_date) if target_date
+
+        single_page_meeting_messages(thread_id)
+      end
+
+      def single_page_meeting_messages(thread_id)
         response = with_token_refresh do
           runner.messages_api.chat_messages(chat_id: thread_id, limit: @options[:limit])
         end
@@ -452,19 +688,27 @@ module Teems
           display_meeting_chat(classified[:chat_messages])
           return 0
         end
-        return download_recording_with_transcript(target, classified) if @options[:recording]
+        media = media_output_spec
+        return download_media_with_transcript(target, classified, media) if media
         return download_transcript(target, classified) || 0 if @options[:transcript]
 
         display_meeting_summary(target, classified)
         0
       end
 
-      def download_recording_with_transcript(target, classified)
+      def media_output_spec
+        audio, recording, no_video = @options.values_at(:audio, :recording, :no_video)
+        return nil unless audio || recording || no_video
+
+        { video: (recording || audio) && !no_video, audio: audio || no_video }
+      end
+
+      def download_media_with_transcript(target, classified, media)
         if @options[:transcript]
           result = download_transcript(target, classified)
-          warn('Transcript download failed; proceeding with recording') if result == 1
+          warn("Transcript download failed; proceeding with #{media[:video] ? 'recording' : 'audio'}") if result == 1
         end
-        download_recording(target, classified) || 0
+        download_recording(target, classified, media: media) || 0
       end
     end
   end