teems 0.1.0

data/lib/teems/commands/status.rb

@@ -0,0 +1,224 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    # Render helpers for presence status display
+    module StatusDisplay
+      AVAILABILITY_LABELS = {
+        'Available' => 'Available', 'Busy' => 'Busy',
+        'DoNotDisturb' => 'Do Not Disturb', 'Away' => 'Away',
+        'BeRightBack' => 'Be Right Back', 'Offline' => 'Offline',
+        'PresenceUnknown' => 'Unknown'
+      }.freeze
+
+      private
+
+      def render_presence(data)
+        @options[:json] ? output_json(data) : render_presence_text(data)
+      end
+
+      def render_presence_text(data)
+        render_availability_line(data)
+        render_status_message_line(data)
+      end
+
+      def render_availability_line(data)
+        raw, activity = data.values_at('availability', 'activity')
+        line = "Availability: #{AVAILABILITY_LABELS[raw] || raw}"
+        line += " (#{activity})" if activity && activity != raw
+        puts line
+      end
+
+      def render_status_message_line(data)
+        msg = data.dig('statusMessage', 'message', 'content')
+        return unless msg && !msg.empty?
+
+        expiry_text = format_expiry(data.dig('statusMessage', 'expiryDateTime'))
+        line = "Status:       #{msg}"
+        line += " (#{expiry_text})" if expiry_text
+        puts line
+      end
+
+      def format_expiry(expiry_data)
+        return nil unless expiry_data
+
+        expiry_str = expiry_data['dateTime']
+        return nil unless expiry_str
+
+        remaining = Time.parse(expiry_str) - Time.now.utc
+        return 'expired' unless remaining.positive?
+
+        format_remaining(remaining)
+      end
+
+      def format_remaining(remaining)
+        total_minutes = (remaining / 60).ceil
+        hrs = total_minutes / 60
+        mins = total_minutes % 60
+        parts = []
+        parts << "#{hrs}h" if hrs.positive?
+        parts << "#{mins}m" if mins.positive?
+        "expires in #{parts.join(' ')}"
+      end
+    end
+
+    # Dispatch and mutation logic for setting/clearing presence
+    module StatusActions
+      private
+
+      def dispatch_action
+        case positional_args
+        in ['clear', *] then clear_status
+        in [text, *rest] then set_status(text, rest)
+        in [] then @options[:presence] ? set_presence_only : show_status
+        end
+      end
+
+      def show_status
+        data = with_token_refresh { runner.users_api.my_presence }
+        render_presence(data)
+        0
+      end
+
+      def set_status(text, rest)
+        duration = parse_duration(rest.first)
+        expiry = duration&.to_expiration
+        with_token_refresh { runner.users_api.set_status_message(message: text, expiry: expiry) }
+        send_presence(presence_duration(duration)) if @options[:presence]
+        msg = "Status set: #{text}"
+        msg += " (#{duration})" if duration
+        success(msg)
+        0
+      end
+
+      def clear_status
+        with_token_refresh { runner.users_api.clear_status_message }
+        send_presence(self.class::DEFAULT_PRESENCE_DURATION) if @options[:presence]
+        success('Status cleared')
+        0
+      end
+
+      def set_presence_only
+        send_presence(self.class::DEFAULT_PRESENCE_DURATION)
+        success("Presence set: #{@options[:presence]}")
+        0
+      end
+
+      def presence_duration(duration)
+        duration ? duration.to_iso8601_duration : self.class::DEFAULT_PRESENCE_DURATION
+      end
+
+      def send_presence(iso_duration)
+        availability, activity = self.class::PRESENCE_MAP[@options[:presence]]
+        with_token_refresh do
+          runner.users_api.set_presence(availability: availability, activity: activity, duration: iso_duration)
+        end
+      end
+
+      def parse_duration(value)
+        return nil unless value
+
+        Models::Duration.parse(value)
+      rescue ArgumentError
+        debug("Invalid duration #{value.inspect}, ignoring")
+        nil
+      end
+    end
+
+    # View and manage your presence status
+    class Status < Base
+      include StatusDisplay
+      include StatusActions
+
+      PRESENCE_MAP = {
+        'available' => %w[Available Available],
+        'busy' => %w[Busy Busy],
+        'dnd' => %w[DoNotDisturb DoNotDisturb],
+        'away' => %w[Away Away],
+        'brb' => %w[BeRightBack BeRightBack],
+        'offline' => %w[Offline OffWork]
+      }.freeze
+
+      DEFAULT_PRESENCE_DURATION = 'PT4H'
+
+      STATUS_OPTIONS = {
+        '-p' => ->(opts, args) { opts[:presence] = args.shift },
+        '--presence' => ->(opts, args) { opts[:presence] = args.shift }
+      }.freeze
+
+      def initialize(args, runner:)
+        @options = {}
+        super
+      end
+
+      def execute
+        result = validate_options
+        return result if result
+
+        auth_result = require_auth
+        return auth_result if auth_result
+
+        dispatch
+      end
+
+      protected
+
+      def handle_option(arg, pending)
+        handler = STATUS_OPTIONS[arg]
+        return super unless handler
+
+        handler.call(@options, pending)
+      end
+
+      def help_text
+        <<~HELP
+          #{output.bold('teems status')} - View and manage your presence status
+
+          #{output.bold('USAGE:')}
+            teems status                             Show current status
+            teems status "<message>"                 Set status message
+            teems status "<message>" <duration>      Set with expiry (e.g. 2h, 30m, 1h30m)
+            teems status clear                       Clear status message
+            teems status --presence <value>          Set presence only
+
+          #{output.bold('PRESENCE VALUES:')}
+            available, busy, dnd, away, brb, offline
+
+          #{output.bold('OPTIONS:')}
+            -p, --presence VALUE   Set presence/availability
+            --json                 Output as JSON
+            -v, --verbose          Show debug output
+            -q, --quiet            Suppress output
+            -h, --help             Show this help
+
+          #{output.bold('EXAMPLES:')}
+            teems status                             Show current status
+            teems status "In a meeting"              Set status message
+            teems status "Focus time" 2h             Set with 2h expiry
+            teems status clear                       Clear status message
+            teems status --presence away             Set presence to away
+            teems status "Focus" 2h --presence dnd   Set message + presence
+        HELP
+      end
+
+      private
+
+      def dispatch
+        return invalid_presence if @options[:presence] && !valid_presence?
+
+        dispatch_action
+      rescue ApiError => e
+        error("Status error: #{e.message}")
+        1
+      end
+
+      def valid_presence? = PRESENCE_MAP.key?(@options[:presence])
+
+      def invalid_presence
+        error("Invalid presence: #{@options[:presence]}")
+        error("Valid values: #{PRESENCE_MAP.keys.join(', ')}")
+        1
+      end
+    end
+  end
+end

data/lib/teems/commands/sync.rb

@@ -0,0 +1,390 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    SYNC_HELP = <<~HELP
+      teems sync - Sync chat history locally
+
+      USAGE:
+        teems sync [options]
+
+      OPTIONS:
+        --since DAYS     Number of days of history to sync (default: 180)
+        --chat CHAT_ID   Sync only this chat
+        --auth           Authenticate via Safari before syncing
+        --dry-run        Show what would be synced without writing files
+        -v, --verbose    Show debug output
+        -q, --quiet      Suppress output
+
+      EXAMPLES:
+        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 --dry-run               # Preview what would be synced
+
+      OUTPUT:
+        Files are stored in ~/.local/share/teems/sync/chats/
+        Each chat gets: messages.md, messages.json, chat_metadata.json
+    HELP
+
+    # Handles syncing individual chats: fetch, merge, retry on 404
+    module SyncChatHandler
+      RETRY_DELAY_SECONDS = 2
+
+      private
+
+      def sync_or_skip_chat(chat_data, label)
+        chat = Models::Chat.from_api(chat_data)
+        skip_reason(chat.id) ? log_skip(chat, label) : log_and_sync(chat, label)
+      rescue StandardError => e
+        handle_sync_error(chat, e)
+      end
+
+      def log_and_sync(chat, label)
+        info("#{label} Syncing: #{chat.display_name}")
+        with_404_retry(chat) { sync_single_chat(chat) }
+      end
+
+      def log_skip(chat, label)
+        chat_id = chat.id
+        debug("#{label} Skipping #{skip_reason(chat_id)}: #{chat.display_name} (#{chat_id})")
+        @stats[:skipped] += 1
+      end
+
+      def handle_sync_error(chat, err)
+        output.flush
+        warn("  Unexpected error syncing '#{chat.display_name}': #{err.message}")
+        debug("  #{err.backtrace&.first}")
+        @stats[:errors] += 1
+      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 }
+        )
+        new_messages = fetch_new_messages(chat)
+        debug("  Fetched #{new_messages.length} new message(s)")
+        process_fetched_messages(chat, new_messages)
+      end
+
+      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)
+
+        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
+        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)
+        update_chat_state(chat, all_messages)
+      end
+
+      def skip_unchanged(chat_id)
+        debug("  No new messages, skipping write (#{chat_id})")
+        @stats[:skipped] += 1
+      end
+
+      def update_chat_state(chat, all_messages)
+        count = all_messages.length
+        debug("  Total: #{count} message(s) after merge")
+        @sync_store.update_chat_state(
+          @state, chat.id,
+          attrs: { last_synced_at: Time.now, message_count: count,
+                   display_name: chat.display_name, chat_type: chat.chat_type }
+        )
+        @stats[:synced] += 1
+        @stats[:messages_total] += count
+      end
+
+      def with_404_retry(chat, &)
+        yield
+      rescue ApiError => e
+        output.flush
+        return handle_non_404_error(chat, e) unless e.not_found?
+
+        retry_after_not_found(chat, &)
+      end
+
+      def handle_non_404_error(chat, error)
+        warn("  Failed to sync '#{chat.display_name}': #{error.message}")
+        @stats[:errors] += 1
+      end
+
+      def retry_after_not_found(chat)
+        debug("  Got 404, retrying in #{RETRY_DELAY_SECONDS}s...")
+        sleep(RETRY_DELAY_SECONDS)
+        yield
+      rescue ApiError => e
+        handle_persistent_not_found(chat, e)
+      end
+
+      def handle_persistent_not_found(chat, error)
+        display_name = chat.display_name
+        if error.not_found?
+          @sync_store.mark_unavailable(@state, chat.id, display_name: display_name, chat_type: chat.chat_type)
+          warn("  Chat unavailable (404): '#{display_name}' — will skip on future syncs")
+        else
+          warn("  Failed to sync '#{display_name}': #{error.message}")
+        end
+        @stats[:errors] += 1
+      end
+    end
+
+    # Chat list fetching, dry-run display, and summary reporting
+    module SyncDisplay
+      private
+
+      def fetch_chat_list
+        return build_single_chat if @options[:chat_id]
+
+        fetch_all_chats
+      rescue ApiError => e
+        error("Failed to fetch chats: #{e.message}")
+        nil
+      end
+
+      def build_single_chat
+        chat_id = @options[:chat_id]
+        info("Fetching chat info for #{chat_id}...")
+        [{ 'id' => chat_id, 'threadProperties' => {} }]
+      end
+
+      def fetch_all_chats
+        info('Fetching chat list...')
+        chats = fetch_raw_chats
+        chats.tap { |list| list.empty? ? info('No chats found') : debug("Found #{list.length} chats") }
+      end
+
+      def fetch_raw_chats
+        parse_chat_response(with_token_refresh { runner.chats_api.list(limit: 200) })
+      end
+
+      def parse_chat_response(response)
+        response['conversations'] || response['value'] || []
+      end
+
+      def show_dry_run(chats)
+        syncable = chats.reject { |chat| skip_reason(chat['id']) }
+        display_dry_run_list(chats.length - syncable.length, syncable)
+      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)
+        info("Dry run — would sync #{syncable_count} chat(s) since #{since_time.strftime('%Y-%m-%d')}")
+        info("  (#{skipped} system streams skipped)") if skipped.positive?
+        puts
+      end
+
+      def format_dry_run_chat(chat_data)
+        chat = Models::Chat.from_api(chat_data)
+        chat_id = chat.id
+        puts "  #{chat.display_name}\n    ID: #{chat_id}\n    Status: #{dry_run_sync_status(chat_id)}\n"
+      end
+
+      def dry_run_sync_status(chat_id)
+        last_sync = @sync_store.last_synced_time(@state, chat_id)
+        last_sync ? "last synced #{last_sync.strftime('%Y-%m-%d %H:%M')}" : 'never synced'
+      end
+
+      def show_summary
+        puts
+        success('Sync complete!')
+        show_summary_stats
+        info("  Output: #{@sync_store.sync_dir}")
+      end
+
+      def show_summary_stats
+        info("  Chats synced: #{@stats[:synced]}")
+        skipped = @stats[:skipped]
+        info("  Chats skipped (no new messages): #{skipped}") if skipped.positive?
+        info("  Total messages: #{@stats[:messages_total]}")
+        display_error_count
+      end
+
+      def display_error_count
+        error_count = @stats[:errors]
+        return unless error_count.positive?
+
+        output.flush
+        warn("  Errors: #{error_count}")
+      end
+    end
+
+    # Authentication handling for sync --auth flag
+    module SyncAuth
+      private
+
+      def login_if_requested
+        return unless @options[:auth] && !tokens_already_valid?
+
+        tokens = runner.token_extractor.extract
+        return save_login_tokens(tokens) if tokens&.dig(:auth_token) && tokens[:skype_token]
+
+        tokens&.dig(:auth_token) ? report_partial_extraction : report_full_extraction_failure
+      end
+
+      def report_partial_extraction
+        error('Failed to authenticate via Safari')
+        error('  auth_token extracted but skype_token exchange failed')
+        1
+      end
+
+      def report_full_extraction_failure
+        error('Failed to authenticate via Safari')
+        1
+      end
+
+      def tokens_already_valid?
+        return false unless runner.configured?
+
+        unless token_store.account
+          debug('Stored tokens incomplete, re-authenticating...')
+          return false
+        end
+
+        check_tokens_with_api
+      end
+
+      def check_tokens_with_api
+        debug('Checking if existing tokens are still valid...')
+        runner.chats_api.list(limit: 1)
+        log_valid_tokens
+      rescue ApiError
+        debug('Existing tokens are expired or invalid, re-authenticating...')
+        nil
+      end
+
+      def log_valid_tokens
+        debug('Existing tokens are valid, skipping browser auth')
+        success('Using existing authentication (tokens still valid)')
+        :valid
+      end
+
+      def save_login_tokens(tokens)
+        saved = token_store.save(name: 'default', **tokens.slice(:auth_token, :skype_token,
+                                                                 :skype_spaces_token, :chatsvc_token,
+                                                                 :refresh_token, :client_id, :tenant_id))
+        return error('Authentication tokens extracted but failed to save') || 1 unless saved
+
+        success('Authentication successful!')
+        nil
+      end
+    end
+
+    # Sync chat history locally as Markdown + JSON files
+    class Sync < Base
+      include SyncChatHandler
+      include SyncDisplay
+      include SyncAuth
+
+      DEFAULT_SINCE_DAYS = 180
+      SKIP_PREFIXES = %w[48:].freeze
+
+      def initialize(args, runner:)
+        @options = {}
+        @sync_store = nil
+        @state = nil
+        @stats = nil
+        super
+      end
+
+      def execute
+        result = validate_and_authenticate
+        return result if result
+
+        run_sync
+      end
+
+      def validate_and_authenticate
+        validate_options || login_if_requested || require_auth
+      end
+
+      protected
+
+      SYNC_OPTIONS = {
+        '--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 },
+        '--auth' => ->(opts, _args) { opts[:auth] = true }
+      }.freeze
+
+      def handle_option(arg, pending)
+        handler = SYNC_OPTIONS[arg]
+        return super unless handler
+
+        handler.call(@options, pending)
+      end
+
+      def help_text = SYNC_HELP
+
+      private
+
+      def run_sync
+        init_sync_state
+        chats = fetch_chat_list
+        return 1 unless chats
+        return show_dry_run(chats) if @options[:dry_run]
+
+        sync_all_chats(chats)
+      end
+
+      def sync_all_chats(chats)
+        chats.each_with_index { |chat_data, index| sync_or_skip_chat(chat_data, "[#{index + 1}/#{chats.length}]") }
+        save_state_safely
+        show_summary
+        sync_exit_code
+      end
+
+      def sync_exit_code = @stats[:errors].positive? ? 1 : 0
+
+      def init_sync_state
+        @sync_store = Services::SyncStore.new
+        @state = @sync_store.load_state
+        @stats = { synced: 0, skipped: 0, errors: 0, messages_total: 0 }
+        setup_api_logging
+      end
+
+      def skip_reason(chat_id)
+        return 'system stream' if SKIP_PREFIXES.any? { |prefix| chat_id.start_with?(prefix) }
+        return 'unavailable chat' if @sync_store.chat_unavailable?(@state, chat_id)
+
+        nil
+      end
+
+      def sync_engine
+        @sync_engine ||= Services::SyncEngine.new(
+          runner: runner, sync_store: @sync_store, state: @state, output: output
+        )
+      end
+
+      def save_state_safely
+        @sync_store.save_state(@state)
+      rescue StandardError => e
+        @stats[:errors] += 1
+        error("Warning: Failed to save sync state: #{e.message}")
+      end
+
+      def since_time = Time.now - ((@options[:since_days] || DEFAULT_SINCE_DAYS) * 86_400)
+
+      def setup_api_logging
+        out = output
+        runner.api_client.on_response = lambda { |path, code|
+          out.debug("  API ← #{code} #{path[0..80]}") if out.verbose?
+        }
+      end
+    end
+  end
+end