git-fit 0.11.3 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 276921601668a2e97d554de9e446f64e0fe6986e681d5eada7d9688757b51d98
-  data.tar.gz: 925e3e271c03e659b406426d03f4714eaff62fb57961738455f43d6926bd0c25
+  metadata.gz: c3e935c4e4949dfd80ef84c659f9f64a727d9c1d3aab7c2b6303d6571f42156b
+  data.tar.gz: 771f645e5ae8a369c89237d3df03c00b06d5887f5331e7cfec306af0c57f8eb6
 SHA512:
-  metadata.gz: 02537c373595d27fc4d65288a7608d4eb5713500eddb022e881aa9df09c68c423522cf6b065da4852bc65c155fd331836e20497ddb29dc64635a12896d3c70ae
-  data.tar.gz: 8fd6c2b178cf4a6a0e38345e0e5884cdea0ce9da14573ab3f775adb918a335e6b1cad6a2d6d92fa135c94919fcd7ac25b2870a2b963b306af206d74ce3de226c
+  metadata.gz: 926a648129246714657066e5d7a21b9663682af63516a98d21646e9c58167b4c962150697a8d1d9e14068c834d1d010f9d3696628f8edae9b6ee8f2c614d36cc
+  data.tar.gz: 7bebd70ae9b51e18fc97278f7e691466ea5ca4aec07594c83bc7ca2c9ff913f85566dcf9b98b6013a279a3c2927216fd60ad82d860d8185b8fb133a873fbc5fe

data/lib/git-fit.rb

@@ -63,7 +63,7 @@ require_relative 'git_fit/util'
 require_relative 'git_fit/sync/lorem'
 require_relative 'git_fit/sync/garmin_base'
 require_relative 'git_fit/sync/garmin_base_di'
-require_relative 'git_fit/sync/garmin'
+require_relative 'git_fit/sync/garmin_com'
 require_relative 'git_fit/sync/garmin_cn'
 require_relative 'git_fit/sync/strava'
 require_relative 'git_fit/sync/keep'

data/lib/git_fit/auth/garmin/login_session.rb

@@ -15,7 +15,7 @@ module GitFit
       # Persists the pre-auth login session created during an interrupted MFA
       # flow. This is a *temporary* session (30-minute TTL matching the MFA code
       # validity window), distinct from the long-lived persistent session cookie
-      # (garmin_playwright_session_*.json) that Strategy B keeps after success.
+      # (data/auth/garmin/session.json) that Strategy B keeps after success.
       module LoginSession
         DIR = 'data/cache'
         TTL_SECONDS = 30 * 60

data/lib/git_fit/auth/garmin/strategy_b.rb

@@ -2,7 +2,8 @@
 
 require_relative 'di_exchange'
 require_relative 'login_session'
-require_relative '../../sync/garmin_base'
+require_relative '../../sync/garmin_com'
+require_relative '../paths'
 require 'json'
 require 'fileutils'
 
@@ -18,7 +19,6 @@ module GitFit
         MOBILE_SERVICE = 'https://mobile.integration.garmin.com/gcm/android'
         LOGIN_DELAY_MIN = 30.0
         LOGIN_DELAY_MAX = 45.0
-        SESSION_CACHE_DIR = 'data/cache'
         REDIRECT_STATUSES = [301, 302, 303, 307, 308].freeze
         AUTH_FLAG = '-B'
 
@@ -204,8 +204,8 @@ module GitFit
           sleep(delay)
         end
 
-        def _session_file_path(domain)
-          File.join(SESSION_CACHE_DIR, "garmin_playwright_session_#{domain.tr('.', '_')}.json")
+        def _session_file_path(_domain)
+          Auth.file(GitFit::Sync::GarminCom.source_prefix, 'session.json')
         end
 
         def _load_session(session_path)

data/lib/git_fit/auth/garmin.rb

@@ -4,6 +4,8 @@ require_relative 'garmin/strategy_a'
 require_relative 'garmin/strategy_b'
 require_relative 'garmin/di_exchange'
 require_relative 'garmin/login_session'
+require_relative 'paths'
+require_relative '../sync/garmin_com'
 require_relative '../config'
 require_relative '../cli/gh_cli'
 require 'json'
@@ -189,7 +191,7 @@ module GitFit
 
         def token_path
           garmin_cfg['token_path'] ||
-            File.join('data', 'auth', "garmin_#{domain.tr('.', '_')}_tokens.json")
+            Auth.file(GitFit::Sync::GarminCom.source_prefix, 'tokens.json')
         end
 
         def gh_ladder(seed)

data/lib/git_fit/auth/garmin_token.rb

@@ -10,7 +10,7 @@ module GitFit
     # commands, CI token checks).
     class GarminToken
       def self.for_intl(config)
-        authenticate_with(GitFit::Sync::Garmin, config, 'garmin.com')
+        authenticate_with(GitFit::Sync::GarminCom, config, 'garmin.com')
       end
 
       def self.for_cn(config)

data/lib/git_fit/auth/paths.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module GitFit
+  module Auth
+    module_function
+
+    # Canonical per-source auth storage: data/auth/{source}/{name}. All sync
+    # adapters, the auth orchestrator and strategies must resolve token/session
+    # defaults through this helper so they can never drift apart.
+    def file(source, name)
+      File.join('data', 'auth', source, name)
+    end
+  end
+end

data/lib/git_fit/cli/import_cli.rb

@@ -184,5 +184,36 @@ module GitFit
         0
       end
     end
+
+    desc 'tbulu', 'Import 2bulu (两步路) activities from data/import/2bulu/'
+    option :activity, type: :array, desc: 'Filter by sport type', aliases: '--act'
+    option :checkpoint, type: :boolean, desc: 'Run WAL checkpoint after import'
+    def tbulu
+      config = GitFit::Config.new
+      conn = GitFit::DB::Connection.new(config.db_path)
+      conn.migrate!
+      db = conn.db
+      filter = options[:activity]&.map(&:strip)&.map(&:downcase)
+      time_budget = config.dig('sync', 'time_budget')
+
+      say_status :import, '2bulu', :green
+      adapter = GitFit::Import::Tbulu.new(
+        config: {}, db:, activity_filter: filter,
+        time_budget: time_budget
+      )
+
+      begin
+        count = adapter.call
+        if count == 0
+          say_status :warn, '2bulu: 0 activities (already imported or none found)', :yellow
+        else
+          say_status :done, "2bulu: #{count} activities", :green
+        end
+        checkpoint_db(db) if options[:checkpoint]
+      rescue StandardError => e
+        say_status :error, "2bulu: #{e.message}", :red
+        0
+      end
+    end
   end
 end

data/lib/git_fit/cli/strava.rb

@@ -4,6 +4,7 @@ require 'thor'
 require 'fileutils'
 require 'tzinfo'
 require 'stravaweb'
+require_relative '../auth/paths'
 
 module GitFit
   class StravaCLI < Thor
@@ -60,7 +61,7 @@ module GitFit
       FileUtils.mkdir_p(output_dir)
       cache_dir = File.join('data', 'cache', 'strava_downloads')
       FileUtils.mkdir_p(cache_dir)
-      cookie_path = File.join('data', 'cache', 'strava_session.yml')
+      cookie_path = web_cfg['cookie_path'] || GitFit::Auth.file('strava', 'session.yml')
 
       if activity_ids.empty?
         activity_ids = pending_ids(config, output_dir)

data/lib/git_fit/config_template.rb

@@ -19,6 +19,7 @@ module GitFit
           #   web_auth:                                # web original-file fetch (git fit strava fetch)
           #     jwt: ""                                # env: GIT_FIT_STRAVA_WEB_AUTH_JWT (strava_remember_token)
           #     auth_seed: ""                          # env: GIT_FIT_STRAVA_WEB_AUTH_AUTH_SEED (base64 JWT)
+          #     cookie_path: ""                        # default data/auth/strava/session.yml
 
           # garmin:                                    # env: GIT_FIT_GARMIN_EMAIL
           #   email: ""                                # env: GIT_FIT_GARMIN_PASSWORD
@@ -44,12 +45,14 @@ module GitFit
           # xoss:                                        # env: GIT_FIT_XOSS_EMAIL
           #   email: ""                                  # env: GIT_FIT_XOSS_PASSWORD
           #   password: ""
+          #   token_path: ""                             # env: GIT_FIT_XOSS_TOKEN_PATH
+          #                                              # default data/auth/xoss/tokens.json
 
           # xingzhe:                                     # env: GIT_FIT_XINGZHE_EMAIL
           #   email: ""                                  # env: GIT_FIT_XINGZHE_PASSWORD
           #   password: ""
           #   session_path: ""                           # env: GIT_FIT_XINGZHE_SESSION_PATH
-          #                                              # default data/cache/xingzhe_session.json
+          #                                              # default data/auth/xingzhe/session.json
 
         export:
           json:

data/lib/git_fit/import/tbulu.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'fileutils'
+require 'json'
+require 'time'
+require 'tzinfo'
+
+module GitFit
+  module Import
+    class Tbulu < Source::Base
+      DEFAULT_IMPORT_DIR = 'data/import/2bulu'
+
+      def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil)
+        super
+        @import_dir = config['import_dir'] || DEFAULT_IMPORT_DIR
+        @timezone_resolver = GitFit::Timezone::Resolver.new(config)
+      end
+
+      def before_call
+        return false unless File.directory?(@import_dir)
+        super
+      end
+
+      def authenticate
+        true
+      end
+
+      def call
+        return 0 unless before_call
+
+        files = scan_files
+        total = 0
+        files.each do |file_path|
+          break if time_expired? && total.positive?
+          r = process_one(file_path)
+          total += 1 if r
+          report_progress(total, files.size, File.basename(file_path)) if r
+        end
+
+        total
+      end
+
+      def pending_ids
+        []
+      end
+
+      def source_label
+        '2bulu'
+      end
+
+      def raw_dir
+        File.join('data', 'raw', '2bulu')
+      end
+
+      def std_dir
+        File.join('data', 'std', '2bulu')
+      end
+
+      private
+
+      def scan_files
+        Dir.glob(File.join(@import_dir, '*'), File::FNM_CASEFOLD).select do |f|
+          File.file?(f) && GitFit::Parser::Tbulu.sniff_format(File.binread(f))
+        end
+      end
+
+      def process_one(file_path)
+        content = File.binread(file_path)
+        format = GitFit::Parser::Tbulu.sniff_format(content)
+        return nil unless format
+
+        parser = GitFit::Parser::Tbulu.new
+        activities, points = parser.call_with_points(content)
+        return nil if activities.empty?
+
+        activity = activities.first
+        return nil if skip_type?(activity[:sport_category])
+
+        run_id = build_run_id(activity, points)
+        return nil if existing_run_id?(run_id)
+
+        ext = format == :tk ? '.2tk' : '.kml'
+        write_raw(content, run_id, ext)
+        write_std(activity, run_id, points)
+
+        activity[:source] = '2bulu'
+        activity[:run_id] = run_id
+        upsert_activity(activity)
+        activity
+      end
+
+      def build_run_id(activity, points)
+        date = extract_date_prefix(activity[:start_date])
+        "2bulu_#{date}_#{content_hash(points, activity)[0, 12]}"
+      end
+
+      def content_hash(points, activity)
+        point_part = points.map do |p|
+          t = p[3].respond_to?(:to_i) ? p[3].to_i : p[3]
+          [p[0].round(9), p[1].round(9), p[2].round(3), t].join('|')
+        end.join("\n")
+        sensor_part = [
+          activity[:steps].to_i,
+          activity[:calories].to_f.round(1),
+          activity[:total_up].to_f.round(1),
+          activity[:total_down].to_f.round(1),
+        ].join('|')
+        Digest::SHA256.hexdigest("#{point_part}\n#{sensor_part}")
+      end
+
+      def upsert_activity(activity)
+        # steps/total_up/total_down are hash-only signals, not DB columns
+        persistable = activity.reject { |k, _| %i[steps total_up total_down].include?(k) }
+        super(persistable)
+      end
+
+      def extract_date_prefix(start_date)
+        t = parse_start_time(start_date)
+        return '00000000' unless t
+        t.getutc.strftime('%Y%m%d')
+      end
+
+      def parse_start_time(start_date)
+        return nil unless start_date
+        start_date.respond_to?(:getutc) ? start_date : Time.parse(start_date.to_s)
+      rescue ArgumentError
+        nil
+      end
+
+      def write_raw(content, run_id, ext)
+        FileUtils.mkdir_p(raw_dir)
+        tmp = File.join(raw_dir, ".#{run_id}#{ext}.tmp")
+        final = File.join(raw_dir, "#{run_id}#{ext}")
+        File.binwrite(tmp, content)
+        File.rename(tmp, final)
+      end
+
+      def write_std(activity, run_id, points)
+        return unless points&.any?
+
+        std_data = points.map do |pt|
+          h = { latitude: pt[0], longitude: pt[1] }
+          h[:altitude] = pt[2] if pt[2]
+          h[:timestamp] = pt[3]&.iso8601 if pt[3]
+          h
+        end
+
+        natural_id = run_id.sub('2bulu_', '')
+        FileUtils.mkdir_p(std_dir)
+        tmp = File.join(std_dir, ".#{natural_id}.json.tmp")
+        final = File.join(std_dir, "#{natural_id}.json")
+        File.write(tmp, JSON.generate(std_data))
+        File.rename(tmp, final)
+
+        coords = points.map { |p| [p[0], p[1]] }
+        activity[:summary_polyline] = GitFit::Geo::Polyline.encode(coords)
+
+        first_pt = points.first
+        tz = @timezone_resolver.resolve(first_pt[0], first_pt[1])
+        return unless tz && activity[:start_date]
+        activity[:start_date_local] = utc_to_local(activity[:start_date], tz)
+      end
+
+      def existing_run_id?(run_id)
+        !@db[:activities].where(run_id: run_id).empty?
+      end
+
+      def utc_to_local(utc_iso8601, tz_name)
+        return utc_iso8601 unless utc_iso8601 && tz_name
+        t = Time.parse(utc_iso8601)
+        return utc_iso8601 unless t.utc?
+        tz = TZInfo::Timezone.get(tz_name)
+        local = tz.utc_to_local(t)
+        local.iso8601
+      rescue TZInfo::InvalidTimezoneIdentifier, ArgumentError
+        utc_iso8601
+      end
+    end
+  end
+end

data/lib/git_fit/import.rb

@@ -2,3 +2,4 @@
 
 require_relative 'import/local_file'
 require_relative 'import/apple_health'
+require_relative 'import/tbulu'

data/lib/git_fit/parser/tbulu.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'time'
+
+module GitFit
+  module Parser
+    class Tbulu < Base
+      MAGIC = '##tk'.b
+      MOD32 = 2**32
+      HOUR8 = 8 * 3600 * 1000
+
+      SPORT_TYPE_MAP = {
+        3 => 'hike',
+        18 => 'hike',
+        24 => 'run',
+      }.freeze
+
+      def self.sniff_format(content)
+        return :tk if content.start_with?(MAGIC)
+        return :kml if content.lstrip.start_with?('<kml', '<?xml')
+
+        nil
+      end
+
+      def call(input)
+        activities, = call_with_points(input)
+        activities
+      end
+
+      def call_with_points(input)
+        content = input.is_a?(String) ? input.b : input
+        return [[], []] if content.nil? || content.empty?
+
+        format = sniff_format(content)
+        case format
+        when :tk then parse_2tk_full(content)
+        when :kml then parse_kml_full(content)
+        else
+          [[], []]
+        end
+      end
+
+      def extract_points(input)
+        _, points = call_with_points(input)
+        points
+      end
+
+      private
+
+      def sniff_format(content)
+        self.class.sniff_format(content)
+      end
+
+      # ── 2tk ──────────────────────────────────────────────────
+
+      def parse_2tk_full(content)
+        header = extract_2tk_header(content)
+        ti = header['trackinfo']
+        return [[], []] if ti.nil?
+
+        start_ms = ti['starttime']
+        return [[], []] unless start_ms
+
+        points = extract_2tk_points(content, header, start_ms)
+        return [[], points] if points.empty?
+
+        times = points.map { |p| p[3] }.compact
+        return [[], points] if times.empty?
+
+        sport = classify_sport(ti['tracktype'], header)
+        attrs = build_activity_attrs({
+          run_id: build_run_id('2bulu', SecureRandom.hex(8)),
+          name: ti['title'],
+          distance: total_distance(points),
+          moving_time: moving_time_from_points(points),
+          elapsed_time: elapsed_time_from_points(points),
+          sport_category: sport,
+          sport_type: ti['tracktype'],
+          start_date: times.min,
+          start_date_local: times.min,
+          location_country: nil,
+          summary_polyline: nil,
+          average_heartrate: nil,
+          elevation_gain: elevation_gain(points),
+          source: '2bulu',
+        })
+        attach_sensor_stats(attrs, ti)
+        [[attrs], points]
+      end
+
+      def parse_2tk(content)
+        attrs, = parse_2tk_full(content)
+        attrs
+      end
+
+      def attach_sensor_stats(attrs, track_info)
+        attrs[:steps] = track_info['steps']
+        attrs[:calories] = track_info['calorie']
+        attrs[:total_up] = track_info['totalup']
+        attrs[:total_down] = track_info['totaldown']
+      end
+
+      def extract_2tk_header(content)
+        pos = content.index('{')
+        return {} unless pos
+
+        depth = 0
+        json_end = nil
+        (pos...content.bytesize).each do |i|
+          case content.getbyte(i)
+          when 0x7b then depth += 1
+          when 0x7d then depth -= 1
+          end
+          json_end = i if depth.zero?
+          break if depth.zero?
+        end
+        return {} unless json_end
+
+        JSON.parse(content[pos..json_end])
+      rescue JSON::ParserError
+        {}
+      end
+
+      def extract_2tk_points(content, _header, start_ms)
+        pos = content.index('{')
+        return [] unless pos
+
+        depth = 0
+        json_end = nil
+        (pos...content.bytesize).each do |i|
+          case content.getbyte(i)
+          when 0x7b then depth += 1
+          when 0x7d then depth -= 1
+          end
+          json_end = i if depth.zero?
+          break if depth.zero?
+        end
+        return [] unless json_end
+
+        bin_start = json_end + 1
+        pcount = content[bin_start + 10, 4].unpack1('L<')
+        pts_raw = content[bin_start + 14, pcount * 36]
+        return [] unless pts_raw && pts_raw.bytesize == pcount * 36
+
+        times = []
+        coords = []
+        (0...pcount).each do |i|
+          off = i * 36
+          lat, lng = pts_raw[off, 16].unpack('E2')
+          alt = pts_raw[off + 16, 4].unpack1('l<')
+          t = pts_raw[off + 24, 4].unpack1('L<')
+          q = ((start_ms - t).to_f / MOD32).round
+          times << t + q * MOD32
+          coords << [lat, lng, alt]
+        end
+
+        delta = timezone_fix(times, start_ms)
+        times.map! { |t| t + delta }
+
+        times.each_with_index.map do |t, i|
+          c = coords[i]
+          [c[0], c[1], c[2], Time.at(t / 1000.0).utc, nil]
+        end
+      end
+
+      def timezone_fix(times, start_ms)
+        return 0 if times.empty?
+        (-2..2).each do |k|
+          cand = times[0] + k * HOUR8
+          return k * HOUR8 if cand >= start_ms - 30 * 60_000 && cand <= start_ms + HOUR8
+        end
+        0
+      end
+
+      # ── KML ─────────────────────────────────────────────────
+
+      def parse_kml_full(content)
+        doc = parse_xml(content)
+        return [[], []] unless doc
+
+        ext = extract_extended_data(doc)
+        points = extract_kml_points(doc)
+        return [[], points] if points.empty?
+
+        times = points.map { |p| p[3] }.compact
+        return [[], points] if times.empty?
+        start_date = times.min
+
+        sport = classify_sport(nil, ext)
+        distance = ext['Mileage'].to_f
+        distance = ext['Distance'].to_f if distance.zero?
+
+        attrs = build_activity_attrs({
+          run_id: build_run_id('2bulu', SecureRandom.hex(8)),
+          name: doc_text(doc, '//Document/name'),
+          distance: distance,
+          moving_time: moving_time_from_points(points),
+          elapsed_time: elapsed_time_from_points(points),
+          sport_category: sport,
+          sport_type: sport_type_name(ext['SportTypeId']),
+          start_date: start_date,
+          start_date_local: start_date,
+          location_country: nil,
+          summary_polyline: nil,
+          average_heartrate: nil,
+          elevation_gain: elevation_gain(points),
+          source: '2bulu',
+        })
+        attach_kml_stats(attrs, ext)
+        [[attrs], points]
+      end
+
+      def parse_kml(content)
+        attrs, = parse_kml_full(content)
+        attrs
+      end
+
+      def attach_kml_stats(attrs, ext)
+        attrs[:steps] = ext['Step'].to_i
+        attrs[:calories] = ext['Calorie'].to_f
+        attrs[:total_up] = ext['ElevationGain'].to_f
+        attrs[:total_down] = ext['ElevationLoss'].to_f
+      end
+
+      def extract_kml_points(doc)
+        whens = doc.xpath('//when').map(&:text)
+        coords = doc.xpath('//coord').map { |c| c.text.strip.split.map(&:to_f) }
+
+        if whens.empty? || coords.empty?
+          whens = []
+          coords = []
+          doc.xpath('//coordinates').each do |cs|
+            cs.text.strip.split.each do |triplet|
+              c = triplet.split(',').map(&:to_f)
+              coords << c
+              whens << nil
+            end
+          end
+        end
+
+        whens.each_with_index.map do |w, i|
+          c = coords[i] || [0, 0, 0]
+          [c[1], c[0], c[2], w ? parse_time(w) : nil, nil]
+        end
+      end
+
+      def extract_extended_data(doc)
+        ext = {}
+        doc.xpath('//Data').each do |d|
+          name = d['name']
+          value = d.at_xpath('value')&.text
+          ext[name] = value if name && value
+        end
+        ext
+      end
+
+      def parse_xml(content)
+        require 'nokogiri'
+        doc = Nokogiri::XML(content)
+        doc.remove_namespaces!
+        doc
+      rescue Nokogiri::XML::SyntaxError
+        nil
+      end
+
+      def doc_text(doc, xpath)
+        doc.at_xpath(xpath)&.text&.strip
+      end
+
+      def parse_time(str)
+        return nil unless str
+        Time.parse(str)
+      rescue ArgumentError
+        nil
+      end
+
+      # ── sport classification ────────────────────────────────
+
+      TRACKTYPE_MAP = {
+        '爬山' => 'hike',
+        '徒步' => 'hike',
+        '跑步' => 'run',
+        '骑行' => 'ride',
+      }.freeze
+
+      def classify_sport(tracktype, data)
+        sport_type_id = data['SportTypeId'] if data.is_a?(Hash)
+        mapped = SPORT_TYPE_MAP[sport_type_id.to_i] if sport_type_id
+        return mapped if mapped
+
+        track_type_id = data['TrackTypeId'] if data.is_a?(Hash)
+        return 'hike' if track_type_id.to_i == 8
+
+        TRACKTYPE_MAP[tracktype.to_s] || normalize_sport_type(tracktype.to_s)
+      end
+
+      def sport_type_name(id)
+        return nil if id.nil? || id.to_i.zero?
+        SPORT_TYPE_MAP[id.to_i]
+      end
+    end
+  end
+end

data/lib/git_fit/parser.rb

@@ -9,3 +9,4 @@ require_relative 'parser/base'
 require_relative 'parser/gpx'
 require_relative 'parser/tcx'
 require_relative 'parser/fit'
+require_relative 'parser/tbulu'

data/lib/git_fit/sync/garmin_base.rb

@@ -2,6 +2,7 @@
 
 require_relative 'base'
 require_relative '../fit/decoder'
+require_relative '../auth/paths'
 require 'ostruct'
 require 'base64'
 require 'oauth'
@@ -29,12 +30,17 @@ module GitFit
       OAUTH_CONSUMER_URL = 'https://thegarth.s3.amazonaws.com/oauth_consumer.json'
 
       SSO_HEADERS = {
-        'User-Agent' => 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
+        'User-Agent' => 'Mozilla/5.0 (iPhone; CPU iPhone OS 18_7 like Mac OS X) ' \
+                        'AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148',
         'Accept' => 'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
         'Accept-Language' => 'en-US,en;q=0.9',
       }.freeze
 
       def initialize(...)
+        if instance_of?(GarminBase)
+          raise NotImplementedError,
+                'GarminBase is abstract — instantiate a concrete subclass (Garmin, GarminCN)'
+        end
         super
         @domain = 'garmin.com'
         @email = @config['email']
@@ -53,19 +59,18 @@ module GitFit
       def authenticate
         @oauth_consumer = fetch_oauth_consumer
 
-        if @secret
-          if parse_secret_string(@secret)
-            if access_token_valid?
-              @auth_method = 'secret'
+        if @secret && parse_secret_string(@secret)
+          if access_token_valid?
+            @auth_method = 'secret'
+            return true
+          end
+          begin
+            if refresh_oauth2_via_oauth1
+              @auth_method = 'refreshed'
               return true
             end
-            begin
-              if refresh_oauth2_via_oauth1
-                @auth_method = 'refreshed'
-                return true
-              end
-            rescue AuthError
-            end
+          rescue AuthError => e
+            warn e.message
           end
         end
 
@@ -144,6 +149,14 @@ module GitFit
         attrs
       end
 
+      def self.source_prefix
+        raise NotImplementedError, "#{self} must implement source_prefix"
+      end
+
+      def source_prefix
+        self.class.source_prefix
+      end
+
       private
 
       def access_token_valid?
@@ -164,7 +177,7 @@ module GitFit
           oauth_token: o1['oauth_token'],
           oauth_token_secret: o1['oauth_token_secret'],
           mfa_token: o1['mfa_token'],
-          domain: @domain
+          domain: @domain,
         )
         @access_token = o2
         true
@@ -190,7 +203,7 @@ module GitFit
         return unless File.exist?(path)
 
         cfg = YAML.safe_load(File.read(path)) || {}
-        source = @domain == 'garmin.cn' ? 'garmin_cn' : 'garmin'
+        source = source_prefix
         cfg['sync'] ||= {}
         cfg['sync'][source] ||= {}
         cfg['sync'][source]['secret'] = @generated_secret
@@ -222,8 +235,8 @@ module GitFit
         save_tokens
         true
       rescue StandardError => e
-        raise AuthError, "Garmin OAuth refresh failed: #{e.message}" +
-          " — #{reauth_hint}"
+        raise AuthError, "Garmin OAuth refresh failed: #{e.message}" \
+                         " — #{reauth_hint}"
       end
 
       def fetch_oauth_consumer
@@ -258,16 +271,14 @@ module GitFit
             mfaVerificationCode: mfa_code,
             rememberMyBrowser: false,
             reconsentList: [],
-            mfaSetup: false
+            mfaSetup: false,
           )
           resp = sso_post(sso_base, '/mobile/api/mfa/verifyCode', login_params, mfa_body, jar)
           body = JSON.parse(resp.body)
           status = body.dig('responseStatus', 'type')
         end
 
-        unless status == 'SUCCESSFUL'
-          raise "Garmin login failed (#{body.dig("responseStatus", "message") || status})"
-        end
+        raise "Garmin login failed (#{body.dig('responseStatus', 'message') || status})" unless status == 'SUCCESSFUL'
 
         body['serviceTicketId']
       end
@@ -314,7 +325,8 @@ module GitFit
       def fetch_oauth1_token(ticket)
         base_url = "https://connectapi.#{@domain}/oauth-service/oauth/"
         login_url = "https://mobile.integration.#{@domain}/gcm/android"
-        url = "#{base_url}preauthorized?ticket=#{CGI.escape(ticket)}&login-url=#{CGI.escape(login_url)}&accepts-mfa-tokens=true"
+        url = "#{base_url}preauthorized?ticket=#{CGI.escape(ticket)}" \
+              "&login-url=#{CGI.escape(login_url)}&accepts-mfa-tokens=true"
 
         oauth_consumer = OAuth::Consumer.new(
           @oauth_consumer['consumer_key'], @oauth_consumer['consumer_secret'],
@@ -328,7 +340,7 @@ module GitFit
         req['User-Agent'] = 'com.garmin.android.apps.connectmobile'
         oauth_consumer.sign!(req, nil)
 
-        resp = retry_on_429(3, 5) { send_http(URI(url), req) }
+        resp = retry_on_rate_limit(3, 5) { send_http(URI(url), req) }
         raise "OAuth1 error: #{resp.code}" unless resp.code.to_i == 200
 
         parsed = CGI.parse(resp.body).transform_keys(&:to_s).transform_values(&:first)
@@ -337,7 +349,7 @@ module GitFit
           oauth_token: parsed['oauth_token'],
           oauth_token_secret: parsed['oauth_token_secret'],
           mfa_token: parsed['mfa_token'],
-          domain: @domain
+          domain: @domain,
         )
       end
 
@@ -359,7 +371,7 @@ module GitFit
         req.body = URI.encode_www_form(body_params)
         oauth_consumer.sign!(req, token)
 
-        resp = retry_on_429 { send_http(URI(url), req) }
+        resp = retry_on_rate_limit { send_http(URI(url), req) }
         raise "OAuth2 exchange error: #{resp.code}" unless resp.code.to_i == 200
 
         result = JSON.parse(resp.body)
@@ -374,7 +386,7 @@ module GitFit
 
       def existing_run_ids
         @db[:activities].where(source: source_prefix).select_map(:run_id)
-          .map { |id| id.sub("#{source_prefix}_", '') }
+                        .map { |id| id.sub("#{source_prefix}_", '') }
       end
 
       def fetch_activity_list(start, limit)
@@ -388,9 +400,9 @@ module GitFit
       def api_get(path)
         uri = URI("#{connectapi_base}#{path}")
         req = Net::HTTP::Get.new(uri)
-        req['Authorization'] = "Bearer #{@access_token["access_token"]}"
+        req['Authorization'] = "Bearer #{@access_token['access_token']}"
         req['User-Agent'] = 'GCM-iOS-5.22.1.4'
-        resp = retry_on_429 { send_http(uri, req) }
+        resp = retry_on_rate_limit { send_http(uri, req) }
         return nil unless resp.code.to_i == 200
         JSON.parse(resp.body)
       end
@@ -408,14 +420,14 @@ module GitFit
         http.start { |h| h.request(request) }
       end
 
-      def retry_on_429(max_retries = 3, base_delay = 2)
+      def retry_on_rate_limit(max_retries = 3, base_delay = 2)
         retries = 0
         loop do
           resp = yield
           return resp unless resp.code.to_i == 429 && retries < max_retries
 
           retries += 1
-          sleep(base_delay * (2 ** retries))
+          sleep(base_delay * (2**retries))
         end
       end
 
@@ -424,15 +436,17 @@ module GitFit
       end
 
       def resolve_local_time(start_utc, activity_id, polyline = nil)
-        lat = lng = nil
+        nil
 
         lat, lng = first_gps_from_l2(activity_id)
 
         if lat.nil? && polyline
-          decoded = GitFit::Geo::Polyline.decode(polyline) rescue nil
-          if decoded && decoded.any?
-            lat, lng = decoded.first
+          decoded = begin
+            GitFit::Geo::Polyline.decode(polyline)
+          rescue StandardError
+            nil
           end
+          lat, lng = decoded.first if decoded&.any?
         end
 
         tz_string = tz_resolver.resolve(lat, lng)
@@ -450,11 +464,11 @@ module GitFit
         l2 = JSON.parse(File.read(l2_path))
         return [nil, nil] unless l2.is_a?(Array) && l2.any?
 
-        first = l2.find { |r|
+        first = l2.find do |r|
           lat = r['positionLat']
           lng = r['positionLong']
           lat && lng && lat.to_f != 0.0 && lng.to_f != 0.0
-        }
+        end
         return [nil, nil] unless first
 
         [first['positionLat'].to_f, first['positionLong'].to_f]
@@ -462,10 +476,6 @@ module GitFit
         [nil, nil]
       end
 
-      def source_prefix
-        'garmin'
-      end
-
       def reauth_hint
         "Re-auth: set sync.#{source_prefix}.secret in config/config.yml"
       end
@@ -560,7 +570,7 @@ module GitFit
           oauth_token: o1['oauth_token'],
           oauth_token_secret: o1['oauth_token_secret'],
           mfa_token: o1['mfa_token'],
-          domain: @domain
+          domain: @domain,
         )
         @access_token = data['oauth2']
         @saved_expires_at = @access_token&.dig('expires_at')
@@ -571,7 +581,7 @@ module GitFit
       end
 
       def token_path
-        @config['token_path'] || File.join('data', 'auth', "garmin_#{@domain.tr(".", "_")}_tokens.json")
+        @config['token_path'] || GitFit::Auth.file(source_prefix, 'tokens.json')
       end
 
       FIT_EPOCH = 631_065_600
@@ -598,9 +608,9 @@ module GitFit
       def download_fit_raw(activity_id)
         uri = URI("#{connectapi_base}/download-service/files/activity/#{activity_id}")
         req = Net::HTTP::Get.new(uri)
-        req['Authorization'] = "Bearer #{@access_token.fetch("access_token")}"
+        req['Authorization'] = "Bearer #{@access_token.fetch('access_token')}"
         req['User-Agent'] = 'GCM-iOS-5.22.1.4'
-        resp = retry_on_429 { send_http(uri, req) }
+        resp = retry_on_rate_limit { send_http(uri, req) }
         return false unless resp.code.to_i == 200
 
         zip_data = resp.body
@@ -652,13 +662,13 @@ module GitFit
         nil
       end
 
-      def write_standardized_json(l2, activity_id)
-        return unless l2
+      def write_standardized_json(l2_data, activity_id)
+        return unless l2_data
 
         dir = std_dir
         FileUtils.mkdir_p(dir)
         tmp = File.join(dir, ".#{activity_id}.json.tmp")
-        File.write(tmp, JSON.generate(l2))
+        File.write(tmp, JSON.generate(l2_data))
         File.rename(tmp, std_path(activity_id))
       end
     end

data/lib/git_fit/sync/garmin_base_di.rb

@@ -5,6 +5,10 @@ require_relative 'garmin_base'
 module GitFit
   module Sync
     class GarminBaseDI < GarminBase
+      def self.source_prefix
+        'garmin'
+      end
+
       DI_CLIENT_IDS = %w[
         GARMIN_CONNECT_MOBILE_ANDROID_DI_2025Q2
         GARMIN_CONNECT_MOBILE_ANDROID_DI_2024Q4
@@ -131,10 +135,10 @@ module GitFit
         req.body = URI.encode_www_form(
           grant_type: 'refresh_token',
           client_id: client_id,
-          refresh_token: @access_token['refresh_token']
+          refresh_token: @access_token['refresh_token'],
         )
 
-        resp = retry_on_429 { send_http(uri, req) }
+        resp = retry_on_rate_limit { send_http(uri, req) }
         unless resp.code.to_i == 200
           msg = "DI refresh error: #{resp.code}"
           if resp.code.to_i == 400

data/lib/git_fit/sync/garmin_cn.rb

@@ -8,6 +8,10 @@ module GitFit
       register_adapter
       register_config :email, :password, :secret, :token_path
 
+      def self.source_prefix
+        'garmin_cn'
+      end
+
       def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil)
         super
         @domain = 'garmin.cn'
@@ -21,10 +25,6 @@ module GitFit
       def std_dir
         File.join('data', 'std', 'garmin_cn')
       end
-
-      def source_prefix
-        'garmin_cn'
-      end
     end
   end
 end

data/lib/git_fit/sync/{garmin.rb → garmin_com.rb}

@@ -4,15 +4,21 @@ require_relative 'garmin_base_di'
 
 module GitFit
   module Sync
-    class Garmin < GarminBaseDI
+    class GarminCom < GarminBaseDI
       register_adapter
-      register_config :email, :password, :secret, :auth_seed, :token_path
       config_key 'garmin'
+      register_config :email, :password, :secret, :auth_seed, :token_path
 
       def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil)
         super
         @domain = 'garmin.com'
       end
+
+      protected
+
+      def source_label
+        'Garmin'
+      end
     end
   end
 end

data/lib/git_fit/sync/xingzhe.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'base'
+require_relative '../auth/paths'
 require 'fileutils'
 require 'openssl'
 require 'tzinfo'
@@ -32,7 +33,7 @@ module GitFit
         super
         @email = @config['email']
         @password = @config['password']
-        @session_path = @config['session_path'] || File.join('data', 'cache', 'xingzhe_session.json')
+        @session_path = @config['session_path'] || GitFit::Auth.file('xingzhe', 'session.json')
       end
 
       def before_call

data/lib/git_fit/sync/xoss.rb

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require_relative 'base'
+require_relative '../auth/paths'
 require 'fileutils'
 require 'tzinfo'
 
@@ -32,7 +33,7 @@ module GitFit
         super
         @email = @config['email']
         @password = @config['password']
-        @token_path = @config['token_path'] || File.join('data', 'auth', 'xoss_tokens.json')
+        @token_path = @config['token_path'] || GitFit::Auth.file('xoss', 'tokens.json')
       end
 
       def before_call

data/lib/git_fit/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module GitFit
-  VERSION = '0.11.3'
+  VERSION = '0.13.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fit
 version: !ruby/object:Gem::Version
-  version: 0.11.3
+  version: 0.13.0
 platform: ruby
 authors:
 - Lax
@@ -252,6 +252,7 @@ files:
 - lib/git_fit/auth/garmin/strategy_a.rb
 - lib/git_fit/auth/garmin/strategy_b.rb
 - lib/git_fit/auth/garmin_token.rb
+- lib/git_fit/auth/paths.rb
 - lib/git_fit/auth/strava.rb
 - lib/git_fit/cli.rb
 - lib/git_fit/cli/checkpointable.rb
@@ -294,6 +295,7 @@ files:
 - lib/git_fit/import.rb
 - lib/git_fit/import/apple_health.rb
 - lib/git_fit/import/local_file.rb
+- lib/git_fit/import/tbulu.rb
 - lib/git_fit/install/actions.rb
 - lib/git_fit/install/actions/db-store/restore.yml.erb
 - lib/git_fit/install/actions/db-store/save.yml.erb
@@ -301,6 +303,7 @@ files:
 - lib/git_fit/parser/base.rb
 - lib/git_fit/parser/fit.rb
 - lib/git_fit/parser/gpx.rb
+- lib/git_fit/parser/tbulu.rb
 - lib/git_fit/parser/tcx.rb
 - lib/git_fit/privacy/polyline_filter.rb
 - lib/git_fit/source.rb
@@ -310,10 +313,10 @@ files:
 - lib/git_fit/std/resolver.rb
 - lib/git_fit/strava_web/file_check.rb
 - lib/git_fit/sync/base.rb
-- lib/git_fit/sync/garmin.rb
 - lib/git_fit/sync/garmin_base.rb
 - lib/git_fit/sync/garmin_base_di.rb
 - lib/git_fit/sync/garmin_cn.rb
+- lib/git_fit/sync/garmin_com.rb
 - lib/git_fit/sync/igpsport.rb
 - lib/git_fit/sync/keep.rb
 - lib/git_fit/sync/lorem.rb