teems 0.3.2 → 0.8.0

data/lib/teems/commands/meet.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+
+module Teems
+  module Commands
+    MEET_HELP = <<~HELP
+      teems meet - Start a Teams meeting and print its join link
+
+      USAGE:
+        teems meet [minutes] [options]
+
+      Puts a Teams meeting on your calendar, starting now for 30 minutes unless told
+      otherwise, prints its join link (alone on stdout, so it pipes) and opens it here
+      to join. With nobody invited, nothing is sent.
+
+      Joining here matters: people from organizations yours does not trust wait in the
+      lobby until a member of yours joins, even with "Everyone" set to bypass the lobby
+      in Meeting options, and even when invited. Once you are in you can admit them;
+      the meeting usually carries on after you leave.
+
+      OPTIONS:
+        --at TIME            Start: now (default), HH:MM, "today HH:MM",
+                             "tomorrow HH:MM", or "YYYY-MM-DD HH:MM"
+        --title TEXT         Event title (default: Meet now)
+        --with EMAILS        Comma-separated people to invite. Exchange emails
+                             each an invitation, so this asks first
+        -y, --yes            Invite without asking (needed without a terminal)
+        --copy               Also copy the link to the clipboard
+        --no-open            Do not open the link here (just print it)
+        -q, --quiet          Just the link
+        --json               Event ID, title, start, end and link as JSON
+
+      EXAMPLES:
+        teems meet                         # Now, 30 minutes, and join here
+        teems meet 60 --title "Pairing"    # Now, an hour
+        teems meet --copy                  # Also copy the link
+        teems meet --no-open | pbcopy      # Just the link, for someone else
+        teems meet --at 14:30 --with alice@example.com
+    HELP
+
+    # `teems meet`: a calendar event with a Teams meeting, starting now by default, and
+    # its join link. Calendars.ReadWrite is enough for that, where creating a bare online
+    # meeting would need OnlineMeetings.ReadWrite.
+    class Meet < Base
+      include Support::Timezone
+      include Support::TimeParsing
+      include Confirmation
+
+      DEFAULT_MINUTES = 30
+      MAX_MINUTES = 24 * 60
+      VALUE_OPTIONS = { '--at' => :at, '--title' => :title, '--with' => :with }.freeze
+      # --open is the default; it is still accepted, so scripts that pass it keep working
+      FLAGS = { '--copy' => :copy, '--open' => :open, '--no-open' => :no_open, '--yes' => :yes, '-y' => :yes }.freeze
+
+      def initialize(args, runner:)
+        @options = {}
+        super
+      end
+
+      def execute
+        validation = validate_options
+        return validation if validation
+
+        auth = require_auth
+        return auth if auth
+
+        with_token_refresh { create_meeting }
+      rescue ApiError => e
+        api_error_result('Could not create the meeting', e)
+      rescue Teems::Error => e
+        error(e.message)
+      end
+
+      protected
+
+      def handle_option(arg, pending)
+        return @options[FLAGS[arg]] = true if FLAGS.key?(arg)
+        return super unless VALUE_OPTIONS.key?(arg)
+
+        @options[VALUE_OPTIONS[arg]] = pending.shift
+      end
+
+      def help_text = MEET_HELP
+
+      private
+
+      def create_meeting
+        start = start_time
+        finish = start + (minutes * 60)
+        return error('Cancelled; no meeting created') unless invite_confirmed?
+
+        event = runner.calendar_api.create_event(event_body(start, finish))
+        link = event.online_meeting_url or raise Error, 'Graph created the event but gave no Teams link'
+        report(event, link, start..finish)
+      end
+
+      def minutes
+        given = positional_args.first
+        return DEFAULT_MINUTES unless given
+
+        count = Integer(given, 10, exception: false)
+        raise Error, "Minutes must be a whole number from 1 to #{MAX_MINUTES}" unless count&.between?(1, MAX_MINUTES)
+
+        count
+      end
+
+      def start_time
+        given = @options[:at] || 'now'
+        parse_time_input(given) or raise Error, "Unknown time: #{given} (use now, HH:MM, \"tomorrow HH:MM\", ...)"
+      end
+
+      def invitees = @options[:with].to_s.split(',').map(&:strip).reject(&:empty?)
+
+      # Inviting people sends them mail, so it needs a yes (at the prompt, or --yes)
+      def invite_confirmed?
+        people = invitees
+        return true if people.empty? || @options[:yes]
+
+        confirm?("Invite #{people.join(', ')} (Exchange emails each an invitation)",
+                 refusal: 'Inviting people sends them email; pass --yes to go ahead')
+      end
+
+      def event_body(start, finish)
+        zone = detect_timezone
+        { subject: @options[:title] || 'Meet now', isOnlineMeeting: true, onlineMeetingProvider: 'teamsForBusiness',
+          start: { dateTime: graph_time(start), timeZone: zone }, end: { dateTime: graph_time(finish), timeZone: zone },
+          attendees: invitees.map { |address| { emailAddress: { address: address }, type: 'required' } },
+          transactionId: SecureRandom.uuid }
+      end
+
+      # On stderr, beside the link on stdout; -q leaves just the link
+      def note(message) = @options[:quiet] || output.note(message)
+
+      def graph_time(time) = time.strftime('%Y-%m-%dT%H:%M:%S')
+
+      def report(event, link, times)
+        return json_report(event, link, times) if @options[:json]
+
+        output.puts(link)
+        note("#{event.subject}, #{times.begin.strftime('%-I:%M')}-#{times.end.strftime('%-I:%M %p')}")
+        hand_off(link)
+        0
+      end
+
+      def json_report(event, link, times)
+        hand_off(link)
+        output_json(id: event.id, title: event.subject, start: times.begin.iso8601, end: times.end.iso8601,
+                    join_url: link)
+        0
+      end
+
+      def hand_off(link)
+        runner.clipboard.copy(link) && note('Copied the link') if @options[:copy]
+        runner.browser.open(link) && note('Opened it to join') unless @options[:no_open]
+      end
+    end
+  end
+end

data/lib/teems/commands/meeting.rb

@@ -613,10 +613,11 @@ module Teems
       private
 
       def output_meeting_json(target, classified)
+        call_events, recordings, transcripts = classified.values_at(:call_events, :recordings, :transcripts)
         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) })
+                    call_events: call_events.map { |event| json_call_event(event) },
+                    recordings: recordings.map { |rec| rec.slice(:time, :url, :call_id) },
+                    transcripts: transcripts.map { |item| item.slice(:time) })
         0
       end
 

data/lib/teems/commands/messages.rb

@@ -14,7 +14,7 @@ module Teems
       OPTIONS:
         -t, --team ID    Team ID (required for channel messages)
         -n, --limit N    Number of messages (default: 20)
-        --download       Download file attachments
+        --download       Download file attachments and inline images
         -o, --output-dir Directory for downloads (default: ~/.local/share/teems/downloads)
         -v, --verbose    Show debug output
         -q, --quiet      Suppress output
@@ -23,10 +23,13 @@ module Teems
       EXAMPLES:
         teems messages 19:abc123@thread.v2         # Read chat messages
         teems messages 19:abc123@thread.v2 -n 50   # Show 50 messages
+        teems messages 19:abc123@thread.v2 --download  # Save attachments + pasted images
         teems messages "https://teams.microsoft.com/l/message/19:abc@thread.v2/123?context=..."
                                                    # Show the linked message and its thread replies
     HELP
 
+    IMAGE_ICON = "\u{1F5BC}\u{FE0F}"
+
     # Display formatting for messages command
     module MessagesDisplay
       REACTION_EMOJI = {
@@ -45,6 +48,7 @@ module Teems
         puts format_message_header(message)
         puts "  #{formatted_content(message)}"
         display_attachments(message)
+        display_images(message)
         display_reactions(message)
         puts
       end
@@ -66,6 +70,11 @@ module Teems
         puts "  #{output.gray("\u{1F4CE} #{names.join(', ')}")}"
       end
 
+      def display_images(message)
+        summary = Formatters::FormatUtils.image_summary(message.images)
+        puts "  #{output.gray("#{IMAGE_ICON} #{summary}")}" unless summary.empty?
+      end
+
       def display_reactions(message)
         reactions = message.reactions
         return unless reactions.any?
@@ -85,7 +94,7 @@ module Teems
           created_at: message.created_at&.iso8601,
           importance: message.importance, reactions: message.reactions,
           attachments: message.attachments, edited: message.edited,
-          mentions: message.mentions }
+          mentions: message.mentions, images: message.images.map(&:as_json) }
       end
     end
 
@@ -95,14 +104,15 @@ module Teems
 
       def download_attachments(messages)
         attachments = find_downloadable(messages)
-        return puts('No downloadable attachments found') if attachments.empty?
+        images = inline_images(messages)
+        return puts('No downloadable attachments found') if attachments.empty? && images.empty?
 
-        execute_downloads(attachments)
+        execute_downloads(attachments, images)
       end
 
-      def execute_downloads(attachments)
+      def execute_downloads(attachments, images)
         dir = prepare_output_dir
-        count = attachments.sum { |att| download_one(att, dir) }
+        count = attachments.sum { |att| download_one(att, dir) } + images.sum { |entry| download_image(entry, dir) }
         puts "Downloaded #{count} file#{'s' if count != 1} to #{dir}" if count.positive?
       end
 
@@ -168,6 +178,29 @@ module Teems
       end
     end
 
+    # Download logic for images pasted inline into message bodies (Teams AMS objects)
+    module InlineImageDownload
+      private
+
+      # [message, image, 1-based position within the message] for every inline image
+      def inline_images(messages) = messages.flat_map { |msg| numbered_images(msg) }
+
+      def numbered_images(msg) = msg.images.map.with_index(1) { |image, number| [msg, image, number] }
+
+      def download_image(entry, dir)
+        msg, image, number = entry
+        print "#{IMAGE_ICON} Downloading #{image.label}..."
+        result = with_token_refresh { image_downloader.fetch(image) }
+        path = unique_path(dir, "image-#{msg.short_hash}-#{number}.#{result.extension}")
+        puts " done (#{Formatters::FormatUtils.format_bytes(File.binwrite(path, result.body))}) #{path}"
+        1
+      rescue StandardError => e
+        handle_download_error(e)
+      end
+
+      def image_downloader = @image_downloader ||= runner.inline_image_downloader
+    end
+
     # Fetch and render a single message and its thread replies
     module ThreadFetch
       private
@@ -175,7 +208,7 @@ module Teems
       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
+        replies_data = fetch_replies do
           api.replies(thread_id: thread_id, message_id: message_id, limit: @options[:limit])
         end
         display_thread(parent_data, extract_messages_data(replies_data))
@@ -183,10 +216,19 @@ module Teems
         error("Failed to fetch message: #{e.message}")
       end
 
+      # Group and 1:1 chats have no reply threads; their replies endpoint returns 404
+      def fetch_replies(&)
+        with_token_refresh(&)
+      rescue ApiError => e
+        raise unless e.not_found?
+
+        {}
+      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]
+        return output_json(thread_to_hash(parent, replies)) || 0 if @options[:json]
 
         render_thread(parent, replies)
         download_attachments([parent, *replies]) if @options[:download]
@@ -212,6 +254,7 @@ module Teems
     class Messages < Base
       include MessagesDisplay
       include AttachmentDownload
+      include InlineImageDownload
       include ThreadFetch
 
       def initialize(args, runner:)

data/lib/teems/commands/sync.rb

@@ -11,8 +11,11 @@ module Teems
       OPTIONS:
         --since DAYS     Number of days of history to sync (default: 180)
         --chat CHAT_ID   Sync only this chat
+        --images         Also download inline (pasted) images into each chat's images/ dir
         --auth           Authenticate via Safari before syncing
-        --dry-run        Show what would be synced without writing files
+        --dry-run        Show what would be synced and every folder change, without writing anything
+        --migrate-dirs   Also rename existing chat folders to "<name> (<chat ID>)" and write
+                         a map of old to new paths (sync/dir-maps/)
         -v, --verbose    Show debug output
         -q, --quiet      Suppress output
 
@@ -20,11 +23,15 @@ module Teems
         teems sync                         # Sync 6 months of all chats
         teems sync --since 30              # Sync last 30 days
         teems sync --chat 19:abc@thread.v2 # Sync a single chat
+        teems sync --images                # Include pasted screenshots
         teems sync --dry-run               # Preview what would be synced
+        teems sync --dry-run --migrate-dirs # Preview renaming every folder
 
       OUTPUT:
         Files are stored in ~/.local/share/teems/sync/chats/
         Each chat gets: messages.md, messages.json, chat_metadata.json
+        (plus images/ with --images; messages.md links saved images, otherwise [image: ...])
+        New chats get a "<name> (<chat ID>)" folder; existing folders keep their names.
     HELP
 
     # Handles syncing individual chats: fetch, merge, retry on 404
@@ -59,10 +66,7 @@ module Teems
       end
 
       def sync_single_chat(chat)
-        @sync_store.ensure_dir_name(
-          @state, chat_info: { chat_id: chat.id, display_name: chat.display_name,
-                               chat_type: chat.chat_type }
-        )
+        report_dir_move(@sync_store.ensure_chat_dir(@state, chat_info: dir_info(chat)))
         new_messages = fetch_new_messages(chat)
         debug("  Fetched #{new_messages.length} new message(s)")
         process_fetched_messages(chat, new_messages)
@@ -70,20 +74,24 @@ module Teems
 
       def process_fetched_messages(chat, new_messages)
         chat_id = chat.id
-        return skip_unchanged(chat_id) if new_messages.empty? && @sync_store.last_synced_time(@state, chat_id)
+        # --images rewrites unchanged chats too, so images in already-synced messages are backfilled
+        unchanged = new_messages.empty? && !@options[:images]
+        return skip_unchanged(chat_id) if unchanged && @sync_store.last_synced_time(@state, chat_id)
 
         merge_and_update(chat, new_messages)
       end
 
       def fetch_new_messages(chat)
         chat_id = chat.id
-        start_time = @sync_store.last_synced_time(@state, chat_id) || since_time
+        start_time = @sync_store.last_synced_time(@state, chat_id) || resync_start(@state, chat_id)
         with_token_refresh { sync_engine.fetch_all_messages(chat_id, start_time) }
       end
 
       def merge_and_update(chat, new_messages)
         existing_raw = @sync_store.read_messages_json(chat.id, state: @state)
-        all_messages = sync_engine.merge_and_write(chat, existing_raw, new_messages)
+        all_messages = sync_engine.merge_and_write(chat, existing_raw, new_messages) do |chat_dir, messages|
+          save_chat_images(chat_dir, messages)
+        end
         update_chat_state(chat, all_messages)
       end
 
@@ -138,6 +146,23 @@ module Teems
       end
     end
 
+    # Opt-in (--images) download of inline images into each synced chat directory
+    module SyncImageHandler
+      private
+
+      def save_chat_images(chat_dir, messages)
+        return unless @options[:images]
+
+        saved = sync_images.save(chat_dir, messages)
+        debug("  Saved #{saved} image(s)")
+        @stats[:images] += saved
+      end
+
+      def sync_images
+        @sync_images ||= Services::SyncImages.new(downloader: runner.inline_image_downloader, output: output)
+      end
+    end
+
     # Chat list fetching, dry-run display, and summary reporting
     module SyncDisplay
       private
@@ -174,12 +199,13 @@ module Teems
       def show_dry_run(chats)
         syncable = chats.reject { |chat| skip_reason(chat['id']) }
         display_dry_run_list(chats.length - syncable.length, syncable)
+        show_dir_plan(syncable)
+        0
       end
 
       def display_dry_run_list(skipped_count, syncable)
         display_dry_run_header(skipped_count, syncable.length)
         syncable.each { |chat| format_dry_run_chat(chat) }
-        0
       end
 
       def display_dry_run_header(skipped, syncable_count)
@@ -204,6 +230,7 @@ module Teems
         success('Sync complete!')
         show_summary_stats
         info("  Output: #{@sync_store.sync_dir}")
+        show_folder_summary
       end
 
       def show_summary_stats
@@ -211,6 +238,7 @@ module Teems
         skipped = @stats[:skipped]
         info("  Chats skipped (no new messages): #{skipped}") if skipped.positive?
         info("  Total messages: #{@stats[:messages_total]}")
+        info("  Images downloaded: #{@stats[:images]}") if @options[:images]
         display_error_count
       end
 
@@ -287,8 +315,10 @@ module Teems
     # Sync chat history locally as Markdown + JSON files
     class Sync < Base
       include SyncChatHandler
+      include SyncImageHandler
       include SyncDisplay
       include SyncAuth
+      include SyncFolders
 
       DEFAULT_SINCE_DAYS = 180
       SKIP_PREFIXES = %w[48:].freeze
@@ -318,6 +348,8 @@ module Teems
         '--since' => ->(opts, args) { opts[:since_days] = args.shift.to_i },
         '--chat' => ->(opts, args) { opts[:chat_id] = args.shift },
         '--dry-run' => ->(opts, _args) { opts[:dry_run] = true },
+        '--images' => ->(opts, _args) { opts[:images] = true },
+        '--migrate-dirs' => ->(opts, _args) { opts[:migrate_dirs] = true },
         '--auth' => ->(opts, _args) { opts[:auth] = true }
       }.freeze
 
@@ -342,6 +374,7 @@ module Teems
       end
 
       def sync_all_chats(chats)
+        detach_shared_dirs
         chats.each_with_index { |chat_data, index| sync_or_skip_chat(chat_data, "[#{index + 1}/#{chats.length}]") }
         save_state_safely
         show_summary
@@ -353,7 +386,7 @@ module Teems
       def init_sync_state
         @sync_store = Services::SyncStore.new
         @state = @sync_store.load_state
-        @stats = { synced: 0, skipped: 0, errors: 0, messages_total: 0 }
+        @stats = { synced: 0, skipped: 0, errors: 0, messages_total: 0, images: 0 }
         setup_api_logging
       end
 
@@ -377,7 +410,8 @@ module Teems
         error("Warning: Failed to save sync state: #{e.message}")
       end
 
-      def since_time = Time.now - ((@options[:since_days] || DEFAULT_SINCE_DAYS) * 86_400)
+      def since_days = @options[:since_days] || DEFAULT_SINCE_DAYS
+      def since_time = Time.now - (since_days * 86_400)
 
       def setup_api_logging
         out = output

data/lib/teems/commands/sync_folders.rb

@@ -0,0 +1,118 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    # Chat folder changes made by sync: detaching shared folders, moving folders, listing old
+    # shared folders still on disk, and previewing all of it for --dry-run
+    module SyncFolders
+      # How each kind of folder change is described; :split is described by split_note, and :new
+      # and :kept aren't reported
+      MOVE_NOTES = {
+        move: '',
+        retarget: ' (the old folder is already gone)',
+        repoint: ' (the new folder already exists: switching to it, the old folder is left in place)',
+        release: " (the old folder also holds another chat's messages and is left in place)"
+      }.freeze
+
+      private
+
+      def dir_info(chat) = { **chat.sync_identity, migrate: @options[:migrate_dirs] }
+
+      # sync --chat X only detaches X, so the other chats keep their cursors until they sync
+      def detach_shared_dirs
+        detached = @sync_store.detach_shared_dirs(@state, only: @options[:chat_id])
+        @detached_dirs = detached.keys
+        warn_shared_dirs(detached)
+      end
+
+      def warn_shared_dirs(shared)
+        return if shared.empty?
+
+        warn([shared_dirs_intro(shared), *dir_lines(shared), shared_dirs_plan].join("\n"))
+      end
+
+      def shared_dirs_intro(shared)
+        "#{shared.length} folder(s) in #{File.join(@sync_store.sync_dir, 'chats')} mix messages from " \
+          'several chats (an older teems gave those chats the same folder name):'
+      end
+
+      def shared_dirs_plan
+        'These folders are left as they are. Each affected chat now syncs to its own folder, re-fetching ' \
+          'history back to the oldest message in the old folder. Older history may still exist only in the ' \
+          "old folders, so keep them until you've checked the new ones."
+      end
+
+      def dir_lines(dirs) = dirs.map { |path, ids| "  #{path} (#{ids.length} chat#{'s' unless ids.one?})" }
+
+      def report_dir_move(move)
+        line = dir_move_line(move, @state)
+        return unless line
+
+        (@dir_moves ||= []) << move
+        move.kind == :repoint ? warn("  Folder: #{line}") : info("  Folder: #{line}")
+      end
+
+      def dir_move_line(move, state)
+        note = move_note(move.to_h, state)
+        "#{move}#{note}" if note
+      end
+
+      def move_note(move_attrs, state)
+        kind, chat_id = move_attrs.values_at(:kind, :chat_id)
+        return MOVE_NOTES[kind] unless kind == :split
+
+        start = resync_start(state, chat_id).strftime('%Y-%m-%d')
+        " (split from a shared folder, which is left in place; re-fetching from #{start})"
+      end
+
+      # A detached chat re-syncs from the oldest message in its old folder, or --since if earlier
+      def resync_start(state, chat_id) = [@sync_store.resync_from(state, chat_id), since_time].compact.min
+
+      def show_folder_summary
+        write_dir_map
+        show_legacy_dirs(@detached_dirs)
+      end
+
+      def write_dir_map
+        moves = @dir_moves
+        return unless @options[:migrate_dirs] && moves
+
+        info("  Folder map: #{@sync_store.write_dir_map(moves)}")
+      end
+
+      def show_legacy_dirs(exclude)
+        legacy = @sync_store.legacy_shared_dirs(@state).except(*exclude)
+        return if legacy.empty?
+
+        info("Old shared folders still on disk (they may hold history the new folders don't):\n" \
+             "#{dir_lines(legacy).join("\n")}")
+      end
+
+      # Plans on a copy of the state, so nothing changes on disk or in sync_state.json
+      def show_dir_plan(syncable)
+        plan = JSON.parse(JSON.generate(@state))
+        detached = @sync_store.detach_shared_dirs(plan, only: @options[:chat_id])
+        lines = syncable.filter_map do |chat_data|
+          dir_move_line(@sync_store.plan_chat_dir(plan, dir_info(Models::Chat.from_api(chat_data))), plan)
+        end
+        show_planned_moves(lines)
+        show_planned_detaches(detached)
+        show_legacy_dirs([])
+      end
+
+      def show_planned_moves(lines)
+        puts
+        return info('Folder changes: none') if lines.empty?
+
+        info("Folder changes (#{lines.length}):\n#{lines.map { |line| "  #{line}" }.join("\n")}")
+      end
+
+      def show_planned_detaches(detached)
+        return if detached.empty?
+
+        info("Shared folders that would be detached (#{detached.length}):\n" \
+             "#{dir_lines(detached).join("\n")}\n#{shared_dirs_plan}")
+      end
+    end
+  end
+end