teems 0.3.3 → 0.8.0

data/lib/teems/formatters/ics_format.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Renders Models::IcsEvent objects as an RFC 5545 calendar for subscribing from
+    # Calendar.app and friends. The VEVENT layout follows the feed outlook-cli served,
+    # so a subscription keeps showing invitees, responses and Teams join buttons.
+    module IcsFormat
+      PRODID = '-//ericboehs//teems//EN'
+      PARTSTAT = { 'accepted' => 'ACCEPTED', 'organizer' => 'ACCEPTED', 'declined' => 'DECLINED',
+                   'tentativelyAccepted' => 'TENTATIVE' }.freeze
+      ROLE = { 'optional' => 'OPT-PARTICIPANT', 'resource' => 'NON-PARTICIPANT' }.freeze
+
+      module_function
+
+      def calendar(events, name:, stamp: Time.now)
+        dtstamp = utc(stamp)
+        vevents = events.select(&:dated?).flat_map { |event| vevent(event, dtstamp) }
+        lines = ['BEGIN:VCALENDAR', 'VERSION:2.0', "PRODID:#{PRODID}", 'CALSCALE:GREGORIAN', 'METHOD:PUBLISH',
+                 "X-WR-CALNAME:#{escape(name)}", *vevents, 'END:VCALENDAR']
+        "#{lines.map { |line| fold(line) }.join("\r\n")}\r\n"
+      end
+
+      def vevent(event, dtstamp)
+        ['BEGIN:VEVENT', "UID:#{uri(event.uid)}", "DTSTAMP:#{dtstamp}", *times(event),
+         "SUMMARY:#{escape(event.subject)}", *optional_text('LOCATION', event.location),
+         *people(event), *optional_text('DESCRIPTION', event.description), *join_lines(event.join_url),
+         *status_lines(event), 'END:VEVENT']
+      end
+
+      def times(event) = ["DTSTART#{time_value(event.starts)}", "DTEND#{time_value(event.ends)}"]
+
+      # All-day events have Dates, others UTC Times
+      def time_value(value) = value.is_a?(Date) ? ";VALUE=DATE:#{value.strftime('%Y%m%d')}" : ":#{utc(value)}"
+
+      def people(event)
+        organizer = Hash(event.organizer)
+        email = mail_address(organizer)
+        lines = email ? ["ORGANIZER;CN=#{common_name(organizer, email)}:mailto:#{email}"] : []
+        lines + event.attendees.filter_map { |attendee| attendee_line(attendee) }
+      end
+
+      def attendee_line(attendee)
+        email = mail_address(attendee)
+        return unless email
+
+        role = ROLE.fetch(attendee[:type].to_s, 'REQ-PARTICIPANT')
+        partstat = PARTSTAT.fetch(attendee[:response].to_s, 'NEEDS-ACTION')
+        "ATTENDEE;CN=#{common_name(attendee, email)};ROLE=#{role};PARTSTAT=#{partstat};RSVP=TRUE:mailto:#{email}"
+      end
+
+      # An address that makes a valid mailto: URI, or nil. Exchange-internal X.500 addresses
+      # (/O=EXCHANGELABS/...) have no @ and are left out with the people who have them.
+      def mail_address(person)
+        email = uri(person[:email]).strip
+        email.include?('@') ? email : nil
+      end
+
+      def common_name(person, email)
+        name = person[:name].to_s.strip
+        param(name.empty? ? email : name)
+      end
+
+      # URI values are not text-escaped. URL is what most clients show; CONFERENCE and the
+      # Microsoft property are what Calendar.app and Outlook look for to offer a Join button.
+      def join_lines(join_url)
+        url = uri(join_url)
+        return [] if url.empty?
+
+        ["URL;VALUE=URI:#{url}", %(CONFERENCE;VALUE=URI;FEATURE=AUDIO,VIDEO;LABEL="Microsoft Teams":#{url}),
+         "X-MICROSOFT-SKYPETEAMSMEETINGURL:#{url}"]
+      end
+
+      def status_lines(event)
+        [*('STATUS:CANCELLED' if event.cancelled?), *('TRANSP:TRANSPARENT' if event.free?)]
+      end
+
+      def optional_text(name, text) = text.to_s.strip.empty? ? [] : ["#{name}:#{escape(text)}"]
+
+      # Control characters RFC 5545 allows in no value: all but HTAB, once line breaks are handled
+      CONTROLS = /[\x00-\x08\x0A-\x1F\x7F]/
+
+      # RFC 5545 TEXT escaping
+      def escape(text)
+        text.to_s.gsub(/[\\;,]/) { |char| "\\#{char}" }.gsub(/\r\n|\r|\n/, '\\n').gsub(CONTROLS, '')
+      end
+
+      # UIDs, URIs and addresses are not escaped, so a line break in one would start a new
+      # property: control characters are dropped
+      def uri(value) = value.to_s.gsub(CONTROLS, '')
+
+      # Parameter values are quoted when they hold a separator; quotes themselves cannot appear
+      def param(value)
+        text = value.to_s.delete('"').gsub(/[\r\n]+/, ' ').gsub(CONTROLS, '')
+        text.match?(/[;:,]/) ? %("#{text}") : text
+      end
+
+      def utc(time) = time.utc.strftime('%Y%m%dT%H%M%SZ')
+
+      # Lines longer than 75 octets continue on lines starting with a space, never splitting a character
+      def fold(line)
+        parts = []
+        line.each_char do |char|
+          current = parts.last
+          fits = current && current.bytesize + char.bytesize <= (parts.one? ? 75 : 74)
+          fits ? current << char : parts << char
+        end
+        parts.join("\r\n ")
+      end
+    end
+  end
+end

data/lib/teems/formatters/link_cleaner.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Cleans the hrefs listed in a mail links footer. SafeLinks wrappers are unwrapped and
+    # click tracking is dropped (utm_* everywhere, plus SharePoint and Teams noise on
+    # SharePoint hosts). Every other query parameter is kept with its original encoding.
+    module LinkCleaner
+      SAFELINKS_HOSTS = %w[.safelinks.protection.outlook.com .safelinks.protection.office365.us].freeze
+      SHAREPOINT_HOSTS = %w[.sharepoint.com .sharepoint.us].freeze
+      # ASP.NET reads query keys case-insensitively, so these are matched that way too
+      SHAREPOINT_NOISE = %w[xsdata sdata ovuser clickparams teamscid ct linkopentime or].freeze
+      # Not web pages: mail and phone links, inline images, scripts
+      SKIP_SCHEMES = %w[mailto: tel: cid: javascript: data: sms: callto: about:].freeze
+      URL_PARTS = %r{\A(?<head>[a-z][a-z0-9+.-]*://(?<host>[^/?#]*)[^?#]*)(?:\?(?<query>[^#]*))?(?<frag>#.*)?\z}im
+
+      module_function
+
+      def skip?(href)
+        href.empty? || href.start_with?('#') || href.downcase.start_with?(*SKIP_SCHEMES)
+      end
+
+      def clean(href)
+        url = unwrap_safelinks(href.gsub(/[\t\r\n]/, '').strip)
+        drop_tracking(url).gsub(' ', '%20')
+      end
+
+      # SafeLinks wraps the real URL in its url param, sometimes more than once when a
+      # message has been forwarded around
+      def unwrap_safelinks(url)
+        5.times do
+          inner = safelinks_target(url)
+          break unless inner
+
+          url = inner
+        end
+        url
+      end
+
+      def safelinks_target(url)
+        parts = URL_PARTS.match(url)
+        return unless parts && host_of(parts).end_with?(*SAFELINKS_HOSTS)
+
+        URI.decode_www_form(parts[:query].to_s).assoc('url')&.last&.strip
+      rescue ArgumentError
+        nil
+      end
+
+      def drop_tracking(url)
+        parts = URL_PARTS.match(url)
+        query = parts&.[](:query)
+        return url if query.to_s.empty?
+
+        pairs = query.split('&', -1)
+        noise = host_of(parts).end_with?(*SHAREPOINT_HOSTS) ? SHAREPOINT_NOISE : []
+        kept = pairs.reject { |pair| tracking_param?(pair, noise) }
+        kept.length == pairs.length ? url : rebuild(parts, kept)
+      end
+
+      def tracking_param?(pair, noise)
+        name = unescape(pair.split('=', 2).first.to_s).downcase
+        pair.empty? || name.start_with?('utm_') || noise.include?(name)
+      end
+
+      def rebuild(parts, kept)
+        query = kept.empty? ? '' : "?#{kept.join('&')}"
+        "#{parts[:head]}#{query}#{parts[:frag]}"
+      end
+
+      # Link text that is a URL, or just repeats the start of this one, adds nothing.
+      # Compared without scheme, leading www. and trailing slashes.
+      def label(text, url, max:)
+        text = text.delete("\u200b\ufeff").gsub(/[[:space:]]+/, ' ').strip
+        return '' if text.empty? || text.match?(%r{\A(https?://|www\.)}i) || prefix_of_url?(text, url)
+
+        text.length > max ? "#{text[0, max - 3].rstrip}..." : text
+      end
+
+      def prefix_of_url?(text, url)
+        bare_text = bare(text)
+        bare_text.match?(%r{[./]}) && bare(url).start_with?(bare_text)
+      end
+
+      def bare(text) = text.downcase.sub(%r{\A([a-z][a-z0-9+.-]*://)?(www\.)?}, '').sub(%r{/+\z}, '')
+
+      def host_of(parts) = parts[:host].sub(/\A.*@/, '').sub(/:\d*\z/, '').downcase
+
+      def unescape(text) = text.gsub(/%(\h\h)/) { Regexp.last_match(1).hex.chr }
+    end
+  end
+end

data/lib/teems/formatters/link_collector.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Collects the anchors of an HTML body, one entry per cleaned URL, numbered by first
+    # appearance. A later anchor for the same URL supplies the label when the first had none.
+    class LinkCollector
+      LABEL_MAX = 80
+
+      def initialize
+        @links = {}
+        # Each URL's footer number, kept when it is first added
+        @numbers = {}
+        @current = nil
+      end
+
+      def links = @links.to_a
+
+      def empty? = @links.empty?
+
+      def capturing? = @current.is_a?(Hash)
+
+      def start(href)
+        finish
+        @current = { href: href, text: +'', alt: [] }
+      end
+
+      def add_text(text)
+        @current[:text] << text if @current
+      end
+
+      def add_alt(alt)
+        @current[:alt] << alt if @current && !alt.empty?
+      end
+
+      # Ends the current anchor; returns its footer number, or nil when it is not listed
+      def finish
+        current = @current
+        return unless current
+
+        @current = nil
+        register(current[:href].strip, anchor_text(current))
+      end
+
+      def footer
+        return '' if empty?
+
+        lines = links.each.with_index(1).map do |(url, label), number|
+          label.empty? ? "[#{number}] #{url}" : "[#{number}] #{label} <#{url}>"
+        end
+        ['Links:', *lines].join("\n")
+      end
+
+      private
+
+      def anchor_text(current)
+        text = current[:text]
+        text.strip.empty? ? current[:alt].join(' ') : text
+      end
+
+      def register(href, text)
+        return if LinkCleaner.skip?(href)
+
+        url = LinkCleaner.clean(href)
+        @links[url] = LinkCleaner.label(text, url, max: LABEL_MAX) if @links.fetch(url, '').empty?
+        @numbers[url] ||= @numbers.size + 1
+      end
+    end
+  end
+end

data/lib/teems/formatters/mail_formatter.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Date styles shared by mail output
+    module MailDates
+      module_function
+
+      # The style Outlook for Mac printed, kept for `read` headers and synced Markdown
+      def long(time) = time ? time.getlocal.strftime('%A, %B %-d, %Y at %-I:%M:%S %p') : ''
+
+      def short(time) = time ? time.getlocal.strftime('%Y-%m-%d %H:%M') : ''
+
+      def iso(time) = time ? time.getlocal.iso8601 : ''
+    end
+
+    # Terminal output for `teems mail` (TSV rows come from the models)
+    class MailFormatter
+      FROM_WIDTH = 24
+      SUBJECT_WIDTH = 70
+
+      def initialize(output:)
+        @output = output
+      end
+
+      # id, received (local), from, subject, read flag
+      def message_rows(messages) = messages.map { |message| message_row(message) }
+
+      # message_rows plus each message's folder, which lines up after the read/unread column
+      def thread_rows(conversation)
+        conversation.messages.map do |message|
+          padding = message.read? ? '    ' : '  '
+          "#{message_row(message)}#{padding}#{@output.gray(conversation.folder(message).to_s)}"
+        end
+      end
+
+      def folder_rows(folders)
+        width = folders.map { |folder| folder.path.length }.push(6).max
+        header = @output.bold("#{'FOLDER'.ljust(width)}  #{'UNREAD'.rjust(6)}  #{'TOTAL'.rjust(7)}")
+        [header, *folders.collect { |folder| folder_row(folder, width) }]
+      end
+
+      private
+
+      def message_row(message)
+        short_id, received, from, subject = message.list_columns
+        from = FormatUtils.truncate(from, FROM_WIDTH - 3).ljust(FROM_WIDTH)
+        row = "#{@output.cyan(short_id)}  #{received}  #{from}  #{FormatUtils.truncate(subject, SUBJECT_WIDTH)}"
+        row = message.read? ? "#{row}  #{@output.gray('read')}" : @output.bold("#{row}  unread")
+        message.flagged ? "#{row}  #{@output.yellow('flagged')}" : row
+      end
+
+      def folder_row(folder, width)
+        "#{folder.path.ljust(width)}  #{folder.unread_count.to_s.rjust(6)}  #{folder.total_count.to_s.rjust(7)}"
+      end
+    end
+  end
+end

data/lib/teems/formatters/mail_markdown.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # Renders a synced mail message as Markdown with YAML frontmatter. The fields and layout
+    # follow the files outlook-cli wrote to ~/Mail, so md2maildir and search indexes keep working.
+    class MailMarkdown
+      SLUG_MAX = 80
+
+      def self.filename(message)
+        date = message.received_at&.getlocal&.strftime('%Y-%m-%d') || 'unknown-date'
+        slug = message.subject.unicode_normalize(:nfkc).gsub(/[^[:alnum:]]+/, '-')[0, SLUG_MAX].gsub(/\A-+|-+\z/, '')
+        "#{date}-#{slug.empty? ? 'no-subject' : slug}-#{message.short_id}.md"
+      end
+
+      def self.render(message, folder:, attachments: []) = new(message, folder, attachments).render
+
+      def initialize(message, folder, attachments)
+        @message = message
+        @folder = folder
+        @attachments = attachments
+      end
+
+      def render
+        [frontmatter, '', "# #{@message.subject}", '', "**From:** #{@message.from_display}",
+         "**To:** #{addresses(@message.to)}", "**Date:** #{MailDates.long(@message.received_at)}",
+         '', '---', '', *protection_lines, "#{@message.text_body}\n"].join("\n")
+      end
+
+      private
+
+      def frontmatter
+        fields = { 'id' => @message.id, **quoted_fields, 'status' => @message.status.downcase,
+                   'attachments' => quote(@attachments.join(', ')),
+                   'internet_message_id' => quote(@message.internet_message_id), **protection_field }
+        ['---', *fields.map { |key, value| "#{key}: #{value}" }, '---'].join("\n")
+      end
+
+      def quoted_fields
+        received = @message.received_at
+        fields = { 'subject' => @message.subject, 'from' => @message.from_display, 'to' => addresses(@message.to),
+                   'cc' => addresses(@message.cc), 'date' => MailDates.long(received),
+                   'received' => MailDates.iso(received), 'folder' => @folder,
+                   'categories' => @message.categories.join(', ') }
+        fields.transform_values { |value| quote(value) }
+      end
+
+      # Protected mail only, so files of plain mail stay as outlook-cli wrote them
+      def protection_field
+        kind = @message.protection
+        kind ? { 'protection' => quote(kind) } : {}
+      end
+
+      # A note above the body of protected mail, whose body is empty or Microsoft's placeholder;
+      # Purview mail's links to Outlook on the web, which opens it
+      def protection_lines
+        note = @message.protection_note
+        return [] unless note
+
+        link = @message.protection == 'purview' && @message.web_link
+        [link ? "> #{note}: <#{link}>" : "> #{note}", '']
+      end
+
+      def addresses(list) = list.map { |entry| entry[:address] }.reject(&:empty?).join(', ')
+
+      # JSON strings are valid YAML double-quoted scalars
+      def quote(value) = JSON.generate(value.to_s)
+    end
+  end
+end

data/lib/teems/formatters/mail_rule_formatter.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # `teems mail rules` output: a table, TSV, or JSON, each with MailRuleText's description
+    class MailRuleFormatter
+      NAME_WIDTH = 30
+
+      # folder_names: Graph folder ID => path, to name where a rule moves mail
+      def initialize(output:, folder_names: {})
+        @output = output
+        @text = MailRuleText.new(folder_names)
+      end
+
+      def describe(rule) = @text.describe(rule)
+
+      def rows(rules)
+        width = name_width(rules)
+        rules.map { |rule| row(rule, width) }
+      end
+
+      def tsv_rows(rules) = rules.map { |rule| rule.tsv_row(describe(rule)) }
+
+      def json(rules) = rules.map { |rule| rule.to_json_hash(describe(rule)) }
+
+      private
+
+      def name_width(rules) = rules.map { |rule| rule.name.length }.max.to_i.clamp(..NAME_WIDTH)
+
+      def row(rule, width)
+        number, state, name = rule.columns
+        "#{number.to_s.rjust(3)}  #{state_text(state)}  #{name[0, width].ljust(width)}  #{describe(rule)}"
+      end
+
+      def state_text(state)
+        padded = state.ljust(5)
+        case state
+        when 'on' then @output.green(padded)
+        when 'off' then @output.gray(padded)
+        else @output.red(padded)
+        end
+      end
+    end
+  end
+end

data/lib/teems/formatters/mail_rule_text.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Teems
+  module Formatters
+    # One line saying what an Inbox rule does, e.g.
+    #   from jira@example.com, except subject has "urgent" -> move to Inbox/Jira, stop
+    # Keys this does not know are spelled out from their Graph names, so nothing is hidden.
+    class MailRuleText
+      LABELS = {
+        'fromAddresses' => 'from', 'sentToAddresses' => 'to', 'subjectContains' => 'subject has',
+        'bodyContains' => 'body has', 'bodyOrSubjectContains' => 'subject or body has',
+        'senderContains' => 'sender has', 'recipientContains' => 'recipient has',
+        'headerContains' => 'header has', 'moveToFolder' => 'move to', 'copyToFolder' => 'copy to',
+        'assignCategories' => 'categories', 'markImportance' => 'importance',
+        'forwardTo' => 'FORWARD to', 'forwardAsAttachmentTo' => 'FORWARD as attachment to',
+        'redirectTo' => 'REDIRECT to'
+      }.freeze
+      # Conditions and actions that are simply on
+      SWITCHES = { 'markAsRead' => 'mark read', 'stopProcessingRules' => 'stop',
+                   'delete' => 'delete', 'permanentDelete' => 'PERMANENTLY delete',
+                   'isMeetingRequest' => 'meeting requests', 'hasAttachments' => 'with attachments' }.freeze
+      FOLDER_ACTIONS = %w[moveToFolder copyToFolder].freeze
+
+      # folder_names: Graph folder ID => path, to name a rule's destination
+      def initialize(folder_names = {})
+        @folder_names = folder_names
+      end
+
+      def describe(rule)
+        exceptions = phrases(rule.exceptions)
+        tests = phrases(rule.conditions).join(', ')
+        tests = 'all mail' if tests.empty?
+        tests += ", except #{exceptions.join(', ')}" if exceptions.any?
+        "#{tests} -> #{phrases(rule.actions).join(', ')}"
+      end
+
+      private
+
+      def phrases(settings) = settings.filter_map { |key, value| phrase(key, value) }
+
+      def phrase(key, value)
+        return if [false, nil, []].include?(value)
+
+        switch = value == true
+        label = (switch ? SWITCHES : LABELS).fetch(key) { spelled(key) }
+        switch ? label : "#{label} #{values_text(key, value)}"
+      end
+
+      def values_text(key, value) = Array(value).map { |item| item_text(key, item) }.join(', ')
+
+      def item_text(key, item)
+        return @folder_names.fetch(item, 'another folder') if FOLDER_ACTIONS.include?(key)
+        return recipient_text(item) if item.is_a?(Hash)
+
+        key.end_with?('Contains') ? %("#{item}") : item.to_s
+      end
+
+      def recipient_text(item)
+        address = item['emailAddress'] || item
+        address.values_at('address', 'name').compact.first.to_s
+      end
+
+      # isAutomaticReply -> is automatic reply
+      def spelled(key) = key.gsub(/[A-Z]/) { |letter| " #{letter.downcase}" }
+    end
+  end
+end

data/lib/teems/formatters/output.rb

@@ -22,6 +22,14 @@ module Teems
       end
     end
 
+    # Stands in for stdout or stderr once its reader has gone away (see Output#to_stdout)
+    module NullIO
+      def self.puts(*) = nil
+      def self.print(*) = nil
+      def self.flush = self
+      def self.tty? = false
+    end
+
     # Terminal output with ANSI color support
     class Output
       include OutputColors
@@ -52,23 +60,34 @@ module Teems
       def tty? = @io.tty?
 
       def puts(message = '')
-        write_unless_quiet { @io.puts(message) }
+        write_unless_quiet { |io| io.puts(message) }
       end
 
       def print(message)
-        write_unless_quiet { @io.print(message) }
+        write_unless_quiet { |io| io.print(message) }
       end
 
       def flush
-        @io.flush
+        to_stdout(&:flush)
       end
 
       def error(message)
-        @err.puts(colorize("#{red('Error:')} #{message}"))
+        to_stderr { |err| err.puts(colorize("#{red('Error:')} #{message}")) }
       end
 
       def warn(message)
-        write_unless_quiet { @err.puts(colorize("#{yellow('Warning:')} #{message}")) }
+        note("#{yellow('Warning:')} #{message}")
+      end
+
+      # A question for the person at the terminal: on stderr, so piped stdout stays data, and
+      # shown under --quiet too, since an unseen question would just hang (stderr is unbuffered)
+      def prompt(message)
+        to_stderr { |err| err.print(message) }
+      end
+
+      # Commentary that should not mix with data on stdout (shown unless --quiet)
+      def note(message)
+        to_stderr { |err| err.puts(colorize(message)) } unless quiet?
       end
 
       def success(message)
@@ -82,13 +101,31 @@ module Teems
       def debug(message)
         return unless verbose?
 
-        @err.puts(colorize("#{gray('[debug]')} #{message}"))
+        to_stderr { |err| err.puts(colorize("#{gray('[debug]')} #{message}")) }
       end
 
       private
 
-      def write_unless_quiet
-        yield unless quiet?
+      def write_unless_quiet(&)
+        to_stdout(&) unless quiet?
+      end
+
+      # A reader that stops early (`teems ... | head`) is not an error: drop the
+      # rest of stdout and let the command finish quietly. Raising instead would
+      # surface as "Unexpected error: Broken pipe", or be caught by a per-item
+      # rescue and reported as a failed chat or download.
+      def to_stdout
+        yield @io
+      rescue Errno::EPIPE
+        @io = NullIO
+      end
+
+      # The same for stderr, which `teems ... 2>&1 | head` closes along with stdout. A
+      # warning that raised here would also escape the per-item rescues that report it.
+      def to_stderr
+        yield @err
+      rescue Errno::EPIPE
+        @err = NullIO
       end
 
       def wrap(color, text)

data/lib/teems/models/chat.rb

@@ -30,18 +30,22 @@ module Teems
       end
 
       def self.from_ngmsg(data)
-        thread_props = data['threadProperties'] || {}
+        id = data['id']
         props = data['properties'] || {}
         new(
-          id: data['id'],
-          topic: thread_props['topic'] || thread_props['spaceThreadTopic'],
-          chat_type: normalize_chat_type(thread_props['threadType']),
-          created_at: parse_time(thread_props['createdat']),
+          id: id,
           last_updated: parse_time(props['lastimreceivedtime']),
+          **ngmsg_thread(id, data['threadProperties'] || {}),
           **ngmsg_status(props, data['lastMessage'])
         )
       end
 
+      def self.ngmsg_thread(id, thread_props)
+        { topic: thread_props['topic'] || thread_props['spaceThreadTopic'],
+          chat_type: ngmsg_chat_type(id, thread_props),
+          created_at: parse_time(thread_props['createdat']) }
+      end
+
       def self.ngmsg_status(props, last_message)
         horizon = props['consumptionhorizon']
         last_msg_id = last_message&.dig('id')
@@ -52,6 +56,13 @@ module Teems
         }
       end
 
+      # ng.msg reports 1:1 chats with threadType 'chat', like group chats. They are marked by
+      # productThreadType 'OneToOneChat' and a "19:<user>_<user>@unq.gbl.spaces" ID.
+      def self.ngmsg_chat_type(id, thread_props)
+        one_on_one = thread_props['productThreadType'] == 'OneToOneChat' || id.to_s.end_with?('@unq.gbl.spaces')
+        one_on_one ? 'oneOnOne' : normalize_chat_type(thread_props['threadType'])
+      end
+
       # Normalize ng.msg threadType to a consistent chat type.
       # ng.msg uses: 'chat' (group), 'meeting', 'topic' (channel), 'space'
       # Normalized to: 'group', 'meeting', 'channel', 'space'
@@ -79,6 +90,9 @@ module Teems
 
       def chat_type_label = CHAT_TYPE_LABELS.fetch(chat_type, chat_type)
 
+      # What sync uses to name and place the chat's directory
+      def sync_identity = { chat_id: id, display_name: display_name, chat_type: chat_type }
+
       def unread? = unread
       def favorite? = favorite
       def pinned? = pinned