teems 0.3.0 → 0.3.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6b2001d1f6e7653df296a0443a0a2f2bec80068ca05b4693bfd2b74c5f6a5240
-  data.tar.gz: 4f8e3920b836feb38237cd828a11ab63589855391f21cbea90eee6a54a34be9f
+  metadata.gz: bdc6ea71a9d23f39629fd24d240992925cca1482b53b69df377a84870d66367f
+  data.tar.gz: 1d563de02f05c8a120130e3e792b508bbf4d1b2467937951a63f2a3efbb19410
 SHA512:
-  metadata.gz: 245ff54545cf04f3d0db0062ab51ae2e1dc001a474c45c05e7e7cde21e8a00a523813b5019b96acaba0665010b6a6d31b7922141cb01a4203a2850f10fe5ad56
-  data.tar.gz: dffaa23979af2e85fffb8b0d3b8b3d8688aee1ff7c6d53eeeb5c151c81836380e93921eb5c37e2f2acf7d633a2f73e02a007e0c70af59a01e68f0bcb31a87f99
+  metadata.gz: 8c903fdae8e9946614e093ab4370e74abc03f7fab0d0a76509da02d07814e0083382f4a8f46e0e9131dd1eb3b16f0c36c5eeb96bb381778679bb92028574ad13
+  data.tar.gz: b3e6ff9fa9ec3adb9708a3ab97b30929d53a820e9d6239daaf4d359cee179c32448b306a7ac3ab26f336aa3c723402868a1206711637af791a974aa0e3f0e832

data/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## [0.3.2] - 2026-09-29
+
+### Added
+- `teems transcripts sync` discovers calendar Teams meetings and downloads available WebVTT transcripts into a private XDG data directory. The first run scans 30 days; subsequent runs scan seven, with an idempotent manifest and catch-up after time away. `--date`, `--since`, and `--dry-run` are supported. Recordings and audio are not downloaded.
+- Transcript sync writes speaker-turn Markdown copies to `~/.local/share/teems/transcripts-md/` for local search indexes such as qmd.
+- Transcript sync can run a `transcripts.post_sync_command` from `config.json` (for example, a qmd index refresh) after a sync that changed Markdown. The command gets the changed paths in `TEEMS_TRANSCRIPTS_*` environment variables, is bounded by `post_sync_timeout` (default 300 seconds), and warns rather than failing the sync. `--no-post-sync` skips it for one run.
+- Transcript sync keeps one transcript per recording, so meetings that were restarted mid-session no longer lose the later recording's transcript. Existing per-meeting downloads are reused when identical rather than duplicated.
+- `teems meeting --json` prints call events, recording links, and transcript markers as JSON (the option was documented but ignored).
+- `teems meeting --transcript --recording-url URL` downloads the transcript for a specific recording in the meeting instead of the first one.
+
+## [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

data/README.md

@@ -87,11 +87,48 @@ teems meeting <thread-id> --transcript -o ~/Downloads  # Download transcript (VT
 teems meeting <thread-id> --recording -o ~/Downloads   # Download recording (MP4)
 teems meeting <thread-id> --recording --transcript -o ~/Downloads  # Both, with embedded subtitles
 teems meeting <event-id>                           # By calendar event ID (AAMk...)
+teems meeting <event-id> --date 2026-09-29 --json  # Call events + recording links as JSON
+teems meeting <event-id> --date 2026-09-29 --transcript --recording-url <url>  # A specific recording
 teems meeting "https://teams.microsoft.com/..."    # By Teams URL or recap link
 ```
 
 Recording download requires `ffmpeg` (`brew install ffmpeg`) and downloads via DASH streaming with 5 parallel threads. No browser required.
 
+#### Transcript sync
+
+```bash
+teems transcripts sync --dry-run          # Preview meetings and recording counts
+teems transcripts sync                    # First run: 30 days; later: 7 days
+teems transcripts sync --date 2026-09-28  # Retry a specific day
+teems transcripts sync --since 30         # Explicit historical backfill
+teems transcripts sync --no-post-sync     # Skip the configured post-sync command once
+```
+
+This saves **only WebVTT transcripts** in `~/.local/share/teems/transcripts/` on the machine running the command, separate from live-caption `meeting-capture` files. Each sync also writes speaker-turn Markdown copies to `~/.local/share/teems/transcripts-md/` (regenerated when missing or older than the VTT) for local search tools such as [qmd](https://github.com/tobi/qmd). Each recording keeps its own transcript, so a meeting restarted mid-session yields one VTT per recording. A private manifest in `~/.local/state/teems/transcript-sync.json` makes repeats idempotent and catches up after time away (up to 30 days). Data and state directories are mode 0700; transcripts and the manifest are mode 0600. The calendar scan retries unavailable transcripts within the lookback window; errors return a nonzero exit code. To run every evening on a GFE, schedule `teems transcripts sync` there via launchd.
+
+Coverage is **calendar Teams meetings with a saved and accessible recording transcript**, not every meeting attended: ad-hoc calls, meetings with no saved transcript/recording, and inaccessible organizer-owned artifacts cannot be recovered by this route. No audio/video is downloaded, and nothing is copied to another machine.
+
+To search the Markdown locally with qmd, keep it in a dedicated index so refreshes don't re-scan other collections:
+
+```bash
+qmd --index teems-transcripts collection add ~/.local/share/teems/transcripts-md --name teems-transcripts --mask '**/*.md'
+qmd --index teems-transcripts update && qmd --index teems-transcripts embed
+qmd --index teems-transcripts query "what did we decide about monitoring?"
+```
+
+To refresh that index automatically, set a post-sync command in `~/.config/teems/config.json`:
+
+```json
+{
+  "transcripts": {
+    "post_sync_command": "qmd --index teems-transcripts update && qmd --index teems-transcripts embed",
+    "post_sync_timeout": 900
+  }
+}
+```
+
+The command runs via `sh -c` only after a sync writes or regenerates Markdown; not on `--dry-run`, when nothing changed, or with `--no-post-sync`. It receives `TEEMS_TRANSCRIPTS_CHANGED` (newline-separated Markdown paths), `TEEMS_TRANSCRIPTS_CHANGED_COUNT`, `TEEMS_TRANSCRIPTS_MARKDOWN_DIR`, and `TEEMS_TRANSCRIPTS_DIR`, and is killed after `post_sync_timeout` seconds (default 300). A failure or timeout prints a warning but does not change the sync's exit code.
+
 ### People
 
 ```bash

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/cli.rb

@@ -48,6 +48,7 @@ module Teems
       'channels' => Commands::Channels,
       'chats' => Commands::Chats,
       'meeting' => Commands::Meeting,
+      'transcripts' => Commands::Transcripts,
       'messages' => Commands::Messages,
       'sync' => Commands::Sync,
       'who' => Commands::Who,

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/help.rb

@@ -9,6 +9,7 @@ module Teems
       ['channels', 'List joined teams and channels'],
       ['chats', 'List recent chats'],
       ['meeting', 'View meeting details, chat, transcripts, and recordings'],
+      ['transcripts', 'Sync saved meeting transcripts to this machine'],
       ['messages', 'Read messages from a channel or chat'],
       ['sync', 'Sync chat history locally'],
       ['who', "Look up a user's profile"],
@@ -83,6 +84,7 @@ module Teems
             teems channels                 List all channels
             teems chats                    List recent chats
             teems messages <channel-id>    Read messages from a channel
+            teems transcripts sync         Download recent meeting transcripts
             teems who                      Show your profile
             teems who john                 Search for a user
             teems org                      Show your org chart

data/lib/teems/commands/meeting.rb

@@ -22,10 +22,14 @@ module Teems
         --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)
+        --recording-url URL  With --transcript, use this recording's transcript
+                             (a meeting restarted mid-session has several)
         -o, --output-dir Directory for downloads (default: current directory)
         -v, --verbose    Show debug output
         -q, --quiet      Suppress output
-        --json           Output as JSON
+        --json           Output meeting details (call events, recordings) as JSON
         -h, --help       Show this help
 
       EXAMPLES:
@@ -36,6 +40,8 @@ module Teems
         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... --date 2026-05-04 --json  # List recordings
         teems meeting AAMkAGVmMDEz...        # By calendar event ID
     HELP
 
@@ -47,6 +53,8 @@ module Teems
         '--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 },
+        '--recording-url' => ->(opts, args) { opts[:recording_url] = args.shift },
         '-o' => ->(opts, args) { opts[:output_dir] = args.shift },
         '--output-dir' => ->(opts, args) { opts[:output_dir] = args.shift }
       }.freeze
@@ -164,6 +172,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)
@@ -364,6 +382,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
@@ -396,13 +608,33 @@ module Teems
       end
     end
 
+    # Machine-readable meeting details; `teems transcripts sync` uses these to enumerate recordings.
+    module MeetingJsonSummary
+      private
+
+      def output_meeting_json(target, classified)
+        output_json(thread_id: target[:thread_id],
+                    call_events: classified[:call_events].map { |event| json_call_event(event) },
+                    recordings: classified[:recordings].map { |rec| rec.slice(:time, :url, :call_id) },
+                    transcripts: classified[:transcripts].map { |item| item.slice(:time) })
+        0
+      end
+
+      def json_call_event(event)
+        event.slice(:time, :call_id, :duration).merge(participants: event[:participants].map { |part| part[:name] })
+      end
+    end
+
     # View meeting details, chat, transcripts, and recordings
     class Meeting < Base
       include MeetingTargetResolver
       include MeetingMessageParser
       include MeetingDisplay
+      include MeetingJsonSummary
       include MeetingChatDisplay
       include MeetingCallFilter
+      include MeetingDateFilter
+      include MeetingPagination
       include MeetingTranscript
       include MeetingRecording
 
@@ -422,6 +654,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
@@ -442,11 +681,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
@@ -464,6 +713,7 @@ module Teems
         media = media_output_spec
         return download_media_with_transcript(target, classified, media) if media
         return download_transcript(target, classified) || 0 if @options[:transcript]
+        return output_meeting_json(target, classified) if @options[:json]
 
         display_meeting_summary(target, classified)
         0

data/lib/teems/commands/meeting_transcript.rb

@@ -138,24 +138,39 @@ module Teems
       end
     end
 
+    # Chooses which recording's transcript to fetch (--recording-url, else the first link).
+    module MeetingRecordingSelection
+      private
+
+      def first_recording_url(classified)
+        @options[:recording_url] || recording_urls(classified).first
+      end
+
+      def unknown_recording_url?(classified)
+        requested = @options[:recording_url]
+        requested && !recording_urls(classified).include?(requested)
+      end
+
+      def recording_urls(classified) = classified[:recordings].filter_map { |rec| rec[:url] }
+    end
+
     # Downloads meeting transcripts via SharePoint API (no Safari required)
     module MeetingTranscript
+      include MeetingRecordingSelection
       include EmbedPageParser
       include MeetingFilename
 
       private
 
       def download_transcript(target, classified)
+        return error('--recording-url is not a recording in this meeting') if unknown_recording_url?(classified)
+
         sharing_url = target[:fileUrl] || first_recording_url(classified)
         return error('No recording sharing link found for transcript download') unless sharing_url
 
         execute_transcript_pipeline(sharing_url)
       end
 
-      def first_recording_url(classified)
-        classified[:recordings].filter_map { |rec| rec[:url] }.first
-      end
-
       def execute_transcript_pipeline(sharing_url)
         info('Fetching transcript via SharePoint...')
         embed_url = fetch_embed_url(sharing_url)

data/lib/teems/commands/messages.rb

@@ -24,6 +24,7 @@ module Teems
         teems messages 19:abc123@thread.v2         # Read chat messages
         teems messages 19:abc123@thread.v2 -n 50   # Show 50 messages
         teems messages "https://teams.microsoft.com/l/message/19:abc@thread.v2/123?context=..."
+                                                   # Show the linked message and its thread replies
     HELP
 
     # Display formatting for messages command
@@ -167,10 +168,51 @@ module Teems
       end
     end
 
+    # Fetch and render a single message and its thread replies
+    module ThreadFetch
+      private
+
+      def fetch_thread(thread_id, message_id)
+        api = runner.messages_api
+        parent_data = with_token_refresh { api.message(thread_id: thread_id, message_id: message_id) }
+        replies_data = with_token_refresh do
+          api.replies(thread_id: thread_id, message_id: message_id, limit: @options[:limit])
+        end
+        display_thread(parent_data, extract_messages_data(replies_data))
+      rescue ApiError => e
+        error("Failed to fetch message: #{e.message}")
+      end
+
+      def display_thread(parent_data, replies_data)
+        parent = Models::Message.from_api(parent_data)
+        replies = replies_data.map { |data| Models::Message.from_api(data) }.reject(&:system_message?).reverse
+        return output_json(thread_to_hash(parent, replies)) if @options[:json]
+
+        render_thread(parent, replies)
+        download_attachments([parent, *replies]) if @options[:download]
+        0
+      end
+
+      def render_thread(parent, replies)
+        display_message(parent)
+        count = replies.length
+        return if count.zero?
+
+        puts output.gray("--- #{count} #{count == 1 ? 'reply' : 'replies'} ---")
+        puts
+        replies.each { |reply| display_message(reply) }
+      end
+
+      def thread_to_hash(parent, replies)
+        { parent: message_to_hash(parent), replies: replies.map { |reply| message_to_hash(reply) } }
+      end
+    end
+
     # Read messages from a channel or chat
     class Messages < Base
       include MessagesDisplay
       include AttachmentDownload
+      include ThreadFetch
 
       def initialize(args, runner:)
         @options = {}
@@ -231,12 +273,17 @@ module Teems
       def apply_parsed_url(result)
         conversation_id = result.conversation_id
         team_id = result.team_id
-        debug("Parsed URL: conversation=#{conversation_id}, team=#{team_id}")
+        message_id = result.message_id
+        debug("Parsed URL: conversation=#{conversation_id}, team=#{team_id}, message=#{message_id}")
         @options[:team_id] = team_id if team_id
+        @options[:message_id] = message_id if message_id
         conversation_id
       end
 
       def fetch_messages(target)
+        message_id = @options[:message_id]
+        return fetch_thread(target, message_id) if message_id
+
         @options[:team_id] ? fetch_channel_messages(target) : fetch_chat_messages(target)
       end
 

data/lib/teems/commands/org.rb

@@ -7,16 +7,18 @@ module Teems
       private
 
       def walk_manager_chain(target_id)
-        managers = []
-        current_id = target_id
         fetch = method(target_is_me? ? :fetch_my_manager : :fetch_user_manager)
-        collect_managers(managers, current_id, fetch)
+        collect_managers(target_id, fetch, Set[target_id])
       end
 
-      def collect_managers(managers, current_id, fetch)
+      def collect_managers(current_id, fetch, visited)
+        managers = []
         while (mgr = fetch.call(current_id))
+          mgr_id = mgr.id
+          break unless visited.add?(mgr_id)
+
           managers.unshift(mgr)
-          current_id = mgr.id
+          current_id = mgr_id
           fetch = method(:fetch_user_manager)
         end
         managers