teems 0.1.0

data/lib/teems/cli.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+module Teems
+  # Verbose mode and logging helpers for CLI
+  module CLIVerbose
+    private
+
+    def verbose_mode? = @argv.include?('-v') || @argv.include?('--verbose')
+
+    def build_runner
+      out = verbose_mode? ? @output.with_verbose : @output
+      Runner.new(output: out).tap { |new_runner| setup_verbose_logging(new_runner, out) if out.verbose? }
+    end
+
+    def setup_verbose_logging(runner, out)
+      runner.api_client.on_request = lambda { |method, count|
+        out.debug("[API ##{count}] #{method}")
+      }
+    end
+
+    def execute_command(command_class, args, runner)
+      command = command_class.new(args, runner: runner)
+      result = command.execute
+      out = runner.output || @output
+      log_api_call_count(out, runner.api_client.call_count) if out.verbose?
+      result
+    end
+
+    def log_api_call_count(output, count)
+      output.debug("Total API calls: #{count}") if @output && count.positive?
+    end
+
+    def log_error(error) = Support::ErrorLogger.log(error)
+  end
+
+  # Command-line interface entry point that dispatches to commands
+  class CLI
+    include CLIVerbose
+
+    ERROR_LABELS = { AuthError => 'Auth error', ApiError => 'API error' }.freeze
+
+    COMMANDS = {
+      'activity' => Commands::Activity,
+      'auth' => Commands::Auth,
+      'cal' => Commands::Cal,
+      'channels' => Commands::Channels,
+      'chats' => Commands::Chats,
+      'messages' => Commands::Messages,
+      'sync' => Commands::Sync,
+      'who' => Commands::Who,
+      'org' => Commands::Org,
+      'ooo' => Commands::Ooo,
+      'status' => Commands::Status,
+      'help' => Commands::Help
+    }.freeze
+
+    def initialize(argv, output: Formatters::Output.new)
+      @argv = argv.dup
+      @output = output
+    end
+
+    def run
+      command_name, *args = @argv
+      route_command(command_name, args)
+    rescue Interrupt
+      handle_interrupt
+    rescue StandardError => e
+      handle_error(e)
+    end
+
+    def route_command(command_name, args)
+      return show_help if help_requested?
+      return show_version if version_requested?
+
+      dispatch_command(command_name, args)
+    end
+
+    private
+
+    def help_requested? = @argv.empty? || ['-h', '--help'].include?(@argv.first)
+    def version_requested? = ['--version', '-V', 'version'].include?(@argv.first)
+
+    def show_help = run_command('help', [])
+
+    def show_version
+      @output.puts "teems v#{VERSION}"
+      0
+    end
+
+    def dispatch_command(command_name, args)
+      COMMANDS[command_name] ? run_command(command_name, args) : show_unknown_command(command_name)
+    rescue ConfigError, AuthError, ApiError => e
+      handle_known_error(e)
+    end
+
+    def show_unknown_command(command_name)
+      @output.error("Unknown command: #{command_name}")
+      @output.puts
+      @output.puts "Run 'teems help' for available commands."
+      1
+    end
+
+    def handle_known_error(err)
+      label = ERROR_LABELS[err.class]
+      @output.error([label, err.message].compact.join(': '))
+      log_error(err)
+      1
+    end
+
+    def handle_interrupt
+      @output.puts
+      @output.puts 'Interrupted.'
+      130
+    end
+
+    def handle_error(error)
+      @output.error("Unexpected error: #{error.message}")
+      log_path = log_error(error)
+      @output.puts "Details logged to: #{log_path}" if log_path
+      1
+    end
+
+    def run_command(name, args)
+      command_class = COMMANDS[name]
+      return 1 unless command_class
+
+      runner = build_runner
+      execute_command(command_class, args, runner)
+    ensure
+      runner&.api_client&.close
+    end
+  end
+end

data/lib/teems/commands/activity.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    # Format activity feed notifications for display
+    module ActivityFormatting
+      ACTIVITY_DESCRIPTIONS = {
+        %w[msGraph privateMeetingCanceled] => 'canceled',
+        %w[msGraph privateMeetingCreated] => 'invited you',
+        %w[msGraph privateMeetingUpdated] => 'updated',
+        %w[msGraph privateMeetingForwarded] => 'forwarded you',
+        %w[msGraph delegateMeetingCreated] => 'invited you',
+        %w[msGraph delegateMeetingUpdated] => 'updated',
+        %w[mentionInChat person] => 'mentioned you',
+        %w[mentionInChat everyone] => 'mentioned Everyone',
+        %w[mention channel] => 'mentioned channel',
+        %w[reactionInChat] => 'reacted'
+      }.freeze
+
+      START_DATETIME_PATTERN = %r{<StartDateTime>(.+?)</StartDateTime>}
+      END_DATETIME_PATTERN = %r{<EndDateTime>(.+?)</EndDateTime>}
+      MAX_PREVIEW = 120
+
+      private
+
+      def format_activity(activity, composetime)
+        [format_activity_header(activity, composetime),
+         format_preview(activity),
+         format_meeting_time(activity),
+         format_activity_source(activity)].compact.join("\n")
+      end
+
+      def format_activity_header(activity, composetime)
+        who = activity['sourceUserImDisplayName'] || 'Unknown'
+        behalf = parse_behalf(activity)
+        name = behalf ? "#{who} on behalf of #{behalf}" : who
+        time_str = Formatters::FormatUtils.format_time(composetime)
+        "#{output.blue(time_str)} #{output.bold(name)} #{describe_action(activity)}"
+      end
+
+      def format_preview(activity)
+        text = activity['messagePreview'].to_s.strip.gsub(/[\r\n]+/, ' ')
+        text.empty? ? nil : "  #{Formatters::FormatUtils.truncate(text, MAX_PREVIEW)}"
+      end
+
+      def format_activity_source(activity)
+        topic = activity['sourceThreadTopic']
+        topic ? "  #{output.gray(topic)}" : nil
+      end
+
+      def describe_action(activity)
+        desc = resolve_activity_description(activity['activityType'], activity['activitySubtype'])
+        output.yellow(desc)
+      end
+
+      def resolve_activity_description(type, subtype)
+        ACTIVITY_DESCRIPTIONS[[type, subtype]] || ACTIVITY_DESCRIPTIONS[[type]] || subtype || type
+      end
+
+      def format_meeting_time(activity)
+        return nil unless activity['activityType'] == 'msGraph'
+
+        location = activity.dig('activityContext', 'location')
+        parsed = location && parse_meeting_range(location)
+        "  #{format_time_range(*parsed)}" if parsed
+      end
+
+      def parse_meeting_range(location)
+        start_match, end_match = extract_datetime_matches(location)
+        return nil unless start_match
+
+        Formatters::FormatUtils.build_time_range(start_match[1], end_match)
+      rescue ArgumentError
+        nil
+      end
+
+      def extract_datetime_matches(text)
+        [text.match(START_DATETIME_PATTERN),
+         text.match(END_DATETIME_PATTERN)]
+      end
+
+      def format_time_range(start_time, end_time)
+        start_str = start_time.strftime('%b %-d, %-I:%M %p')
+        return start_str unless end_time
+
+        "#{start_str} - #{Formatters::FormatUtils.format_end_time(start_time, end_time)}"
+      end
+
+      def parse_behalf(activity)
+        params = activity.dig('activityContext', 'templateParameters')
+        return nil unless params.is_a?(String)
+
+        JSON.parse(params)['behalfOf']
+      rescue JSON::ParserError
+        nil
+      end
+    end
+
+    # Show activity feed (mentions, reactions, calendar notifications)
+    class Activity < Base
+      include ActivityFormatting
+
+      NOTIFICATION_THREAD = '48:notifications'
+
+      ACTIVITY_OPTIONS = {
+        '--unread' => ->(opts, _pending) { opts[:unread] = true }
+      }.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
+
+        show_activity
+      end
+
+      protected
+
+      def handle_option(arg, pending)
+        handler = ACTIVITY_OPTIONS[arg]
+        return super unless handler
+
+        handler.call(@options, pending)
+      end
+
+      def help_text
+        <<~HELP
+          #{output.bold('teems activity')} - Show activity feed
+
+          #{output.bold('USAGE:')}
+            teems activity [options]
+
+          #{output.bold('OPTIONS:')}
+            -n, --limit N    Number of activities to show (default: 20)
+            --unread         Show only unread activities
+            -v, --verbose    Show debug output
+            -q, --quiet      Suppress output
+            --json           Output as JSON
+
+          #{output.bold('EXAMPLES:')}
+            teems activity              # Show recent activity
+            teems activity --unread     # Show only unread
+            teems activity -n 50        # Show 50 activities
+        HELP
+      end
+
+      private
+
+      def show_activity
+        render_activities(filtered_activities)
+        0
+      rescue ApiError => e
+        activity_fetch_error(e)
+      end
+
+      def filtered_activities
+        items = sorted_activities
+        @options[:unread] ? items.select { |item| item[:unread] } : items
+      end
+
+      def sorted_activities = fetch_and_parse.sort_by { |item| item[:time] || '' }.reverse
+
+      def activity_fetch_error(err)
+        error("Failed to fetch activity: #{err.message}")
+        1
+      end
+
+      def fetch_and_parse
+        response = with_token_refresh do
+          runner.messages_api.chat_messages(chat_id: NOTIFICATION_THREAD, limit: @options[:limit])
+        end
+        (response['messages'] || []).filter_map { |msg| parse_activity(msg) }
+      end
+
+      def render_activities(items)
+        if items.empty?
+          puts 'No activity found'
+        elsif @options[:json]
+          output_json(items.map { |item| item.except(:raw_activity) })
+        else
+          display_activities(items)
+        end
+      end
+
+      def parse_activity(msg)
+        activity = msg.dig('properties', 'activity')
+        return nil unless activity.is_a?(Hash)
+
+        { type: activity['activityType'], subtype: activity['activitySubtype'],
+          who: activity['sourceUserImDisplayName'], preview: activity['messagePreview'],
+          where: activity['sourceThreadTopic'],
+          time: activity['activityTimestamp'] || msg['composetime'],
+          unread: msg.dig('properties', 'isread')&.to_s != 'true',
+          raw_activity: activity }
+      end
+
+      def display_activities(items)
+        items.each { |item| display_single_activity(item) }
+      end
+
+      def display_single_activity(item)
+        marker = item[:unread] ? output.bold('* ') : '  '
+        print_activity_lines(marker, format_activity(item[:raw_activity], item[:time]))
+      end
+
+      def print_activity_lines(marker, text)
+        text.lines.each_with_index do |line, idx|
+          trimmed = line.chomp
+          puts idx.zero? ? "#{marker}#{trimmed}" : "  #{trimmed}"
+        end
+        puts
+      end
+    end
+  end
+end

data/lib/teems/commands/auth.rb

@@ -0,0 +1,268 @@
+# frozen_string_literal: true
+
+module Teems
+  module Commands
+    AUTH_HELP = <<~HELP
+      teems auth - Manage Teams authentication
+
+      USAGE:
+        teems auth [action]
+
+      ACTIONS:
+        login       Authenticate via Safari (opens browser)
+        logout      Remove stored tokens
+        status      Show current authentication status
+        manual      Show manual token extraction instructions
+        set-tokens  Manually enter tokens from browser
+
+      OPTIONS:
+        --certauth  Use certificate authentication (requires VPN)
+
+      EXAMPLES:
+        teems auth login              # Authenticate (headless or Safari OAuth)
+        teems auth login --certauth   # Use cert auth (on VPN)
+        teems auth status             # Check if authenticated
+        teems auth logout             # Clear stored tokens
+    HELP
+
+    # Token input methods for manual token entry and file import
+    module AuthTokenInput
+      def set_tokens
+        file_path = positional_args[1]
+        return import_tokens_from_file(file_path) if file_path
+
+        prompt_and_save_tokens
+      end
+
+      private
+
+      def prompt_and_save_tokens
+        print_token_prompt
+        auth_token = prompt_for_token('Auth token (from Authorization: Bearer header or authtoken cookie)')
+        return error('Auth token is required') if auth_token.to_s.empty?
+
+        save_extracted_tokens(auth_token, prompt_for_skype_token)
+      end
+
+      def print_token_prompt
+        puts 'Enter your Teams tokens.'
+        puts '(Tokens are long - you can also use: teems auth set-tokens <file>)'
+        puts
+      end
+
+      def prompt_for_skype_token
+        puts
+        puts 'Skype token is optional (needed for some chat APIs).'
+        puts 'Press Enter twice to skip, or paste the skypetoken_asm cookie value:'
+        prompt_for_token('Skype token (optional)')
+      end
+
+      def prompt_for_token(label)
+        puts "#{label}:\n(paste token, then press Enter twice or Ctrl-D)"
+        lines = []
+        while (input = $stdin.gets)
+          break if input.strip.empty?
+
+          lines << input.chomp
+        end
+        clean_token(lines.join)
+      end
+
+      def clean_token(raw)
+        stripped = raw.sub(/^Bearer\s+/i, '').sub(/^skypetoken=/i, '').strip
+        debug("Cleaned token (#{stripped.length} chars)")
+        stripped
+      end
+
+      def import_tokens_from_file(file_path)
+        return error("File not found: #{file_path}") unless File.exist?(file_path)
+
+        read_and_save_token_file(file_path)
+      rescue Errno::EACCES => e
+        error("Cannot read file: #{e.message}")
+      rescue Errno::EISDIR
+        error("Path is a directory, not a file: #{file_path}")
+      end
+
+      def read_and_save_token_file(file_path)
+        data = parse_token_file(file_path)
+        return data if data.is_a?(Integer)
+
+        validate_and_save_tokens(data)
+      end
+
+      def validate_and_save_tokens(data)
+        auth_token, skype_token, chatsvc = data.values_at('auth_token', 'skype_token', 'chatsvc_token')
+        auth_token ||= data['authtoken']
+        return error('File must contain auth_token key') unless auth_token
+
+        debug('Found auth token in file data')
+        save_extracted_tokens(auth_token, skype_token || data['skypetoken'] || auth_token, chatsvc)
+      end
+
+      def parse_token_file(file_path)
+        JSON.parse(File.read(file_path))
+      rescue JSON::ParserError
+        error('Invalid JSON file. Expected: {"auth_token": "..."}')
+      end
+
+      def save_extracted_tokens(auth_token, skype_token, chatsvc_token = nil)
+        token_store.save(
+          name: 'default', auth_token: clean_token(auth_token),
+          skype_token: clean_token(skype_token), chatsvc_token: chatsvc_token
+        )
+        success('Tokens saved successfully!')
+        0
+      end
+    end
+
+    AUTH_ACTIONS = {
+      'login' => :login, 'logout' => :logout, 'clear' => :logout,
+      'status' => :status, 'manual' => :show_manual_instructions,
+      'set-tokens' => :set_tokens, 'set' => :set_tokens
+    }.freeze
+
+    # Status display helpers for auth command
+    module AuthStatus
+      private
+
+      def status
+        return display_unauthenticated_status unless token_store.configured?
+
+        display_authenticated_status
+      end
+
+      def display_authenticated_status
+        account = token_store.account
+        return display_incomplete_tokens unless account
+
+        puts "#{output.green("\u2713")} Authenticated as: #{account.name}"
+        display_token_age
+        0
+      end
+
+      def display_incomplete_tokens
+        puts "#{output.yellow("\u26A0")} Token file exists but is incomplete"
+        puts 'Run: teems auth login'
+        0
+      end
+
+      def display_token_age
+        age = token_store.token_age
+        return unless age
+
+        hours = (age / 3600).to_i
+        if hours >= 24
+          puts "#{output.yellow("\u26A0")} Tokens are #{hours} hours old (may be expired)"
+        else
+          puts "  Token age: #{hours} hours"
+        end
+      end
+
+      def display_unauthenticated_status
+        puts "#{output.red("\u2717")} Not authenticated\n\nRun: teems auth login"
+        0
+      end
+    end
+
+    # Manages authentication with Microsoft Teams
+    class Auth < Base
+      include AuthTokenInput
+      include AuthStatus
+
+      AUTH_OPTIONS = {
+        '--certauth' => ->(opts, _args) { opts[:certauth] = true }
+      }.freeze
+
+      def initialize(args, runner:)
+        @options = {}
+        super
+      end
+
+      def execute
+        result = validate_options
+        return result if result
+
+        dispatch_action(positional_args.first)
+      end
+
+      protected
+
+      def handle_option(arg, pending)
+        handler = AUTH_OPTIONS[arg]
+        return super unless handler
+
+        handler.call(@options, pending)
+      end
+
+      def help_text = AUTH_HELP
+
+      private
+
+      def dispatch_action(action)
+        method_name = AUTH_ACTIONS[action || 'status']
+        return unknown_action(action) unless method_name
+
+        send(method_name)
+      end
+
+      def unknown_action(action)
+        error("Unknown auth action: #{action}")
+        puts 'Available actions: login, logout, status, manual, set-tokens'
+        1
+      end
+
+      def login
+        print_login_banner
+        mode = @options[:certauth] ? :certauth : :default
+        tokens = runner.token_extractor(auth_mode: mode).extract
+        handle_login_result(tokens)
+      end
+
+      def print_login_banner
+        puts 'Starting Teams authentication...'
+        puts 'Safari will open to teams.microsoft.com'
+        puts 'Please complete the login process'
+        puts
+      end
+
+      def handle_login_result(tokens)
+        if tokens && tokens[:auth_token] && tokens[:skype_token]
+          save_tokens(tokens)
+          success('Authentication successful!')
+          0
+        else
+          suggest_manual_auth
+        end
+      end
+
+      def suggest_manual_auth
+        error('Failed to extract tokens automatically')
+        puts "\nTry manual extraction instead:\n  teems auth manual"
+        1
+      end
+
+      def save_tokens(tokens)
+        token_store.save(name: 'default', **tokens.slice(:auth_token, :skype_token,
+                                                         :skype_spaces_token, :chatsvc_token,
+                                                         :refresh_token, :client_id, :tenant_id))
+      end
+
+      def logout
+        if token_store.configured?
+          token_store.clear
+          success('Tokens cleared')
+        else
+          puts 'No tokens to clear'
+        end
+        0
+      end
+
+      def show_manual_instructions
+        puts runner.token_extractor.manual_instructions
+        puts "\nOnce you have the tokens, you can set them manually:\n  teems auth set-tokens"
+        0
+      end
+    end
+  end
+end