git-fit 0.23.2 → 0.24.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9f0c03193a95a9f5f4b02aaf515cad3b547e57c82201359d1a9cbd2194261ccf
-  data.tar.gz: ba4acbff8c51f343c0641a265c3e75356830864e48e93abd8c24054602762745
+  metadata.gz: 91c3d0ac4cecce476fb6ca55ac9d42b2f0cf5159d52f51df9551aa511ce20108
+  data.tar.gz: b8ea24629e8e92424084edfe441588ad478fdc3388f8763d299c88ddc9a73e2d
 SHA512:
-  metadata.gz: 57640bd7dc13d63da72f616a50cd48f9bd9a903f4cadf3edf1321f2344410859641f44d50701ac26da1622c3bdc460a6d639a94564c1da7a7862dccd6b9c8c65
-  data.tar.gz: 80ee63c140618207ab471327f3673daed9d2ed211f104dd9442484758f085a2420290756187dadb6d521575abf50b5832edfcb24911db633e620fbf5c207c4e0
+  metadata.gz: a86c69332d9dc3474a2f8984e900f8f84be6cce1b6a9f3262a103d9e153407935575e4f32a697906f3947d0e86f947e075abd3961014bab525b0e267bdc2b466
+  data.tar.gz: c84de3d8dc16989789e2b69c477b5f9500f51e048ac51f4cd4cbe19aefc5944669ed96c3ef192f6ff4bfbd80a31168b33da043472aabd71449150812252bcd24

data/lib/git-fit.rb

@@ -69,6 +69,8 @@ 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'
+require_relative 'git_fit/sync/codoon'
+require_relative 'git_fit/sync/joyrun'
 require_relative 'git_fit/sync/igpsport'
 require_relative 'git_fit/sync/xoss'
 require_relative 'git_fit/sync/xingzhe'

data/lib/git_fit/cli/sync.rb

@@ -32,19 +32,24 @@ module GitFit
       end
 
       def auth(source)
-        sources = %w[garmin garmin_cn strava]
+        sources = %w[garmin garmin_cn strava joyrun]
         unless sources.include?(source)
           say_status :error, "Supported: #{sources.join(', ')}", :red
           return
         end
 
         config = git_fit_config.sync_config(source)
-        if config.empty?
+        if source == 'joyrun'
+          config = config.merge(
+            'phone' => options[:phone],
+            'sms_code' => options[:sms_code],
+          )
+        elsif config.empty?
           say_status :warn, "No config for #{source}. Set env vars or config.yml", :yellow
           return
         end
 
-        adapter = build_auth_adapter(source)
+        adapter = build_auth_adapter(source, config: config, interactive_auth: source == 'joyrun')
         unless adapter.respond_to?(:authenticate)
           say_status :error, "#{source} does not support interactive auth", :red
           return
@@ -63,6 +68,10 @@ module GitFit
             puts 'Local config:'
             puts "  #{source}:"
             puts "    secret: (已自动写入 #{GitFit::Config.default_path})"
+          elsif adapter.respond_to?(:generated_secrets) && (secrets = adapter.generated_secrets)
+            puts ''
+            puts 'GitHub Actions Secrets:'
+            secrets.each { |name, value| puts "  SYNC_JOYRUN_#{name} = #{value}" }
           end
         else
           say_status :error, 'Authentication failed', :red
@@ -73,13 +82,13 @@ module GitFit
 
       private
 
-      def build_auth_adapter(source)
+      def build_auth_adapter(source, config: nil, interactive_auth: false)
         klass = GitFit::Sync::Base.adapters.find { |a| a.config_key == source }
         return nil unless klass
 
-        cfg = git_fit_config.sync_config(source).dup
+        cfg = (config || git_fit_config.sync_config(source)).dup
         cfg['config_path'] = options[:config] if options[:config]
-        klass.new(config: cfg, db: nil)
+        klass.new(config: cfg, db: nil, interactive_auth: interactive_auth)
       end
     end
   end

data/lib/git_fit/cli.rb

@@ -76,12 +76,14 @@ module GitFit
       super
     end
 
-    desc 'auth SOURCE', 'Authenticate with a sync source (strava, garmin, garmin_cn)'
+    desc 'auth SOURCE', 'Authenticate with a sync source (strava, garmin, garmin_cn, joyrun)'
     option :A, type: :boolean, desc: 'Garmin Strategy A: curl-impersonate shellout'
     option :B, type: :boolean, desc: 'Garmin Strategy B: Playwright'
     option :auto, type: :boolean, desc: 'Garmin auto: B first, fallback to A (default)'
     option :sync, type: :boolean, desc: 'Garmin: promote cached token to auth_seed'
     option :mfa_code, type: :string, desc: 'Garmin MFA code (from email), re-run to continue'
+    option :phone, type: :string, desc: 'Joyrun phone number'
+    option :sms_code, type: :string, desc: 'Joyrun SMS code'
     def auth(source)
       if source == 'garmin'
         GitFit::Auth::Garmin.new(options, git_fit_config).call

data/lib/git_fit/config_template.rb

@@ -35,6 +35,14 @@ module GitFit
           #   phone: ""                                # env: GIT_FIT_KEEP_PASSWORD
           #   password: ""
 
+          # codoon:                                    # env: GIT_FIT_CODOON_PHONE
+          #   phone: ""                                # env: GIT_FIT_CODOON_PASSWORD
+          #   password: ""
+
+          # joyrun:                                    # env: GIT_FIT_JOYRUN_UID
+          #   uid: ""
+          #   sid: ""                                  # env: GIT_FIT_JOYRUN_SID / git fit auth joyrun
+
           # igpsport:                                  # env: GIT_FIT_IGPSPORT_PHONE
           #   phone: ""                                # env: GIT_FIT_IGPSPORT_PASSWORD
           #   password: ""

data/lib/git_fit/elevation/backfill.rb

@@ -3,7 +3,7 @@
 module GitFit
   module Elevation
     class Backfill
-      SOURCES = %w[igpsport xoss strava garmin garmin_cn xingzhe keep].freeze
+      SOURCES = %w[igpsport xoss strava garmin garmin_cn xingzhe keep codoon joyrun].freeze
       BATCH_SIZE = 100
 
       def initialize(db, force: false)
@@ -63,6 +63,7 @@ module GitFit
                when 'strava' then compute_from_l2(source, natural_id)
                when 'xingzhe' then compute_from_xingzhe(natural_id)
                when 'keep' then compute_from_keep(natural_id)
+               when 'codoon', 'joyrun' then compute_from_std(source, natural_id)
                else return
                end
 
@@ -105,6 +106,27 @@ module GitFit
         nil
       end
 
+      def compute_from_std(source, natural_id)
+        l2_path = File.join('data', 'std', source, "#{natural_id}.json")
+        return nil unless File.exist?(l2_path)
+
+        l2 = JSON.parse(File.read(l2_path))
+        return nil unless l2.is_a?(Array)
+
+        alts = l2.filter_map { |point| point['altitude']&.to_f if point.is_a?(Hash) }
+        return nil if alts.size < 2
+
+        {
+          elevation_gain: elevation_gain_from_alts(alts, threshold: 3.0).round(1),
+          elevation_loss: elevation_loss_from_alts(alts, threshold: 3.0).round(1),
+          elevation_min: alts.min&.round(1),
+          elevation_max: alts.max&.round(1),
+        }
+      rescue StandardError => e
+        warn "Elevation backfill [#{source}][#{natural_id}]: #{e.message}"
+        nil
+      end
+
       def compute_from_keep(natural_id)
         l2_path = File.join('data', 'std', 'keep', "#{natural_id}.json")
         return nil unless File.exist?(l2_path)

data/lib/git_fit/elevation/correct.rb

@@ -6,7 +6,7 @@ module GitFit
     # threshold → activities.elevation_*_terrain. Raw device/API values stay in
     # elevation_* (written by Backfill); this class only fills the _terrain columns.
     class Correct
-      SOURCES = %w[garmin garmin_cn strava keep igpsport xoss xingzhe 2bulu apple_health].freeze
+      SOURCES = %w[garmin garmin_cn strava keep igpsport xoss xingzhe 2bulu apple_health codoon joyrun].freeze
       BARO_SOURCES = %w[xingzhe 2bulu apple_health].freeze
       BATCH_SIZE = 100
       STATIC_HYST_BARO = 2.0

data/lib/git_fit/std/resolver.rb

@@ -5,7 +5,7 @@ module GitFit
     module Resolver
       # garmin_cn 必须排在 garmin 前面："garmin_cn_7".start_with?("garmin_") == true
       SOURCE_PREFIXES = %w[
-        garmin_cn garmin strava keep igpsport xoss xingzhe
+        garmin_cn garmin strava keep igpsport xoss xingzhe codoon joyrun
         apple_health gpx fit tcx
       ].freeze
 

data/lib/git_fit/sync/codoon.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'cgi'
+require 'openssl'
+require 'time'
+
+module GitFit
+  module Sync
+    class Codoon < Base
+      BASE_URL = 'https://api.codoon.com'
+      TOKEN_PATH = '/token'
+      LIST_PATH = '/api/get_old_route_log'
+      DETAIL_PATH = '/api/get_single_log'
+      BASIC_AUTH = 'MDk5Y2NlMjhjMDVmNmMzOWFkNWUwNGU1MWVkNjA3MDQ6YzM5ZDNmYmVhMWU4NWJlY2VlNDFjMTk5N2FjZjBlMzY='
+      CLIENT_ID = '099cce28c05f6c39ad5e04e51ed60704'
+      SIGNATURE_KEY = 'ecc140ad6e1e12f7d972af04add2c7ee'
+      DID = '24-ffffffff-faac-3052-0033-c5870033c587'
+      USER_AGENT = 'CodoonSport(8.9.0 1170;Android 7;Sony XZ1)'
+      PAGE_SIZE = 500
+      CHINA_OFFSET = '+08:00'
+
+      SPORT_MAP = { 0 => 'hike', 1 => 'run', 2 => 'ride' }.freeze
+
+      register_adapter
+      register_config :phone, :password
+
+      def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil)
+        super
+        @phone = @config['phone']
+        @password = @config['password']
+        @access_token = nil
+        @user_id = nil
+        @last_http_code = nil
+      end
+
+      def before_call
+        return credentials_missing unless credentials_present?
+
+        super
+      end
+
+      def authenticate
+        params = {
+          'client_id' => CLIENT_ID,
+          'email' => @phone,
+          'grant_type' => 'password',
+          'password' => @password,
+          'scope' => 'user',
+        }
+        resp = http_request(:get, TOKEN_PATH, params: params)
+        data = parse_json(resp)
+        valid_login = resp.code.to_i == 200 && data.is_a?(Hash) &&
+                      data['access_token'].is_a?(String) && !data['access_token'].empty? &&
+                      !data['user_id'].nil?
+        return login_failed(resp, data) unless valid_login
+
+        @access_token = data['access_token']
+        @user_id = data['user_id'].to_s
+        @auth_method = 'login'
+        true
+      rescue StandardError => e
+        warn "Codoon: login failed: #{e.message}\n  Fix: 检查 GIT_FIT_CODOON_PHONE/PASSWORD"
+        false
+      end
+
+      def pending_ids
+        existing = existing_run_ids
+        ids = []
+        page = 1
+        loop do
+          items, has_more = fetch_page(page)
+          break if items.nil? || items.empty?
+
+          items.each do |item|
+            id = item['log_id'].to_s
+            next if id.empty?
+
+            type = map_sport(item['sports_type'])
+            next if skip_type?(type)
+
+            has_raw = raw_file_exists?(id)
+            next if existing.include?(id) && has_raw
+
+            ids << { id: id, route_id: item['route_id'].to_s, type: type, has_raw: has_raw }
+          end
+          page += 1
+          break unless has_more
+        end
+        ids
+      end
+
+      def process_one(pending)
+        return load_raw_activity(pending[:id]) if pending[:has_raw]
+
+        resp = http_request(:post, DETAIL_PATH, body: { route_id: pending[:route_id] },
+                                                token: @access_token)
+        data = parse_json(resp)
+        return false unless resp.code.to_i == 200 && data.is_a?(Hash) && data['data'].is_a?(Hash)
+
+        write_source_archive(data, pending[:id])
+        upsert_from_detail(pending[:id], data['data'])
+      end
+
+      def self.signature(auth, path_with_query, body: '', timestamp: 0, key: nil)
+        path, query = path_with_query.split('?', 2)
+        query = URI.decode_www_form_component(query.to_s)
+        message = "Authorization=#{auth}&Davinci=0&Did=#{DID}&Timestamp=#{timestamp}" \
+                  "|path=#{path}|body=#{body}|#{query}"
+        key ||= SIGNATURE_KEY
+        Base64.strict_encode64(OpenSSL::HMAC.digest('sha1', key, message))
+      end
+
+      private
+
+      def fetch_page(page)
+        resp = http_request(:post, LIST_PATH,
+                            body: { limit: PAGE_SIZE, page: page, user_id: @user_id },
+                            token: @access_token)
+        data = parse_json(resp)
+        return [[], false] unless resp.code.to_i == 200 && data.is_a?(Hash) && data['data'].is_a?(Hash)
+
+        [Array(data.dig('data', 'log_list')), data.dig('data', 'has_more') ? true : false]
+      end
+
+      def http_request(method, path, params: nil, body: nil, token: nil)
+        uri = URI.join(BASE_URL, path)
+        uri.query = URI.encode_www_form(params) if params
+        json_body = body ? JSON.generate(body) : ''
+        timestamp = method == :get ? 0 : Time.now.to_i
+        auth = token ? "Bearer #{token}" : "Basic #{BASIC_AUTH}"
+
+        request = method == :get ? Net::HTTP::Get.new(uri) : Net::HTTP::Post.new(uri)
+        request['User-Agent'] = USER_AGENT
+        request['did'] = DID
+        request['davinci'] = '0'
+        request['authorization'] = auth
+        request['timestamp'] = timestamp.to_s
+        request['signature'] = self.class.signature(auth, uri.request_uri, body: json_body, timestamp: timestamp)
+        unless method == :get
+          request['Content-Type'] =
+            token ? 'application/json; charset=utf-8' : 'application/x-www-form-urlencode; charset=utf-8'
+          request.body = json_body
+        end
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.open_timeout = 30
+        http.read_timeout = 60
+        response = http.start { |client| client.request(request) }
+        @last_http_code = response.code.to_i
+        response
+      end
+
+      def load_raw_activity(id)
+        data = JSON.parse(File.read(raw_path(id)))
+        detail = data['data']
+        return false unless detail.is_a?(Hash)
+
+        upsert_from_detail(id, detail)
+      end
+
+      def upsert_from_detail(log_id, detail)
+        attrs = build_activity(log_id, detail)
+        return false unless attrs
+
+        points = attrs.delete(:standard_points)
+        write_std(points, log_id)
+        upsert_activity(attrs)
+        attrs
+      end
+
+      def build_activity(log_id, detail)
+        start_time = parse_beijing_time(detail['start_time'])
+        end_time = parse_beijing_time(detail['end_time'])
+        moving_time = detail['total_time'].to_i
+        return nil unless start_time && moving_time.positive?
+
+        points = standard_points(detail['points'])
+        return nil if points.empty?
+
+        hr_values = heart_rate_values(detail['heart_rate'])
+        cadence_values = cadence_values(detail)
+        distance = detail['total_length'].to_f
+        elapsed = end_time ? [(end_time - start_time).round, 0].max : moving_time
+        sport = map_sport(detail['sports_type'])
+
+        official_cadence = numeric(detail['average_step_cadence'])
+        attrs = {
+          run_id: "codoon_#{log_id}",
+          name: "#{sport.capitalize} from Codoon",
+          distance: distance.positive? ? distance : nil,
+          moving_time: moving_time,
+          elapsed_time: elapsed,
+          sport_category: sport,
+          sport_type: detail['sports_type'].to_s,
+          start_date: Time.at(start_time.to_i).utc.iso8601,
+          start_date_local: start_time.iso8601,
+          average_heartrate: average(hr_values),
+          max_heartrate: hr_values.max,
+          average_cadence: official_cadence&.positive? ? official_cadence : average(cadence_values),
+          max_cadence: cadence_values.max,
+          calories: numeric(detail['total_calories'])&.round,
+          average_speed: distance.positive? && moving_time.positive? ? (distance / moving_time).round(2) : nil,
+          source: 'codoon',
+        }
+        attrs.merge!(point_attributes(points))
+        attrs[:standard_points] = points
+        attrs
+      end
+
+      def point_attributes(points)
+        return { summary_polyline: nil } if points.empty?
+
+        alts = points.filter_map { |point| numeric(point[:altitude]) }
+        {
+          summary_polyline: Geo::Polyline.encode(points.map { |point| [point[:latitude], point[:longitude]] }),
+          elevation_gain: elevation_delta(alts, :gain),
+          elevation_loss: elevation_delta(alts, :loss),
+          elevation_min: alts.min&.round(1),
+          elevation_max: alts.max&.round(1),
+        }
+      end
+
+      def standard_points(points)
+        Array(points).filter_map do |point|
+          lat = numeric(point['latitude'])
+          lng = numeric(point['longitude'])
+          point_time = parse_beijing_time(point['time_stamp'])
+          next unless lat && lng
+          next unless point_time
+
+          lat, lng = Geo::CoordTransform.gcj02_to_wgs84_exact(lat, lng)
+          {
+            latitude: lat.round(7),
+            longitude: lng.round(7),
+            altitude: numeric(point['elevation']),
+            timestamp: Time.at(point_time.to_i).utc.iso8601,
+          }
+        end
+      end
+
+      def heart_rate_values(values)
+        return [] unless values.is_a?(Hash)
+
+        values.values.filter_map { |value| hr_value(value) }
+      end
+
+      def cadence_values(detail)
+        Array(detail['user_steps_list_perm']).filter_map do |entry|
+          value = entry.is_a?(Array) ? entry[1] : entry['value'] || entry['step']
+          value = numeric(value)
+          value if value&.positive?
+        end
+      end
+
+      def hr_value(value)
+        value = numeric(value)
+        value if value&.positive?
+      end
+
+      def parse_beijing_time(value)
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        Time.parse("#{value.to_s.sub(/\.\d+\z/, '')}#{CHINA_OFFSET}")
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def map_sport(value)
+        SPORT_MAP[numeric(value)&.to_i] || 'other'
+      end
+
+      def credentials_present?
+        [@phone, @password].all? { |value| value.is_a?(String) && !value.empty? }
+      end
+
+      def credentials_missing
+        warn "Codoon: credentials not configured\n  Fix: 检查 GIT_FIT_CODOON_PHONE/PASSWORD"
+        false
+      end
+
+      def login_failed(resp, data)
+        reason = data.is_a?(Hash) ? data['description'] || data['error'] : nil
+        detail = reason ? ": #{reason}" : ''
+        warn "Codoon: login failed (HTTP #{resp.code}#{detail})\n  Fix: 检查 GIT_FIT_CODOON_PHONE/PASSWORD"
+        false
+      end
+
+      def parse_json(resp)
+        JSON.parse(resp.body)
+      rescue JSON::ParserError, TypeError
+        nil
+      end
+
+      def numeric(value)
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        Float(value)
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def average(values)
+        return nil if values.empty?
+
+        (values.sum.to_f / values.size).round(1)
+      end
+
+      def elevation_delta(altitudes, direction)
+        return nil if altitudes.size < 2
+
+        total = 0.0
+        (1...altitudes.size).each do |index|
+          delta = altitudes[index] - altitudes[index - 1]
+          total += delta if direction == :gain && delta.positive?
+          total -= delta if direction == :loss && delta.negative?
+        end
+        total.round(1)
+      end
+
+      def raw_path(platform_id)
+        File.join(raw_dir, "#{platform_id}.json")
+      end
+
+      def write_std(points, platform_id)
+        dir = std_dir
+        FileUtils.mkdir_p(dir)
+        tmp = File.join(dir, ".#{platform_id}.json.tmp")
+        final = File.join(dir, "#{platform_id}.json")
+        File.write(tmp, JSON.generate(points))
+        File.rename(tmp, final)
+      end
+    end
+  end
+end

data/lib/git_fit/sync/joyrun.rb

@@ -0,0 +1,429 @@
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'digest'
+require 'time'
+
+module GitFit
+  module Sync
+    class Joyrun < Base
+      BASE_URL = 'https://api.thejoyrun.com'
+      LOGIN_PATH = '/user/login/phonecode'
+      LIST_PATH = '/userRunList.aspx'
+      DETAIL_PATH = '/Run/GetInfo.aspx'
+      SALT_V1 = '1fd6e28fd158406995f77727b35bf20a'
+      SALT_V2 = '0C077B1E70F5FDDE6F497C1315687F9C'
+      BASE_HEADERS = {
+        'Accept-Language' => 'en_US',
+        'User-Agent' => 'okhttp/3.10.0',
+        'Host' => 'api.thejoyrun.com',
+        'Connection' => 'Keep-Alive',
+      }.freeze
+      DEVICE_HEADERS = {
+        'MODELTYPE' => 'Xiaomi MI 5',
+        'SYSVERSION' => '8.0.0',
+        'APPVERSION' => '4.2.0',
+      }.freeze
+      SPORT_MAP = { 0 => 'hike', 1 => 'run', 2 => 'ride' }.freeze
+
+      register_adapter
+      register_config :uid, :sid
+
+      attr_reader :generated_secrets
+
+      def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil,
+                     interactive_auth: false)
+        super(config: config, db: db, activity_filter: activity_filter, privacy: privacy,
+              time_budget: time_budget)
+        @uid = present_string(@config['uid'])
+        @sid = present_string(@config['sid'])
+        @phone = present_string(@config['phone'])
+        @sms_code = present_string(@config['sms_code'])
+        @interactive_auth = interactive_auth
+        @generated_secrets = nil
+      end
+
+      def before_call
+        return super if credentials_present?
+        return false unless @interactive_auth
+
+        super
+      end
+
+      def authenticate
+        return true if credentials_present?
+        return false unless @interactive_auth
+
+        @phone = prompt('Joyrun phone number: ') if @phone.empty?
+        @sms_code = prompt('Joyrun SMS code: ') if @sms_code.empty?
+        raise AuthError, 'Joyrun phone and SMS code are required' if @phone.empty? || @sms_code.empty?
+
+        login_with_sms(@phone, @sms_code)
+      end
+
+      def login_with_sms(phone, code)
+        resp = http_request(:get, LOGIN_PATH, params: {
+          'phoneNumber' => phone,
+          'identifyingCode' => code,
+        })
+        data = parse_json(resp)
+        return login_failed(resp, data) unless resp.code.to_i == 200 && data['ret'].to_s == '0'
+
+        @sid = data.dig('data', 'sid').to_s
+        @uid = data.dig('data', 'user', 'uid').to_s
+        return login_failed(resp, data) if @sid.empty? || @uid.empty?
+
+        @generated_secrets = { 'UID' => @uid, 'SID' => @sid }
+        @auth_method = 'sms'
+        true
+      rescue StandardError => e
+        warn "Joyrun: SMS login failed: #{e.message}"
+        false
+      end
+
+      def pending_ids
+        existing = existing_run_ids
+        resp = http_request(:post, LIST_PATH, body: { 'year' => 0 })
+        data = parse_json(resp)
+        raise SyncError, sid_error_message unless sid_valid?(resp, data)
+        return [] unless data.is_a?(Hash) && data['datas'].is_a?(Array)
+
+        data['datas'].filter_map do |item|
+          id = item['fid'].to_s
+          next if id.empty? || (existing.include?(id) && raw_file_exists?(id))
+
+          type = map_sport(item['type'])
+          next if skip_type?(type)
+
+          { id: id, type: type, has_raw: raw_file_exists?(id) }
+        end
+      end
+
+      def process_one(pending)
+        return load_raw_activity(pending[:id]) if pending[:has_raw]
+
+        resp = http_request(:post, DETAIL_PATH, body: { 'fid' => pending[:id], 'wgs' => 1 })
+        data = parse_json(resp)
+        raise SyncError, sid_error_message unless sid_valid?(resp, data)
+        return false unless data.is_a?(Hash) && data['runrecord'].is_a?(Hash)
+
+        write_source_archive(data, pending[:id])
+        upsert_from_detail(data['runrecord'])
+      end
+
+      def self.signature(params, uid, sid, salt, timestamp: nil)
+        timestamp ||= params['timestamp'] || Time.now.to_i
+        signed = params.merge('timestamp' => timestamp)
+        pre_string = signed.sort.map { |key, value| "#{key}#{value}" }.join
+        pre_string = "#{pre_string}#{salt}#{uid}#{sid}"
+        Digest::MD5.hexdigest(pre_string).upcase
+      end
+
+      private
+
+      def http_request(method, path, params: nil, body: nil)
+        timestamp = Time.now.to_i
+        sign_v1 = self.class.signature(params || body || {}, @uid, @sid, SALT_V1, timestamp: timestamp)
+        sign_v2 = self.class.signature(params || body || {}, @uid, @sid, SALT_V2, timestamp: timestamp)
+        uri = URI.join(BASE_URL, path)
+
+        if method == :get
+          query = (params || {}).merge('timestamp' => timestamp, 'signature' => sign_v1)
+          uri.query = URI.encode_www_form(query)
+          request = Net::HTTP::Get.new(uri)
+        else
+          form = (body || {}).merge('timestamp' => timestamp, 'signature' => sign_v1)
+          uri.query = URI.encode_www_form(params) if params
+          request = Net::HTTP::Post.new(uri)
+          request.body = URI.encode_www_form(form)
+          request['Content-Type'] = 'application/x-www-form-urlencoded'
+        end
+        headers_for_request(request)
+        request['_sign'] = sign_v2
+
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = true
+        http.open_timeout = 30
+        http.read_timeout = 60
+        http.start { |client| client.request(request) }
+      end
+
+      def headers_for_request(request)
+        BASE_HEADERS.each { |key, value| request[key] = value }
+        DEVICE_HEADERS.each { |key, value| request[key] = value }
+        return unless credentials_present?
+
+        cookie = "sid=#{@sid}&uid=#{@uid}"
+        request['ypcookie'] = cookie
+        request['Cookie'] = "ypcookie=#{URI.encode_www_form_component(cookie).downcase}"
+      end
+
+      def load_raw_activity(id)
+        data = JSON.parse(File.read(raw_path(id)))
+        record = data['runrecord']
+        return false unless record.is_a?(Hash)
+
+        upsert_from_detail(record)
+      end
+
+      def upsert_from_detail(record)
+        attrs = build_activity(record)
+        return false unless attrs
+
+        points = attrs.delete(:standard_points)
+        write_std(points, record['fid'])
+        upsert_activity(attrs)
+        attrs
+      end
+
+      def build_activity(record)
+        started_at = numeric(record['starttime'])
+        ended_at = numeric(record['endtime'])
+        return nil if started_at.nil? || started_at <= 0 || ended_at.nil? || ended_at <= 0
+
+        start_time = Time.at(numeric(record['starttime']) || 0).utc
+        end_time = Time.at(ended_at).utc
+        points = build_points(record, start_time, end_time)
+        distance = numeric(record['meter'])
+        moving_time = numeric(record['second'])&.round
+        sport = map_sport(record['type'])
+        hr_values = Array(parse_literal(record['heartrate'])).filter_map do |value|
+          value = numeric(value)
+          value&.positive? ? value : nil
+        end
+        location = [record['city'], record['province']].filter_map(&:to_s).reject(&:empty?).join(':')
+
+        attrs = {
+          run_id: "joyrun_#{record['fid']}",
+          name: "#{sport.capitalize} from Joyrun",
+          distance: distance&.positive? ? distance : nil,
+          moving_time: moving_time&.positive? ? moving_time : nil,
+          elapsed_time: end_time > start_time ? (end_time - start_time).round : nil,
+          sport_category: sport,
+          sport_type: record['type'].to_s,
+          start_date: start_time.utc.iso8601,
+          start_date_local: start_time.utc.getlocal('+08:00').iso8601,
+          location_country: location.empty? ? nil : location,
+          summary_polyline: if points.any?
+                              Geo::Polyline.encode(points.map do |point|
+                                point.values_at(:latitude, :longitude)
+                              end)
+                            end,
+          average_heartrate: average(hr_values),
+          max_heartrate: hr_values.max,
+          average_speed: distance&.positive? && moving_time&.positive? ? (distance / moving_time).round(2) : nil,
+          source: 'joyrun',
+        }
+        attrs.merge!(point_attributes(points))
+        attrs[:standard_points] = points
+        attrs
+      end
+
+      def build_points(record, start_time, end_time)
+        coordinates = parse_literal(record['content'].to_s.gsub(']-[', '],['))
+        return [] unless coordinates.is_a?(Array)
+
+        coordinates = coordinates.filter_map do |pair|
+          next unless pair.is_a?(Array) && pair.size >= 2
+
+          lat = numeric(pair[0])
+          lng = numeric(pair[1])
+          next unless lat && lng
+
+          [lat / 1_000_000.0, lng / 1_000_000.0]
+        end
+        return [] if coordinates.empty?
+
+        heart_rates = array_or_empty(parse_literal(record['heartrate']))
+        altitudes = array_or_empty(parse_literal(record['altitude']))
+        pauses = Array(parse_literal(record['pause'])).filter_map do |entry|
+          next unless entry.is_a?(Array) && entry.size >= 2
+
+          [numeric(entry[0])&.to_i, numeric(entry[1])&.to_i]
+        end
+
+        current_time = start_time
+        segment = 0
+        pause_index = 0
+        coordinates.each_with_index.map do |coordinate, index|
+          timestamp = index == coordinates.size - 1 ? end_time : current_time
+          point = {
+            latitude: coordinate[0],
+            longitude: coordinate[1],
+            altitude: numeric(at_altitude(altitudes, index)),
+            timestamp: timestamp.utc.iso8601,
+            heartrate: hr_value(at_value(heart_rates, index)),
+            segment: segment,
+          }
+          unless index == coordinates.size - 1
+            current_time += 5
+            pause = pauses[pause_index]
+            if pause && pause[0] && pause[1] && pause[0] - 1 == index
+              current_time += pause[1]
+              pause_index += 1
+              segment += 1
+            end
+          end
+          point
+        end
+      end
+
+      def point_attributes(points)
+        return { summary_polyline: nil } if points.empty?
+
+        alts = points.filter_map { |point| point[:altitude] }
+        {
+          elevation_gain: elevation_delta(alts, :gain),
+          elevation_loss: elevation_delta(alts, :loss),
+          elevation_min: alts.min&.round(1),
+          elevation_max: alts.max&.round(1),
+        }
+      end
+
+      def at_value(values, index)
+        value = values[index]
+        value.is_a?(Array) ? value.first : value
+      end
+
+      def at_altitude(values, index)
+        at_value(values, index)
+      end
+
+      def hr_value(value)
+        value = numeric(value)
+        value&.positive? ? value : nil
+      end
+
+      def sid_valid?(resp, data)
+        resp.code.to_i == 200 && !(data.is_a?(Hash) && data.key?('ret') && data['ret'].to_s != '0')
+      end
+
+      def sid_error_message
+        "Joyrun: sid expired or invalid\n  Re-auth: git fit auth joyrun"
+      end
+
+      def map_sport(value)
+        SPORT_MAP[numeric(value)&.to_i] || 'other'
+      end
+
+      def credentials_present?
+        !@uid.empty? && !@sid.empty?
+      end
+
+      def login_failed(resp, data)
+        reason = data.is_a?(Hash) ? data['msg'] : nil
+        warn "Joyrun: SMS login failed (HTTP #{resp.code}#{reason ? ": #{reason}" : ''})"
+        false
+      end
+
+      def prompt(label)
+        $stderr.print(label)
+        $stderr.flush
+        input = $stdin.gets
+        raise AuthError, 'Joyrun auth requires phone and SMS code on stdin' if input.nil?
+
+        input.strip
+      end
+
+      def present_string(value)
+        value.to_s
+      end
+
+      def parse_json(resp)
+        JSON.parse(resp.body)
+      rescue JSON::ParserError, TypeError
+        {}
+      end
+
+      def parse_literal(value)
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        parse_python_literal(value)
+      end
+
+      def parse_python_literal(value)
+        text = value.to_s.gsub(']-[', '],[')
+        return nil unless text.start_with?('[') && text.end_with?(']')
+
+        elements = split_top_level(text[1..-2])
+        elements.map { |element| parse_literal_element(element) }
+      end
+
+      def split_top_level(text)
+        groups = []
+        depth = 0
+        current = +''
+        text.each_char do |char|
+          case char
+          when '[' then depth += 1
+          when ']' then depth -= 1
+          when ','
+            if depth.zero?
+              groups << current
+              current = +''
+              next
+            end
+          end
+          current << char
+        end
+        groups << current unless current.empty?
+        groups
+      end
+
+      def parse_literal_element(element)
+        text = element.strip
+        return parse_python_literal(text) if text.start_with?('[')
+
+        value = Float(text)
+        value == value.to_i ? value.to_i : value
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def array_or_empty(value)
+        value.is_a?(Array) ? value : []
+      end
+
+      def numeric(value)
+        return nil if value.nil? || value.to_s.strip.empty?
+
+        Float(value)
+      rescue ArgumentError, TypeError
+        nil
+      end
+
+      def average(values)
+        return nil if values.empty?
+
+        (values.sum.to_f / values.size).round(1)
+      end
+
+      def elevation_delta(altitudes, direction)
+        return nil if altitudes.size < 2
+
+        total = 0.0
+        (1...altitudes.size).each do |index|
+          delta = altitudes[index] - altitudes[index - 1]
+          total += delta if direction == :gain && delta.positive?
+          total -= delta if direction == :loss && delta.negative?
+        end
+        total.round(1)
+      end
+
+      def raw_path(platform_id)
+        File.join(raw_dir, "#{platform_id}.json")
+      end
+
+      def write_std(points, platform_id)
+        dir = std_dir
+        FileUtils.mkdir_p(dir)
+        tmp = File.join(dir, ".#{platform_id}.json.tmp")
+        final = File.join(dir, "#{platform_id}.json")
+        File.write(tmp, JSON.generate(points))
+        File.rename(tmp, final)
+      end
+    end
+  end
+end

data/lib/git_fit/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: git-fit
 version: !ruby/object:Gem::Version
-  version: 0.23.2
+  version: 0.24.1
 platform: ruby
 authors:
 - Lax
@@ -363,11 +363,13 @@ 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/codoon.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/joyrun.rb
 - lib/git_fit/sync/keep.rb
 - lib/git_fit/sync/lorem.rb
 - lib/git_fit/sync/runner.rb