teems 0.1.0 → 0.3.0

data/lib/teems/commands/meeting_recording.rb

@@ -0,0 +1,331 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    # Parses DASH MPD manifest XML to extract video/audio segment info
+    class DashManifestParser
+      # Describes a media track (video or audio) with its segment template info
+      Track = Data.define(:type, :init_url, :media_template, :segment_count, :timescale, :segments)
+
+      # A single media segment with start time and duration in timescale units
+      Segment = Data.define(:start, :duration)
+
+      ADAPTATION_RE = %r{<AdaptationSet[^>]*contentType="(video|audio)"(.*?)</AdaptationSet>}m
+      TEMPLATE_RE = /<SegmentTemplate[^>]*/
+      TIMELINE_RE = %r{<SegmentTimeline>(.*?)</SegmentTimeline>}m
+      SEGMENT_RE = /<S\s[^>]*>/
+      REP_RE = /<Representation[^>]*id="([^"]+)"/
+
+      def initialize(mpd_xml)
+        @xml = mpd_xml
+        @attrs = nil
+        @rep_id = nil
+      end
+
+      def parse
+        tracks = []
+        @xml.scan(ADAPTATION_RE) do |type, body|
+          track = parse_adaptation(type, body)
+          tracks << track if track
+        end
+        tracks
+      end
+
+      private
+
+      def parse_adaptation(type, body)
+        template_match = body.match(TEMPLATE_RE)
+        return nil unless template_match
+
+        @attrs = template_match[0]
+        @rep_id = body.match(REP_RE)&.then { _1[1] } || ''
+        segments = parse_timeline(body)
+        return nil if segments.empty?
+
+        build_track(type, segments)
+      end
+
+      def build_track(type, segments)
+        timescale_val = extract_attr(@attrs, 'timescale').to_i
+        Track.new(type: type,
+                  init_url: decode_template(extract_attr(@attrs, 'initialization')),
+                  media_template: decode_template(extract_attr(@attrs, 'media')),
+                  segment_count: segments.length,
+                  timescale: timescale_val.positive? ? timescale_val : 1,
+                  segments: segments)
+      end
+
+      def decode_template(url)
+        return '' unless url
+
+        url.gsub('&amp;', '&').gsub('$RepresentationID$', @rep_id.to_s)
+      end
+
+      def parse_timeline(body)
+        timeline_match = body.match(TIMELINE_RE)
+        return [] unless timeline_match
+
+        segments = []
+        time = 0
+        timeline_match[1].scan(SEGMENT_RE) do |seg_tag|
+          time = parse_segment_tag(seg_tag, time, segments)
+        end
+        segments
+      end
+
+      def parse_segment_tag(seg_tag, time, segments)
+        start_time = extract_attr(seg_tag, 't').to_i
+        duration = extract_attr(seg_tag, 'd').to_i
+        repeat_count = extract_attr(seg_tag, 'r').to_i
+
+        time = start_time if start_time.positive?
+        (repeat_count + 1).times do
+          segments << Segment.new(start: time, duration: duration)
+          time += duration
+        end
+        time
+      end
+
+      def extract_attr(tag, name)
+        match = tag.match(/#{name}="([^"]*)"/)
+        match ? match[1] : nil
+      end
+    end
+
+    # Downloads DASH segments in parallel and assembles track data
+    module SegmentDownloader
+      PARALLEL_DOWNLOADS = 5
+
+      private
+
+      def download_track_segments(track, base_url)
+        urls = track.segments.map { |seg| resolve_url(base_url, segment_path(track, seg)) }
+        init = fetch_segment(resolve_url(base_url, track.init_url))
+        results = parallel_fetch(urls, track.segment_count)
+        String.new(init).tap { |data| results.each { |seg| data << seg } }
+      end
+
+      def segment_path(track, seg)
+        track.media_template.gsub('$Time$', seg.start.to_s)
+      end
+
+      def parallel_fetch(urls, total)
+        init_seg_state(urls.length, total)
+        urls.each_with_index { |url, idx| @seg_state[:queue] << [url, idx] }
+        PARALLEL_DOWNLOADS.times.map { Thread.new { fetch_from_queue } }.each(&:join)
+        check_seg_errors
+        @seg_state[:results]
+      end
+
+      def init_seg_state(count, total)
+        @seg_state = { results: Array.new(count), errors: [],
+                       queue: Queue.new, total: total, mutex: Mutex.new }
+      end
+
+      def check_seg_errors
+        first_error = @seg_state[:errors].first
+        raise first_error if first_error
+      end
+
+      def fetch_from_queue
+        loop do
+          item = @seg_state[:queue].pop(true)
+          @seg_state[:results][item[1]] = fetch_segment(item[0])
+          record_progress
+        rescue ThreadError
+          break
+        rescue StandardError => e
+          @seg_state[:mutex].synchronize { @seg_state[:errors] << e }
+          break
+        end
+      end
+
+      def record_progress
+        @seg_state[:mutex].synchronize do
+          print "\r  Downloading: #{@seg_state[:results].count { _1 }}/#{@seg_state[:total]} segments"
+        end
+      end
+
+      def resolve_url(base_url, path)
+        return path if path.start_with?('http')
+
+        "#{base_url.sub(%r{/[^/]*$}, '/')}#{path}"
+      end
+
+      def fetch_segment(url)
+        Net::HTTP.get_response(URI(url)).tap do |resp|
+          raise Teems::Error, "Segment download failed (#{resp.code})" unless resp.is_a?(Net::HTTPSuccess)
+        end.body
+      end
+    end
+
+    # Resolves recording file info by fetching embed page HTML directly
+    module RecordingResolver
+      include EmbedPageParser
+
+      private
+
+      def resolve_recording_file_info(sharing_url)
+        embed_url = fetch_embed_url(sharing_url)
+        return error('Could not get embed URL for recording') && nil unless embed_url
+
+        file_info = fetch_and_parse_embed(embed_url)
+        return error('Could not extract file info from embed page') && nil unless file_info&.dig(:transform_url)
+
+        { transform_url: file_info[:transform_url], name: file_info[:name] || 'recording.mp4' }
+      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, 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, media)
+      end
+
+      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, media)
+      end
+
+      def fetch_dash_manifest(transform_url)
+        url = build_manifest_url(transform_url)
+        debug("Fetching DASH manifest: #{url}")
+        fetch_manifest_content(url)
+      end
+
+      def build_manifest_url(transform_url)
+        url = transform_url.sub('/thumbnail', '/videomanifest')
+        separator = url.include?('?') ? '&' : '?'
+        "#{url}#{separator}#{MANIFEST_PARAMS}"
+      end
+
+      def fetch_manifest_content(url)
+        result = Net::HTTP.get_response(URI(url))
+        return result.body if result.is_a?(Net::HTTPSuccess)
+
+        debug("Manifest download failed: HTTP #{result.code}")
+        nil
+      rescue IOError, SystemCallError, SocketError, Timeout::Error, OpenSSL::SSL::SSLError => e
+        debug("Manifest download error: #{e.message}")
+        nil
+      end
+
+      def download_and_assemble(manifest_xml, media)
+        tracks = DashManifestParser.new(manifest_xml).parse
+        selected = select_tracks(tracks, media)
+        return error('No video/audio tracks found in manifest') unless selected
+
+        assemble_recording(selected, manifest_xml, media)
+      end
+
+      def select_tracks(tracks, media)
+        grouped = tracks.group_by(&:type)
+        audio = grouped['audio']&.first
+        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, media)
+        @rec_dir = @options[:output_dir] || '.'
+        FileUtils.mkdir_p(@rec_dir)
+        @rec_base_url = manifest_xml.match(%r{<BaseURL>([^<]+)</BaseURL>})&.then { _1[1] } || ''
+
+        audio_path = write_track(selected[:audio], 'audio')
+        video_path = media[:video] ? write_track(selected[:video], 'video') : nil
+        produce_outputs(video_path, audio_path, media)
+      end
+
+      def write_track(track, label)
+        info("Downloading #{label} track (#{track.segment_count} segments)...")
+        data = download_track_segments(track, @rec_base_url)
+        path = File.join(@rec_dir, ".teems_#{label}.mp4")
+        File.binwrite(path, data)
+        puts
+        path
+      end
+
+      def run_ffmpeg(*)
+        system('ffmpeg', '-y', *, out: File::NULL, err: File::NULL)
+      end
+
+      def ffmpeg?
+        system('which', 'ffmpeg', out: File::NULL, err: File::NULL)
+      end
+    end
+  end
+end

data/lib/teems/commands/meeting_transcript.rb

@@ -0,0 +1,270 @@
+# frozen_string_literal: true
+
+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/([^/?]+)}
+      FILE_INFO_RE = /g_fileInfo\s*=\s*(\{.*?\});/m
+
+      private
+
+      def fetch_embed_url(sharing_url)
+        debug("Resolving sharing link: #{sharing_url}")
+        result = with_token_refresh { runner.meetings_api.share_preview(sharing_url) }
+        result['getUrl']
+      rescue ApiError => e
+        debug("Share preview failed: #{e.message}")
+        nil
+      end
+
+      def fetch_and_parse_embed(embed_url)
+        debug("Fetching embed page: #{embed_url}")
+        html = fetch_embed_page(embed_url)
+        return nil unless html
+
+        parse_embed_file_info(html)
+      end
+
+      def fetch_embed_page(url, limit: 3)
+        response = Net::HTTP.get_response(URI(url))
+        return response.body if response.is_a?(Net::HTTPSuccess)
+        return debug("Embed page failed: HTTP #{response.code}") unless response.is_a?(Net::HTTPRedirection)
+        return debug('Too many redirects fetching embed page') unless limit.positive?
+
+        fetch_embed_page(URI.join(url, response['location']).to_s, limit: limit - 1)
+      rescue IOError, SystemCallError, SocketError, Timeout::Error, URI::InvalidURIError, OpenSSL::SSL::SSLError => e
+        debug("Embed page fetch error: #{e.message}")
+        nil
+      end
+
+      def parse_embed_file_info(html)
+        match = html.match(FILE_INFO_RE)
+        unless match
+          debug('g_fileInfo not found in embed page HTML')
+          return nil
+        end
+
+        data = JSON.parse(match[1])
+        build_file_info(data)
+      rescue JSON::ParserError => e
+        debug("Embed page JSON parse error: #{e.message}")
+        nil
+      end
+
+      def build_file_info(data)
+        extras = extract_extras(data)
+        extract_ids(data)&.merge(extras)
+      end
+
+      def extract_extras(data)
+        { drive_token: data['.driveAccessTokenV21'],
+          transform_url: data['.transformUrl'] || data['transformUrl'],
+          name: data['name'] }
+      end
+
+      def extract_ids(data)
+        build_from_sp_item_url(data['.spItemUrl']) || build_from_fields(data)
+      end
+
+      def build_from_sp_item_url(sp_url)
+        return nil unless sp_url
+
+        match = sp_url.match(SP_ITEM_RE)
+        match ? { site_url: match[1], drive_id: match[2], item_id: match[3] } : nil
+      end
+
+      def build_from_fields(data)
+        drive_id = data.dig('libraryId', 'siteId') || data['driveId']
+        item_id = data['itemId'] || data['id']
+        site_url = data['siteUrl'] || data.dig('libraryId', 'siteUrl')
+        [drive_id, item_id, site_url].all? ? { drive_id: drive_id, item_id: item_id, site_url: site_url } : nil
+      end
+    end
+
+    # Converts JSON transcript entries to WebVTT with speaker names
+    class TranscriptFormatter
+      def initialize(entries)
+        @entries = entries
+        @cue = nil
+      end
+
+      def to_vtt
+        cues = @entries.each_with_index.map { |entry, idx| format_cue(entry, idx) }
+        "WEBVTT\n\n#{cues.join}"
+      end
+
+      private
+
+      def format_cue(entry, idx)
+        @cue = entry
+        "#{idx + 1}\n#{cue_timestamps}\n<v #{@cue['speakerDisplayName']}>#{@cue['text']}</v>\n\n"
+      end
+
+      def cue_timestamps
+        "#{truncate_ts(@cue['startOffset'])} --> #{truncate_ts(@cue['endOffset'])}"
+      end
+
+      def truncate_ts(offset)
+        offset ? offset.to_s[0, 12] : '00:00:00.000'
+      end
+    end
+
+    # Downloads meeting transcripts via SharePoint API (no Safari required)
+    module MeetingTranscript
+      include EmbedPageParser
+      include MeetingFilename
+
+      private
+
+      def download_transcript(target, 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)
+        return error('Could not get embed URL from sharing link') unless embed_url
+
+        @transcript_info = fetch_and_parse_embed(embed_url)
+        return error('Could not extract file info from embed page') unless @transcript_info
+
+        transcript = resolve_transcript
+        return error('No transcripts found for this recording') unless transcript
+
+        save_transcript(transcript)
+      end
+
+      def resolve_transcript
+        url = build_transcripts_url
+        debug("Fetching transcripts from: #{url}")
+        fetch_transcript_list(url)
+      end
+
+      def build_transcripts_url
+        "#{@transcript_info[:site_url]}/_api/v2.1" \
+          "/drives/#{@transcript_info[:drive_id]}" \
+          "/items/#{@transcript_info[:item_id]}/media/transcripts"
+      end
+
+      def fetch_transcript_list(url)
+        response = fetch_with_drive_token(url)
+        return nil unless response
+
+        parse_transcript_response(response)
+      rescue JSON::ParserError => e
+        debug("Transcript list JSON parse error: #{e.message}")
+        nil
+      end
+
+      def fetch_with_drive_token(url)
+        result = Net::HTTP.get_response(URI(url), drive_token_headers)
+        return result.body if result.is_a?(Net::HTTPSuccess)
+
+        debug("Transcript list request failed: HTTP #{result.code}")
+        nil
+      rescue IOError, SystemCallError, SocketError, Timeout::Error, OpenSSL::SSL::SSLError => e
+        debug("Transcript list fetch error: #{e.message}")
+        nil
+      end
+
+      def drive_token_headers
+        token = @transcript_info[:drive_token]
+        debug('No drive token; request will be unauthenticated') unless token
+        hdrs = { 'Accept' => 'application/json' }
+        hdrs['Authorization'] = "Bearer #{token}" if token
+        hdrs
+      end
+
+      def parse_transcript_response(body)
+        parsed = JSON.parse(body)
+        api_error = parsed['error']
+        return debug("SharePoint API error: #{api_error}") if api_error
+
+        extract_transcript_entry(parsed)
+      end
+
+      def extract_transcript_entry(parsed)
+        entry = (parsed['value'] || [parsed]).first
+        url = entry&.dig('temporaryDownloadUrl') || entry&.dig('downloadUrl')
+        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, "#{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
+
+        File.write(path, vtt)
+        success("Transcript saved to #{path}")
+      rescue SystemCallError => e
+        error("Could not save transcript: #{e.message}")
+      end
+
+      def fetch_and_convert_transcript(url)
+        json_url = url.include?('?') ? "#{url}&format=json" : "#{url}?format=json"
+        json_content = parse_transcript_json(fetch_transcript_content(json_url))
+        json_content ? TranscriptFormatter.new(json_content['entries']).to_vtt : fetch_transcript_content(url)
+      end
+
+      def parse_transcript_json(raw)
+        return nil unless raw
+
+        data = JSON.parse(raw)
+        data['entries'] ? data : nil
+      rescue JSON::ParserError
+        nil
+      end
+
+      def fetch_transcript_content(url)
+        response = Net::HTTP.get_response(URI(url))
+        return response.body if response.is_a?(Net::HTTPSuccess)
+
+        debug("Transcript download failed: HTTP #{response.code}")
+        nil
+      rescue IOError, SystemCallError, SocketError, Timeout::Error, OpenSSL::SSL::SSLError => e
+        debug("Transcript download error: #{e.message}")
+        nil
+      end
+    end
+  end
+end