teems 0.2.0 → 0.3.1

data/lib/teems/commands/meeting_recording.rb

@@ -176,32 +176,86 @@ module Teems
       end
     end
 
+    # Writes video/audio output files from downloaded DASH tracks via ffmpeg
+    module RecordingOutputWriter
+      private
+
+      def produce_outputs(video_path, audio_path, media)
+        video_result = media[:video] ? write_video_output(video_path, audio_path) : true
+        audio_result = media[:audio] ? write_audio_output(audio_path) : true
+        FileUtils.rm_f([video_path, audio_path].compact)
+        video_result && audio_result ? 0 : 1
+      end
+
+      def write_video_output(video_path, audio_path)
+        output_path = File.join(@rec_dir, "#{@recording_stem}.mp4")
+        info('Merging video and audio tracks...')
+        merged = run_ffmpeg('-i', video_path, '-i', audio_path, '-c', 'copy', output_path)
+        return error('ffmpeg merge failed') && false unless merged
+
+        embed_subtitle_if_available(output_path)
+        success("Recording saved to #{output_path}")
+        true
+      end
+
+      def write_audio_output(audio_path)
+        output_path = File.join(@rec_dir, "#{@recording_stem}.m4a")
+        info('Remuxing audio track...')
+        remuxed = run_ffmpeg('-i', audio_path, '-c', 'copy', output_path)
+        return error('ffmpeg audio remux failed') && false unless remuxed
+
+        success("Audio saved to #{output_path}")
+        true
+      end
+
+      def embed_subtitle_if_available(video_path)
+        vtt_path = paired_vtt_path(video_path)
+        return unless vtt_path
+
+        info('Embedding transcript as subtitle track...')
+        final_path = video_path.sub('.mp4', '_subs.mp4')
+        return unless run_ffmpeg('-i', video_path, '-i', vtt_path, '-c', 'copy', '-c:s', 'mov_text', final_path)
+
+        FileUtils.mv(final_path, video_path)
+      end
+
+      def paired_vtt_path(video_path)
+        paired = video_path.sub(/\.mp4\z/, '.vtt')
+        return paired if File.exist?(paired)
+
+        Dir.glob(File.join(File.dirname(video_path), '*.vtt')).first
+      end
+    end
+
     # Downloads meeting recordings via DASH streaming from SharePoint
     module MeetingRecording
+      include MeetingFilename
       include RecordingResolver
       include SegmentDownloader
+      include RecordingOutputWriter
 
       MANIFEST_PARAMS = 'format=dash&part=index'
 
       private
 
-      def download_recording(target, classified)
+      def download_recording(target, classified, media: { video: true, audio: false })
         sharing_url = target[:fileUrl] || classified[:recordings].filter_map { |rec| rec[:url] }.first
         return error('No recordings found for this meeting') unless sharing_url
         return error('ffmpeg is required. Install with: brew install ffmpeg') unless ffmpeg?
 
-        execute_recording_pipeline(sharing_url)
+        execute_recording_pipeline(sharing_url, media)
       end
 
-      def execute_recording_pipeline(sharing_url)
-        info('Fetching recording via SharePoint...')
+      def execute_recording_pipeline(sharing_url, media)
+        info("Fetching #{media[:video] ? 'recording' : 'audio'} via SharePoint...")
         file_info = resolve_recording_file_info(sharing_url)
         return 1 unless file_info
 
+        @recording_stem = derive_output_stem(file_info[:name])
         manifest = fetch_dash_manifest(file_info[:transform_url])
         return error('Could not fetch DASH manifest') unless manifest
 
-        download_and_assemble(manifest)
+        download_and_assemble(manifest, media)
       end
 
       def fetch_dash_manifest(transform_url)
@@ -227,29 +281,33 @@ module Teems
         nil
       end
 
-      def download_and_assemble(manifest_xml)
+      def download_and_assemble(manifest_xml, media)
         tracks = DashManifestParser.new(manifest_xml).parse
-        selected = select_tracks(tracks)
+        selected = select_tracks(tracks, media)
         return error('No video/audio tracks found in manifest') unless selected
 
-        assemble_recording(selected, manifest_xml)
+        assemble_recording(selected, manifest_xml, media)
       end
 
-      def select_tracks(tracks)
+      def select_tracks(tracks, media)
         grouped = tracks.group_by(&:type)
-        video = grouped['video']&.first
         audio = grouped['audio']&.first
-        video && audio ? { video: video, audio: audio } : nil
+        return nil unless audio
+
+        video = grouped['video']&.first
+        return nil if media[:video] && !video
+
+        { video: video, audio: audio }
       end
 
-      def assemble_recording(selected, manifest_xml)
+      def assemble_recording(selected, manifest_xml, media)
         @rec_dir = @options[:output_dir] || '.'
         FileUtils.mkdir_p(@rec_dir)
         @rec_base_url = manifest_xml.match(%r{<BaseURL>([^<]+)</BaseURL>})&.then { _1[1] } || ''
 
-        video_path = write_track(selected[:video], 'video')
         audio_path = write_track(selected[:audio], 'audio')
-        merge_and_finalize(video_path, audio_path, @rec_dir)
+        video_path = media[:video] ? write_track(selected[:video], 'video') : nil
+        produce_outputs(video_path, audio_path, media)
       end
 
       def write_track(track, label)
@@ -261,29 +319,6 @@ module Teems
         path
       end
 
-      def merge_and_finalize(video_path, audio_path, dir)
-        output_path = File.join(dir, 'recording.mp4')
-        info('Merging video and audio tracks...')
-        merged = run_ffmpeg('-i', video_path, '-i', audio_path, '-c', 'copy', output_path)
-        FileUtils.rm_f([video_path, audio_path])
-
-        return error('ffmpeg merge failed') unless merged
-
-        embed_subtitle_if_available(output_path)
-        success("Recording saved to #{output_path}")
-      end
-
-      def embed_subtitle_if_available(video_path)
-        vtt_path = Dir.glob(File.join(File.dirname(video_path), '*.vtt')).first
-        return unless vtt_path
-
-        info('Embedding transcript as subtitle track...')
-        final_path = video_path.sub('.mp4', '_subs.mp4')
-        return unless run_ffmpeg('-i', video_path, '-i', vtt_path, '-c', 'copy', '-c:s', 'mov_text', final_path)
-
-        FileUtils.mv(final_path, video_path)
-      end
-
       def run_ffmpeg(*)
         system('ffmpeg', '-y', *, out: File::NULL, err: File::NULL)
       end

data/lib/teems/commands/meeting_transcript.rb

@@ -2,6 +2,34 @@
 
 module Teems
   module Commands
+    # Derives a human-friendly output filename stem from a SharePoint recording/transcript name.
+    # SharePoint format is typically "<subject>-YYYYMMDD_HHMMSS[-Meeting Recording].<ext>"
+    # which we reshape into "YYYY-MM-DD - <subject>".
+    module MeetingFilename
+      SHAREPOINT_NAME_RE = /\A(.+)-(\d{4})(\d{2})(\d{2})_\d{6}\z/
+      UNSAFE_FILENAME_CHARS = %r{[/\\:*?"<>|\x00]}
+
+      private
+
+      def derive_output_stem(sharepoint_name)
+        base = File.basename(sharepoint_name.to_s, '.*').sub(/-Meeting Recording\z/, '')
+        sanitize_filename(reshape_sharepoint_name(base))
+      end
+
+      def reshape_sharepoint_name(base)
+        captures = base.match(SHAREPOINT_NAME_RE)&.captures
+        return base unless captures
+
+        subject, year, month, day = captures
+        "#{year}-#{month}-#{day} - #{subject}"
+      end
+
+      def sanitize_filename(name)
+        cleaned = name.gsub(UNSAFE_FILENAME_CHARS, '_').strip
+        cleaned.empty? ? 'recording' : cleaned
+      end
+    end
+
     # Parses SharePoint embed page HTML to extract file metadata
     module EmbedPageParser
       SP_ITEM_RE = %r{(https://[^/]+(?::\d+)?/.+?)/_api/v2\.\d+/drives/([^/]+)/items/([^/?]+)}
@@ -113,6 +141,7 @@ module Teems
     # Downloads meeting transcripts via SharePoint API (no Safari required)
     module MeetingTranscript
       include EmbedPageParser
+      include MeetingFilename
 
       private
 
@@ -196,11 +225,11 @@ module Teems
         url ? { url: url, name: File.basename(entry['name'] || 'transcript.vtt') } : nil
       end
 
+      # Prefers the recording's name (via @transcript_info) so transcript and recording share a stem.
       def save_transcript(transcript)
         dir = @options[:output_dir] || '.'
         FileUtils.mkdir_p(dir)
-        path = File.join(dir, File.basename(transcript[:name]))
-
+        path = File.join(dir, "#{derive_output_stem(@transcript_info[:name] || transcript[:name])}.vtt")
         info("Downloading transcript to #{path}...")
         vtt = fetch_and_convert_transcript(transcript[:url])
         return error('Failed to download transcript content') unless vtt

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

@@ -15,9 +15,14 @@ module Teems
 
       ON OPTIONS:
         --message TEXT       Auto-reply and status message
-        --start DATE         Schedule start (YYYY-MM-DD), enables scheduled mode
-        --end DATE           Schedule end (YYYY-MM-DD), required with --start
-        --event              Create an all-day OOO calendar event for notify list
+        --start TIME         Schedule start; enables scheduled mode. Formats:
+                               YYYY-MM-DD              (all-day)
+                               YYYY-MM-DD HH:MM        (timed)
+                               "today HH:MM", "tomorrow HH:MM", HH:MM
+        --end TIME           Schedule end, required with --start.
+                             Must match --start style (date or timed).
+        --event              Create an OOO calendar event for notify list
+        --invite EMAILS      Comma-separated invitees; overrides config notify list
         --no-status          Skip setting Teams status/presence
 
       CONFIGURATION:
@@ -38,10 +43,43 @@ module Teems
         teems ooo on                       # Enable OOO (always on)
         teems ooo on --message "Vacation"  # Custom message
         teems ooo on --start 2026-04-14 --end 2026-04-18
+        teems ooo on --start "today 14:00" --end "today 17:00" \\
+          --message "Dr appt"
         teems ooo off                      # Disable OOO
         teems ooo config                   # Show config
     HELP
 
+    # A parsed --start or --end value. Produces ISO datetime strings for
+    # auto-reply schedules and calendar events. Kind is :timed, :date, or
+    # :unscheduled; value is a Time, Date, or nil respectively.
+    OooScheduleEntry = Data.define(:kind, :value) do
+      def timed? = kind == :timed
+      def all_day? = kind == :date
+      def unscheduled? = kind == :unscheduled
+
+      def reply_start_iso
+        timed? ? value.strftime('%Y-%m-%dT%H:%M:%S') : "#{value}T00:00:00"
+      end
+
+      def reply_end_iso
+        timed? ? value.strftime('%Y-%m-%dT%H:%M:%S') : "#{value}T23:59:59"
+      end
+
+      def event_start_iso
+        base = value || Date.today
+        timed? ? base.strftime('%Y-%m-%dT%H:%M:%S') : "#{base}T00:00:00"
+      end
+
+      def event_end_iso
+        base = value || Date.today
+        return base.strftime('%Y-%m-%dT%H:%M:%S') if timed?
+
+        "#{base + 1}T00:00:00"
+      end
+    end
+
+    UNSCHEDULED_OOO_SCHEDULE = OooScheduleEntry.new(kind: :unscheduled, value: nil)
+
     # Displays current OOO status (auto-reply + presence)
     module OooDisplay
       private
@@ -90,13 +128,20 @@ module Teems
       end
 
       def render_schedule(replies)
-        start_dt = replies.dig('scheduledStartDateTime', 'dateTime')
-        end_dt = replies.dig('scheduledEndDateTime', 'dateTime')
-        puts "  Schedule: #{format_dt(start_dt)} to #{format_dt(end_dt)}" if start_dt
+        start_entry = replies['scheduledStartDateTime']
+        return unless start_entry
+
+        start_str = format_schedule_dt(start_entry)
+        end_str = format_schedule_dt(replies['scheduledEndDateTime'])
+        puts "  Schedule: #{start_str} to #{end_str} #{short_tz_label}"
       end
 
-      def format_dt(raw)
-        Time.parse(raw).strftime('%Y-%m-%d %H:%M')
+      def format_schedule_dt(entry)
+        return '' unless entry
+
+        raw = entry['dateTime']
+        time = entry['timeZone'] == 'UTC' ? Time.parse("#{raw} UTC").getlocal : Time.parse(raw)
+        time.strftime('%Y-%m-%d %H:%M')
       rescue ArgumentError
         raw.to_s
       end
@@ -118,6 +163,60 @@ module Teems
       end
     end
 
+    # Parses and validates --start/--end into @schedule_start and @schedule_end.
+    # Each parsed value is a tuple: [:date, Date] for all-day or [:timed, Time] for timed.
+    module OooSchedule
+      private
+
+      def validate_create_options
+        start_raw = @options[:start]
+        end_raw = @options[:end]
+        return unless start_raw
+        return missing_end_error unless end_raw
+
+        parse_schedule_pair(start_raw, end_raw)
+      end
+
+      def missing_end_error
+        error('--end is required when using --start')
+        1
+      end
+
+      def parse_schedule_pair(start_raw, end_raw)
+        @schedule_start = parse_schedule_value(start_raw)
+        return invalid_schedule_error(:start, start_raw) unless @schedule_start
+
+        @schedule_end = parse_schedule_value(end_raw)
+        return invalid_schedule_error(:end, end_raw) unless @schedule_end
+
+        return mixed_schedule_error if schedule_kind(@schedule_start) != schedule_kind(@schedule_end)
+
+        nil
+      end
+
+      def parse_schedule_value(raw)
+        time = parse_time_input(raw)
+        return OooScheduleEntry.new(kind: :timed, value: time) if time
+
+        OooScheduleEntry.new(kind: :date, value: Date.parse(raw))
+      rescue Date::Error
+        nil
+      end
+
+      def invalid_schedule_error(key, raw)
+        error("Invalid value for --#{key}: #{raw}. " \
+              "Use YYYY-MM-DD, HH:MM, 'today HH:MM', 'tomorrow HH:MM', or 'YYYY-MM-DD HH:MM'")
+        1
+      end
+
+      def mixed_schedule_error
+        error('--start and --end must both be dates or both include a time')
+        1
+      end
+
+      def schedule_kind(parsed) = parsed.kind
+    end
+
     # Enables/disables OOO: auto-reply, status message, presence, calendar event
     module OooActions
       private
@@ -139,28 +238,6 @@ module Teems
         results.values.all? ? 0 : 1
       end
 
-      def validate_create_options
-        validate_schedule_dates || validate_date_format(:start) || validate_date_format(:end)
-      end
-
-      def validate_schedule_dates
-        return unless @options[:start] && !@options[:end]
-
-        error('--end is required when using --start')
-        1
-      end
-
-      def validate_date_format(key)
-        value = @options[key]
-        return unless value
-
-        Date.parse(value)
-        nil
-      rescue ArgumentError
-        error("Invalid date for --#{key}: #{value}. Expected format: YYYY-MM-DD")
-        1
-      end
-
       def execute_ooo_steps
         results = {}
         results[:auto_reply] = set_auto_reply
@@ -261,37 +338,29 @@ module Teems
       end
 
       def add_schedule(settings)
-        tz = detect_timezone
-        settings[:scheduledStartDateTime] = { dateTime: "#{@options[:start]}T00:00:00", timeZone: tz }
-        settings[:scheduledEndDateTime] = { dateTime: "#{@options[:end]}T23:59:59", timeZone: tz }
+        timezone = detect_timezone
+        settings[:scheduledStartDateTime] = { dateTime: @schedule_start.reply_start_iso, timeZone: timezone }
+        settings[:scheduledEndDateTime] = { dateTime: @schedule_end.reply_end_iso, timeZone: timezone }
       end
 
       def build_ooo_event
+        timezone = detect_timezone
         { subject: status_message_text,
-          start: ooo_event_time(:start),
-          end: ooo_event_time(:end),
-          isAllDay: true,
-          showAs: 'free',
-          isReminderOn: false,
-          isOnlineMeeting: false,
+          start: { dateTime: @schedule_start.event_start_iso, timeZone: timezone },
+          end: { dateTime: @schedule_end.event_end_iso, timeZone: timezone },
+          isAllDay: !@schedule_start.timed?, showAs: 'free',
+          isReminderOn: false, isOnlineMeeting: false,
           transactionId: SecureRandom.uuid,
           attendees: notify_list.map { |email| ooo_attendee(email) },
           responseRequested: false }
       end
 
-      def ooo_event_time(field)
-        date = @options[field] || Date.today.to_s
-        end_date = field == :end ? (Date.parse(date) + 1).to_s : date
-        tz = detect_timezone
-        { dateTime: "#{end_date}T00:00:00", timeZone: tz }
-      end
-
       def ooo_attendee(email)
         { emailAddress: { address: email }, type: 'required' }
       end
 
       def notify_list
-        @notify_list ||= ooo_config('notify') || []
+        @notify_list ||= @options[:invite] || ooo_config('notify') || []
       end
 
       def ooo_config(key)
@@ -302,20 +371,27 @@ module Teems
     # Manage out-of-office: auto-reply, status, presence, and calendar event
     class Ooo < Base
       include Support::Timezone
+      include Support::TimeParsing
       include OooDisplay
+      include OooSchedule
       include OooActions
       include OooBuildHelpers
 
       def initialize(args, runner:)
         @options = {}
+        @schedule_start = UNSCHEDULED_OOO_SCHEDULE
+        @schedule_end = UNSCHEDULED_OOO_SCHEDULE
         super
       end
 
+      SPLIT_OOO_EMAILS = ->(raw) { raw ? raw.split(',').map(&:strip).reject(&:empty?) : [] }
+
       OOO_OPTIONS = {
         '--message' => ->(opts, args) { opts[:message] = args.shift },
         '--start' => ->(opts, args) { opts[:start] = args.shift },
         '--end' => ->(opts, args) { opts[:end] = args.shift },
         '--event' => ->(opts, _args) { opts[:event] = true },
+        '--invite' => ->(opts, args) { opts[:invite] = SPLIT_OOO_EMAILS.call(args.shift) },
         '--no-status' => ->(opts, _args) { opts[:no_status] = true }
       }.freeze
 

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

data/lib/teems/services/headless_extract.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'open3'
 require 'json'
 require 'net/http'
 require 'uri'
@@ -24,7 +23,7 @@ module Teems
 
       def compile_helper(source, binary)
         log('Compiling headless token helper...')
-        _stdout, stderr, status = Open3.capture3(*swiftc_command(source, binary))
+        _stdout, stderr, status = Support::Subprocess.capture3(*swiftc_command(source, binary))
         log_helper_stderr(stderr)
         status.success? ? binary : log_and_nil('Failed to compile helper')
       rescue Errno::ENOENT
@@ -117,7 +116,7 @@ module Teems
         return nil unless binary
 
         log('Trying headless token extraction...')
-        output, stderr, status = Open3.capture3(binary, *build_helper_args)
+        output, stderr, status = Support::Subprocess.capture3(binary, *build_helper_args)
         log_helper_stderr(stderr)
         handle_helper_result(output, status.exitstatus)
       rescue StandardError => e

data/lib/teems/services/safari_js_runner.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-require 'open3'
-
 module Teems
   module Services
     # Runs JavaScript in Safari's current tab via AppleScript
@@ -74,7 +72,7 @@ module Teems
       end
 
       def run_applescript(script)
-        out, _err, status = Open3.capture3('osascript', '-e', script)
+        out, _err, status = Support::Subprocess.capture3('osascript', '-e', script)
         return nil unless status.success?
 
         out.strip