teems 0.1.0 → 0.2.0

data/lib/teems/commands/meeting_recording.rb

@@ -0,0 +1,296 @@
+# 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
+
+    # Downloads meeting recordings via DASH streaming from SharePoint
+    module MeetingRecording
+      include RecordingResolver
+      include SegmentDownloader
+
+      MANIFEST_PARAMS = 'format=dash&part=index'
+
+      private
+
+      def download_recording(target, classified)
+        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)
+      end
+
+      def execute_recording_pipeline(sharing_url)
+        info('Fetching recording via SharePoint...')
+        file_info = resolve_recording_file_info(sharing_url)
+        return 1 unless file_info
+
+        manifest = fetch_dash_manifest(file_info[:transform_url])
+        return error('Could not fetch DASH manifest') unless manifest
+
+        download_and_assemble(manifest)
+      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)
+        tracks = DashManifestParser.new(manifest_xml).parse
+        selected = select_tracks(tracks)
+        return error('No video/audio tracks found in manifest') unless selected
+
+        assemble_recording(selected, manifest_xml)
+      end
+
+      def select_tracks(tracks)
+        grouped = tracks.group_by(&:type)
+        video = grouped['video']&.first
+        audio = grouped['audio']&.first
+        video && audio ? { video: video, audio: audio } : nil
+      end
+
+      def assemble_recording(selected, manifest_xml)
+        @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)
+      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 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
+
+      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,241 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    # 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
+
+      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
+
+      def save_transcript(transcript)
+        dir = @options[:output_dir] || '.'
+        FileUtils.mkdir_p(dir)
+        path = File.join(dir, File.basename(transcript[:name]))
+
+        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

data/lib/teems/runner.rb

@@ -3,6 +3,7 @@
 module Teems
   # API factory methods for Runner, extracted to keep method count manageable
   module ApiFactories
+    def meetings_api = Api::Meetings.new(api_client, account)
     def channels_api = Api::Channels.new(api_client, account)
     def chats_api = Api::Chats.new(api_client, account)
     def messages_api = Api::Messages.new(api_client, account)
@@ -56,6 +57,11 @@ module Teems
       Formatters::MessageFormatter.new(output: @output, cache_store: cache_store)
     end
 
+    # Safari JS runner for SharePoint automation
+    def safari_js_runner
+      Services::SafariJsRunner.new(output: @output)
+    end
+
     # Token extractor for Safari automation
     def token_extractor(auth_mode: :default)
       Services::TokenExtractor.new(output: @output, auth_mode: auth_mode)

data/lib/teems/services/api_client.rb

@@ -162,9 +162,9 @@ module Teems
         run_request(path, get_http_for_endpoint(endpoint_key)) { |http| http.request(req) }
       end
 
-      def delete(url, endpoint_key:, account:)
-        uri = URI(url)
-        run_request(uri.path, get_http_for_endpoint(endpoint_key)) do |http|
+      def delete(endpoint_key, path, account:)
+        uri = URI("#{resolve_endpoint(endpoint_key)}#{path}")
+        run_request(path, get_http_for_endpoint(endpoint_key)) do |http|
           req = Net::HTTP::Delete.new(uri)
           apply_auth(req, account, endpoint_key)
           http.request(req)

data/lib/teems/services/safari_js_runner.rb

@@ -0,0 +1,89 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+module Teems
+  module Services
+    # Runs JavaScript in Safari's current tab via AppleScript
+    class SafariJsRunner
+      def initialize(output: nil)
+        @output = output
+      end
+
+      def available? = system('which', 'osascript', out: File::NULL, err: File::NULL)
+
+      def execute_js(js_code)
+        escaped = escape_js(js_code)
+        run_applescript(safari_js_script(escaped))
+      end
+
+      def navigate(url)
+        run_applescript(navigate_script(url))
+      end
+
+      def wait_for_load(timeout: 15)
+        timeout.times do
+          sleep 1
+          return if execute_js('document.readyState') == 'complete'
+        end
+        raise Teems::Error, 'Timed out waiting for page to load'
+      end
+
+      def page_url
+        run_applescript(page_url_script)
+      end
+
+      private
+
+      def escape_js(js_code)
+        js_code.gsub('\\', '\\\\\\\\').gsub('"', '\\"').gsub("\n", '\\n')
+      end
+
+      def safari_js_script(escaped_js)
+        <<~APPLESCRIPT
+          tell application "Safari"
+            if (count of windows) > 0 then
+              return do JavaScript "#{escaped_js}" in current tab of front window
+            end if
+            return ""
+          end tell
+        APPLESCRIPT
+      end
+
+      def navigate_script(url)
+        safe = escape_for_applescript(url)
+        "tell application \"Safari\"\nactivate\n" \
+          "if (count of windows) = 0 then\nmake new document with properties {URL:\"#{safe}\"}\n" \
+          "else\nset URL of current tab of front window to \"#{safe}\"\n" \
+          "end if\nend tell\n"
+      end
+
+      def escape_for_applescript(str)
+        str.gsub('\\', '\\\\\\\\').gsub('"', '\\"')
+      end
+
+      def page_url_script
+        <<~APPLESCRIPT
+          tell application "Safari"
+            if (count of windows) > 0 then
+              return URL of current tab of front window
+            end if
+            return ""
+          end tell
+        APPLESCRIPT
+      end
+
+      def run_applescript(script)
+        out, _err, status = Open3.capture3('osascript', '-e', script)
+        return nil unless status.success?
+
+        out.strip
+      rescue IOError, SystemCallError => e
+        log("AppleScript execution failed: #{e.message}")
+        nil
+      end
+
+      def log(message) = @output&.debug(message)
+    end
+  end
+end

data/lib/teems/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Teems
-  VERSION = '0.1.0'
+  VERSION = '0.2.0'
 end

data/lib/teems.rb

@@ -67,6 +67,7 @@ module Teems
     autoload :TeamsUrlParser, 'teems/services/teams_url_parser'
     autoload :SyncStore, 'teems/services/sync_store'
     autoload :SyncDirNaming, 'teems/services/sync_dir_naming'
+    autoload :SafariJsRunner, 'teems/services/safari_js_runner'
     autoload :SyncEngine, 'teems/services/sync_engine'
   end
 
@@ -93,6 +94,7 @@ module Teems
     autoload :Who, 'teems/commands/who'
     autoload :Ooo, 'teems/commands/ooo'
     autoload :Org, 'teems/commands/org'
+    autoload :Meeting, 'teems/commands/meeting'
     autoload :Status, 'teems/commands/status'
   end
 
@@ -103,6 +105,7 @@ module Teems
     autoload :Channels, 'teems/api/channels'
     autoload :Chats, 'teems/api/chats'
     autoload :Files, 'teems/api/files'
+    autoload :Meetings, 'teems/api/meetings'
     autoload :Messages, 'teems/api/messages'
     autoload :Users, 'teems/api/users'
   end