git-fit 0.6.1 → 0.7.1

data/lib/git_fit/sync/garmin_base_di.rb

@@ -0,0 +1,186 @@
+require_relative "garmin_base"
+require "open3"
+
+module GitFit
+  module Sync
+    class GarminBaseDI < GarminBase
+      DI_CLIENT_IDS = %w[
+        GARMIN_CONNECT_MOBILE_ANDROID_DI_2025Q2
+        GARMIN_CONNECT_MOBILE_ANDROID_DI_2024Q4
+        GARMIN_CONNECT_MOBILE_ANDROID_DI
+      ].freeze
+
+      def authenticate
+        @oauth_consumer = fetch_oauth_consumer
+
+        if load_tokens
+          return true if access_token_valid?
+          begin
+            return true if refresh_token
+          rescue AuthError
+            remove_stale_tokens
+          end
+        end
+
+        if load_auth_seed
+          return true if access_token_valid?
+          begin
+            return true if refresh_token
+          rescue AuthError
+            @access_token = nil
+          end
+        end
+
+        puts "Garmin: no valid DI token found"
+        puts "  First time: ./scripts/garmin_auth_local.sh"
+        puts "  Refresh:    ./scripts/garmin_auth_local.sh --sync"
+        false
+      end
+
+      def before_call
+        if @config["auth_seed"].to_s.empty? && !File.exist?(token_path)
+          puts "Garmin: auth_seed not configured and no cached token"
+          puts "  Run: ./scripts/garmin_auth_local.sh"
+          return false
+        end
+        @start_time = Time.now
+        true
+      end
+
+      def reauth_hint
+        "Re-auth: ./scripts/garmin_auth_local.sh --sync"
+      end
+
+      private
+
+      def auth_base
+        "https://diauth.#{@domain}"
+      end
+
+      def load_tokens
+        path = token_path
+        return false unless File.exist?(path)
+
+        data = JSON.parse(File.read(path))
+        @access_token = data
+        true
+      rescue => e
+        puts "Failed to load Garmin tokens: #{e.message}"
+        false
+      end
+
+      def save_tokens
+        return unless @access_token&.dig("access_token")
+
+        path = token_path
+        FileUtils.mkdir_p(File.dirname(path))
+        File.write(path, JSON.pretty_generate(@access_token))
+      rescue => e
+        puts "Failed to save Garmin tokens: #{e.message}"
+      end
+
+      def remove_stale_tokens
+        path = token_path
+        File.delete(path) if File.exist?(path)
+      rescue => e
+        puts "Warning: failed to remove stale tokens: #{e.message}"
+      end
+
+      def load_auth_seed
+        seed = @config["auth_seed"]
+        return false unless seed && !seed.empty?
+
+        decoded = JSON.parse(Base64.strict_decode64(seed))
+        @access_token = decoded
+        save_tokens
+        true
+      rescue JSON::ParserError
+        puts "Garmin: auth_seed decode failed — invalid Base64 or JSON"
+        puts "  Fix: ./scripts/garmin_auth_local.sh --sync"
+        false
+      rescue => e
+        puts "Garmin: auth_seed error: #{e.message}"
+        false
+      end
+
+      def refresh_token
+        return false unless @access_token&.dig("refresh_token")
+
+        client_id = @access_token["di_client_id"] || DI_CLIENT_IDS.first
+        basic = Base64.strict_encode64("#{client_id}:")
+
+        uri = URI("#{auth_base}/di-oauth2-service/oauth/token")
+        req = Net::HTTP::Post.new(uri)
+        req["Authorization"] = "Basic #{basic}"
+        req["Content-Type"] = "application/x-www-form-urlencoded"
+        req["Cache-Control"] = "no-cache"
+        req["User-Agent"] = "GCM-Android-5.23"
+        req.body = URI.encode_www_form(
+          grant_type: "refresh_token",
+          client_id: client_id,
+          refresh_token: @access_token["refresh_token"]
+        )
+
+        resp = retry_on_429 { send_http(uri, req) }
+        unless resp.code.to_i == 200
+          msg = "DI refresh error: #{resp.code}"
+          if resp.code.to_i == 400
+            msg += " — refresh_token expired across rotation"
+            msg += ", re-run: scripts/garmin_auth_local.sh"
+          elsif resp.code.to_i == 401
+            msg += " — DI client_id rotated by Garmin"
+            msg += ", re-run: scripts/garmin_auth_local.sh"
+          end
+          raise AuthError, msg
+        end
+
+        result = JSON.parse(resp.body)
+        result["expires_at"] = Time.now.to_i + (result["expires_in"] || 64800).to_i
+        if result["refresh_token_expires_in"]
+          result["refresh_token_expires_at"] = Time.now.to_i + result["refresh_token_expires_in"].to_i
+        end
+        @access_token = result
+        save_tokens
+        true
+      end
+
+      # @deprecated Kept for local script reference only.
+      # email+password SSO strategies are not called by `authenticate`
+      # because garmin.com DI auth requires MFA, handled by
+      # scripts/garmin_auth_local.sh outside Ruby.
+      #
+      # Note: method naming (strategy_a = curl_cffi, strategy_b = Playwright) is
+      # historical. In scripts/garmin_auth_local.sh, Playwright runs first (cookies
+      # persist 365d → no repeat MFA), curl_cffi is the fallback.
+      def strategy_a_login
+        script = File.expand_path("../../../scripts/garmin_auth.py", __dir__)
+        return nil unless File.exist?(script)
+
+        stdout, stderr, status = Open3.capture3(
+          {"SYNC__GARMIN__EMAIL" => @email, "SYNC__GARMIN__PASSWORD" => @password, "SYNC__GARMIN__DOMAIN" => @domain},
+          "python3", script
+        )
+        warn stderr unless stderr.empty?
+        JSON.parse(stdout) if status.success?
+      rescue => e
+        puts "Strategy A (curl_cffi) failed: #{e.message}"
+        nil
+      end
+
+      def strategy_b_login
+        script = File.expand_path("../../../scripts/garmin_auth_playwright.py", __dir__)
+        return nil unless File.exist?(script)
+
+        stdout, stderr, status = Open3.capture3(
+          {"SYNC__GARMIN__EMAIL" => @email, "SYNC__GARMIN__PASSWORD" => @password, "SYNC__GARMIN__DOMAIN" => @domain},
+          "python3", script
+        )
+        warn stderr unless stderr.empty?
+        JSON.parse(stdout) if status.success?
+      rescue => e
+        puts "Strategy B (Playwright) failed: #{e.message}"
+        nil
+      end
+    end
+  end
+end

data/lib/git_fit/sync/garmin_cn.rb

@@ -0,0 +1,29 @@
+require_relative "garmin_base"
+
+module GitFit
+  module Sync
+    class GarminCN < GarminBase
+      register_adapter
+      register_config :email, :password, :secret
+      config_key "garmin_cn"
+
+      def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil)
+        super
+        @domain = "garmin.cn"
+        @ssl_verify = config.key?("ssl_verify") ? config["ssl_verify"] : false
+      end
+
+      def raw_dir
+        File.join("data", "raw", "garmin_cn")
+      end
+
+      def std_dir
+        File.join("data", "std", "garmin_cn")
+      end
+
+      def source_prefix
+        "garmin_cn"
+      end
+    end
+  end
+end

data/lib/git_fit/sync/igpsport.rb

@@ -0,0 +1,225 @@
+require_relative "base"
+require "faraday"
+
+module GitFit
+  module Sync
+    class IGPSPORT < Base
+      BASE_URL = "https://prod.zh.igpsport.com/service"
+      LOGIN_URL = "#{BASE_URL}/auth/account/login"
+      QUERY_URL = "#{BASE_URL}/web-gateway/web-analyze/activity/queryMyActivity"
+      DOWNLOAD_URL = "#{BASE_URL}/web-gateway/web-analyze/activity/getDownloadUrl"
+
+      EXERCISE_MAP = {
+        0 => "ride", 1 => "run", 2 => "hike", 3 => "walk",
+        4 => "swim", 5 => "ski", 6 => "workout"
+      }.freeze
+
+      RAW_EXT = "fit"
+
+      register_adapter
+      register_config :phone, :password
+
+      def initialize(...)
+        super
+        @phone = @config["phone"]
+        @password = @config["password"]
+      end
+
+      def before_call
+        return false if @phone.nil? || @password.nil?
+        super
+      end
+
+      def authenticate
+        login
+      end
+
+      def pending_ids
+        existing = existing_run_ids
+        ids = []
+        page = 1
+        loop do
+          acts = fetch_page(page)
+          break if acts.nil? || acts.empty?
+          acts.each do |act|
+            ride_id = act["rideId"].to_s
+            next if existing.include?(ride_id) && raw_file_exists?(ride_id)
+            type = map_sport(act["exerciseType"])
+            next if skip_type?(type)
+            ids << { id: ride_id, type: type, summary: act }
+          end
+          page += 1
+        end
+        ids
+      end
+
+      def process_one(pending)
+        sync_activity(pending[:summary], pending[:id])
+      end
+
+      private
+
+      def login
+        resp = Faraday.post(LOGIN_URL,
+          JSON.generate({ appId: "igpsport-web", username: @phone, password: @password }),
+          { "Content-Type" => "application/json" }
+        )
+        return false unless resp.status == 200
+        data = JSON.parse(resp.body)
+        @token = data.dig("data", "access_token")
+        return false unless @token
+        @auth_headers = { "Authorization" => "Bearer #{@token}" }
+        true
+      end
+
+      def sync_activities
+        pending_ids.filter_map { |p| process_one(p) }.size
+      end
+
+      def sync_activity(act, ride_id)
+        url = get_download_url(ride_id)
+        return false unless url
+
+        download_fit(url, ride_id)
+
+        fit_path = raw_path(ride_id)
+        return false unless File.exist?(fit_path)
+
+        wgs_points = FIT::Decoder.decode(fit_path)
+        return false if wgs_points.empty?
+
+        first_ts = wgs_points.first["timestamp"]
+        if first_ts
+          fit_epoch = Time.new(1989, 12, 31, 0, 0, 0, "+00:00").to_i
+          t = Time.at(fit_epoch + first_ts)
+          @fit_start_utc = t.utc
+          @fit_start_local = t.getlocal("+08:00")
+        end
+
+        write_standardized_json(wgs_points, ride_id)
+        polyline = Geo::Polyline.encode(wgs_points.map { |pt| [pt["positionLat"], pt["positionLong"]] })
+        sensor_summary = compute_sensor_summary(wgs_points)
+
+        attrs = build_attrs(act, ride_id, polyline, sensor_summary)
+        return false unless attrs
+
+        upsert_activity(attrs)
+        attrs
+      end
+
+      def get_download_url(ride_id)
+        resp = Faraday.get("#{DOWNLOAD_URL}/#{ride_id}", {}, @auth_headers)
+        return nil unless resp.status == 200
+        JSON.parse(resp.body)["data"]
+      end
+
+      def download_fit(url, ride_id)
+        resp = Faraday.get(url)
+        return false unless resp.status == 200
+
+        write_source_archive(resp.body, ride_id, RAW_EXT)
+        true
+      end
+
+      def fit_to_polyline(ride_id)
+        fit_path = raw_path(ride_id)
+        return nil unless File.exist?(fit_path)
+
+        wgs_points = FIT::Decoder.decode(fit_path)
+        return nil if wgs_points.empty?
+
+        Geo::Polyline.encode(wgs_points.map { |pt| [pt["positionLat"], pt["positionLong"]] })
+      end
+
+      def write_standardized_json(wgs_points, ride_id)
+        dir = std_dir
+        FileUtils.mkdir_p(dir)
+        tmp = File.join(dir, ".#{ride_id}.json.tmp")
+        final = File.join(dir, "#{ride_id}.json")
+        File.write(tmp, JSON.generate(wgs_points))
+        File.rename(tmp, final)
+      end
+
+      def fetch_page(page)
+        resp = Faraday.get(QUERY_URL,
+          { pageNo: page, pageSize: 20, sort: 1, reqType: 0 },
+          @auth_headers
+        )
+        return nil unless resp.status == 200
+        JSON.parse(resp.body).dig("data", "rows")
+      end
+
+      def build_attrs(act, ride_id, polyline = nil, sensor = {})
+        type = map_sport(act["exerciseType"])
+        start_t = @fit_start_utc || parse_date(act["startTime"])
+        start_t_local = @fit_start_local || start_t
+        distance = act["rideDistance"].to_f
+        moving_time = (act["totalMovingTime"] || act["recordTime"]).to_i
+        avg_speed = act["avgSpeed"].to_f
+
+        {
+          run_id: "igpsport_#{ride_id}",
+          name: act["title"] || "iGPSPORT Activity",
+          distance: distance,
+          moving_time: moving_time > 0 ? moving_time : nil,
+          elapsed_time: moving_time > 0 ? moving_time : nil,
+          sport_category: type,
+          sport_type: EXERCISE_MAP[act["exerciseType"]] || "ride",
+          start_date: start_t.iso8601,
+          start_date_local: start_t_local.iso8601,
+          location_country: nil,
+          average_heartrate: act["avgHrm"]&.to_f&.nonzero?,
+          max_heartrate: act["maxHrm"]&.to_f&.nonzero?,
+          average_cadence: sensor[:average_cadence],
+          max_cadence: sensor[:max_cadence],
+          average_power: sensor[:average_power],
+          max_power: sensor[:max_power],
+          calories: sensor[:calories],
+          average_temperature: sensor[:average_temperature],
+          average_speed: avg_speed > 0 ? avg_speed : nil,
+          elevation_gain: act["totalAscent"].to_f.nonzero?,
+          summary_polyline: polyline,
+          source: "igpsport"
+        }
+      end
+
+      def compute_sensor_summary(records)
+        return {} if records.empty?
+
+        cad = records.map { |r| r["cadence"] }.compact
+        pow = records.map { |r| r["power"] }.compact
+        tmp = records.map { |r| r["temperature"] }.compact
+
+        {
+          average_cadence: cad.any? ? (cad.sum.to_f / cad.size).round(1) : nil,
+          max_cadence: cad.max,
+          average_power: pow.any? ? (pow.sum.to_f / pow.size).round(1) : nil,
+          max_power: pow.max,
+          average_temperature: tmp.any? ? (tmp.sum.to_f / tmp.size).round(1) : nil,
+          calories: nil
+        }
+      end
+
+      def map_sport(exercise_type)
+        EXERCISE_MAP[exercise_type] || "other"
+      end
+
+      def parse_date(str)
+        return nil unless str
+        normalized = str.to_s.tr(".", "-")
+        Time.parse(normalized)
+      rescue
+        nil
+      end
+
+      def existing_run_ids
+        @db[:activities].where(source: "igpsport").select_map(:run_id)
+          .map { |id| id.sub("igpsport_", "") }
+      end
+
+      def raw_path(platform_id)
+        File.join(raw_dir, "#{platform_id}.#{RAW_EXT}")
+      end
+    end
+  end
+end