git-fit 0.7.9 → 0.8.0

data/lib/git_fit/sync/keep.rb

@@ -1,39 +1,41 @@
-require_relative "base"
-require "base64"
-require "zlib"
-require "openssl"
-require "time"
-require "tzinfo"
+# frozen_string_literal: true
+
+require_relative 'base'
+require 'base64'
+require 'zlib'
+require 'openssl'
+require 'time'
+require 'tzinfo'
 
 module GitFit
   module Sync
     class Keep < Base
-      LOGIN_URL = "https://api.gotokeep.com/v1.1/users/login"
-      STATS_URL = "https://api.gotokeep.com/pd/v3/stats/detail?dateUnit=all&type=%{sport}&lastDate=%{last_date}"
-      LOG_URL = "https://api.gotokeep.com/pd/v3/%{sport}log/%{run_id}"
+      LOGIN_URL = 'https://api.gotokeep.com/v1.1/users/login'
+      STATS_URL = 'https://api.gotokeep.com/pd/v3/stats/detail?dateUnit=all&type=%{sport}&lastDate=%{last_date}'
+      LOG_URL = 'https://api.gotokeep.com/pd/v3/%{sport}log/%{run_id}'
 
-      AES_KEY = Base64.decode64("NTZmZTU5OzgyZzpkODczYw==")
-      AES_IV = Base64.decode64("MjM0Njg5MjQzMjkyMDMwMA==")
+      AES_KEY = Base64.decode64('NTZmZTU5OzgyZzpkODczYw==')
+      AES_IV = Base64.decode64('MjM0Njg5MjQzMjkyMDMwMA==')
 
-      PLACEHOLDER_POLYLINE = "gqqrFurkeU??".freeze
+      PLACEHOLDER_POLYLINE = 'gqqrFurkeU??'
 
       KEEP_TYPES = %w[running hiking cycling].freeze
-      KEEP_RAW_EXT = "json".freeze
+      KEEP_RAW_EXT = 'json'
 
       TYPE_MAP = {
-        "outdoorWalking" => "walk",
-        "outdoorRunning" => "run",
-        "outdoorCycling" => "ride",
-        "indoorRunning" => "run",
-        "mountaineering" => "hike"
+        'outdoorWalking' => 'walk',
+        'outdoorRunning' => 'run',
+        'outdoorCycling' => 'ride',
+        'indoorRunning' => 'run',
+        'mountaineering' => 'hike',
       }.freeze
 
       STRAVA_TYPE_MAP = {
-        "outdoorWalking" => "Walk",
-        "outdoorRunning" => "Run",
-        "outdoorCycling" => "Ride",
-        "indoorRunning" => "VirtualRun",
-        "mountaineering" => "Hiking"
+        'outdoorWalking' => 'Walk',
+        'outdoorRunning' => 'Run',
+        'outdoorCycling' => 'Ride',
+        'indoorRunning' => 'VirtualRun',
+        'mountaineering' => 'Hiking',
       }.freeze
 
       TIMESTAMP_THRESHOLD = 3_600_000
@@ -44,11 +46,11 @@ module GitFit
 
       def initialize(config:, db:, activity_filter: nil, privacy: nil, time_budget: nil)
         super
-        @phone = @config["phone"] || @config["mobile"]
-        @password = @config["password"]
+        @phone = @config['phone'] || @config['mobile']
+        @password = @config['password']
         @headers = {
-          "User-Agent" => "Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0",
-          "Content-Type" => "application/x-www-form-urlencoded;charset=utf-8"
+          'User-Agent' => 'Mozilla/5.0 (X11; Ubuntu; Linux x86_64; rv:78.0) Gecko/20100101 Firefox/78.0',
+          'Content-Type' => 'application/x-www-form-urlencoded;charset=utf-8',
         }
         @session = nil
       end
@@ -96,7 +98,7 @@ module GitFit
         headers.each { |k, v| req[k] = v }
         req.body = body.is_a?(Hash) ? URI.encode_www_form(body) : body
         http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == "https"
+        http.use_ssl = uri.scheme == 'https'
         http.open_timeout = 30
         http.read_timeout = 60
         http.start { |h| h.request(req) }
@@ -107,7 +109,7 @@ module GitFit
         req = Net::HTTP::Get.new(uri)
         headers.each { |k, v| req[k] = v }
         http = Net::HTTP.new(uri.host, uri.port)
-        http.use_ssl = uri.scheme == "https"
+        http.use_ssl = uri.scheme == 'https'
         http.open_timeout = 30
         http.read_timeout = 60
         http.start { |h| h.request(req) }
@@ -118,10 +120,10 @@ module GitFit
         return nil unless resp.code.to_i == 200
 
         data = JSON.parse(resp.body)
-        token = data.dig("data", "token")
+        token = data.dig('data', 'token')
         return nil unless token
 
-        @headers["Authorization"] = "Bearer #{token}"
+        @headers['Authorization'] = "Bearer #{token}"
         @session = true
       rescue JSON::ParserError
         nil
@@ -134,7 +136,7 @@ module GitFit
       end
 
       def existing_run_ids
-        @db[:activities].where(source: "keep").select_map(:run_id).map(&:to_s)
+        @db[:activities].where(source: 'keep').select_map(:run_id).map(&:to_s)
       end
 
       def fetch_run_ids(sport)
@@ -146,19 +148,19 @@ module GitFit
           resp = @session ? http_get(url, @headers) : nil
           break unless resp&.code&.to_i == 200
 
-          data = JSON.parse(resp.body)["data"]
+          data = JSON.parse(resp.body)['data']
           break unless data
 
-          records = data["records"] || []
+          records = data['records'] || []
           records.each do |r|
-            logs = r["logs"] || []
+            logs = r['logs'] || []
             logs.each do |log|
-              stats = log["stats"] || log
-              ids << stats["id"] unless stats["isDoubtful"]
+              stats = log['stats'] || log
+              ids << stats['id'] unless stats['isDoubtful']
             end
           end
 
-          last_date = data["lastTimestamp"]
+          last_date = data['lastTimestamp']
           break if last_date.nil? || last_date.zero?
 
           spider_sleep
@@ -175,26 +177,26 @@ module GitFit
         return false unless resp.code.to_i == 200
 
         data = JSON.parse(resp.body)
-        run_data = data["data"]
+        run_data = data['data']
         return false unless run_data
 
         payload = decrypt_raw_payload(run_data)
-        keep_id = extract_id(run_data["id"])
+        keep_id = extract_id(run_data['id'])
         return false unless keep_id
 
         write_source_archive({
-          source: "keep",
-          decodedAt: Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ"),
+          source: 'keep',
+          decodedAt: Time.now.utc.strftime('%Y-%m-%dT%H:%M:%SZ'),
           meta: {
-            startTime: run_data["startTime"],
-            endTime: run_data["endTime"],
-            duration: run_data["duration"],
-            dataType: run_data["dataType"],
-            distance: run_data["distance"],
-            region: run_data["region"]
+            startTime: run_data['startTime'],
+            endTime: run_data['endTime'],
+            duration: run_data['duration'],
+            dataType: run_data['dataType'],
+            distance: run_data['distance'],
+            region: run_data['region'],
           },
           geoPoints: payload[:geo_points],
-          heartRates: payload[:hr_data]
+          heartRates: payload[:hr_data],
         }, keep_id)
 
         wgs_points = compute_wgs_points(payload, run_data)
@@ -212,14 +214,14 @@ module GitFit
       def upsert_from_raw(compound_id)
         keep_id = extract_id(compound_id) || compound_id
         raw = JSON.parse(File.read(raw_path(keep_id)))
-        run_data = raw["meta"].merge("id" => compound_id)
+        run_data = raw['meta'].merge('id' => compound_id)
 
         wgs = load_wgs_points(keep_id, raw)
         return false unless wgs&.any?
 
-        if raw["heartRates"]&.any?
-          vals = raw["heartRates"].map { |h| h["value"] }.compact
-          run_data["heartRate"] = { "averageHeartRate" => vals.sum / vals.size } if vals.any?
+        if raw['heartRates']&.any?
+          vals = raw['heartRates'].map { |h| h['value'] }.compact
+          run_data['heartRate'] = { 'averageHeartRate' => vals.sum / vals.size } if vals.any?
         end
 
         attrs = build_activity_from_wgs(run_data, wgs)
@@ -233,19 +235,19 @@ module GitFit
         std_path = File.join(std_dir, "#{keep_id}.json")
         if File.exist?(std_path)
           pts = JSON.parse(File.read(std_path))
-          pts.map { |pt| [pt["latitude"], pt["longitude"], pt["altitude"],
-                          pt["timestamp"] ? Time.parse(pt["timestamp"]) : nil, pt["heartrate"]] }
+          pts.map { |pt| [pt['latitude'], pt['longitude'], pt['altitude'],
+                          pt['timestamp'] ? Time.parse(pt['timestamp']) : nil, pt['heartrate']] }
         else
-          payload = { geo_points: raw["geoPoints"], hr_data: raw["heartRates"] }
-          run_data = raw["meta"]
+          payload = { geo_points: raw['geoPoints'], hr_data: raw['heartRates'] }
+          run_data = raw['meta']
           compute_wgs_points(payload, run_data)
         end
       end
 
       def decrypt_raw_payload(run_data)
         {
-          geo_points: decode_geo_points(run_data["geoPoints"]),
-          hr_data: decode_hr_data(run_data.dig("heartRate", "heartRates"))
+          geo_points: decode_geo_points(run_data['geoPoints']),
+          hr_data: decode_hr_data(run_data.dig('heartRate', 'heartRates')),
         }
       end
 
@@ -254,16 +256,16 @@ module GitFit
         hr_data = payload[:hr_data]
         return [] unless geo_points&.any?
 
-        start_time = run_data["startTime"]
-        use_absolute_ts = geo_points.first["timestamp"].to_i > TIMESTAMP_THRESHOLD
+        start_time = run_data['startTime']
+        use_absolute_ts = geo_points.first['timestamp'].to_i > TIMESTAMP_THRESHOLD
         effective_start = use_absolute_ts ? 0 : start_time
 
         geo_points.map do |p|
-          lat, lng = Geo::CoordTransform.gcj02_to_wgs84_exact(p["latitude"], p["longitude"])
-          ts = p["timestamp"] || p["unixTimestamp"]
+          lat, lng = Geo::CoordTransform.gcj02_to_wgs84_exact(p['latitude'], p['longitude'])
+          ts = p['timestamp'] || p['unixTimestamp']
           pt_time = ts ? Time.at(effective_start / 1000.0 + ts.to_i / 10.0).utc : nil
           hr = find_nearest_hr(hr_data, ts, start_time)
-          [lat, lng, p["altitude"], pt_time, hr]
+          [lat, lng, p['altitude'], pt_time, hr]
         end
       end
 
@@ -278,29 +280,29 @@ module GitFit
         tz_string = tz_resolver.resolve(lat, lng)
         tz = TZInfo::Timezone.get(tz_string)
         tz.utc_to_local(start_utc).iso8601
-      rescue => e
+      rescue StandardError => e
         warn "Keep: timezone resolution failed: #{e.message}"
         start_utc.iso8601
       end
 
       def build_activity_from_wgs(run_data, wgs_points)
-        keep_id = extract_id(run_data["id"])
+        keep_id = extract_id(run_data['id'])
         return nil unless keep_id
 
-        start_time = run_data["startTime"]
-        end_time = run_data["endTime"]
-        duration = run_data["duration"]
+        start_time = run_data['startTime']
+        end_time = run_data['endTime']
+        duration = run_data['duration']
         return nil unless duration
 
         start_date = Time.at(start_time / 1000.0).utc
-        data_type = run_data["dataType"]
+        data_type = run_data['dataType']
 
-        avg_hr = run_data.dig("heartRate", "averageHeartRate")
+        avg_hr = run_data.dig('heartRate', 'averageHeartRate')
         avg_hr = nil if avg_hr && avg_hr < 0
 
         polyline_str = nil
-        total_elevation = run_data["elevation"]
-        computed_distance = run_data["distance"]
+        total_elevation = run_data['elevation']
+        computed_distance = run_data['distance']
 
         if wgs_points.any?
           if wgs_points.any? { |pt| pt[3] }
@@ -321,44 +323,44 @@ module GitFit
           distance: computed_distance&.round(2),
           moving_time: moving_time,
           elapsed_time: elapsed_time,
-          sport_category: TYPE_MAP[data_type] || "other",
+          sport_category: TYPE_MAP[data_type] || 'other',
           sport_type: data_type,
           start_date: start_date.iso8601,
           start_date_local: local_time_from_gps(start_date, wgs_points),
-          location_country: run_data["region"],
+          location_country: run_data['region'],
           summary_polyline: polyline_str,
           average_heartrate: avg_hr&.round(1),
           average_speed: computed_distance && moving_time&.positive? ? (computed_distance.to_f / moving_time).round(2) : nil,
           elevation_gain: total_elevation&.round(1),
-          source: "keep"
+          source: 'keep',
         }
       end
 
       def write_standardized_json(wgs_points, payload, run_data, keep_id)
         geo_points = payload[:geo_points] || []
         hr_data = payload[:hr_data]
-        start_time = run_data["startTime"]
+        start_time = run_data['startTime']
 
         extended = wgs_points.each_with_index.map do |pt, i|
           orig = geo_points[i] || {}
           ts = pt[3]
           {
             latitude: pt[0], longitude: pt[1], altitude: pt[2],
-            timestamp: ts&.strftime("%Y-%m-%dT%H:%M:%SZ"),
+            timestamp: ts&.strftime('%Y-%m-%dT%H:%M:%SZ'),
             heartrate: pt[4],
-            speed: orig["speed"],
-            currentTotalDistance: orig["currentTotalDistance"],
-            currentTotalDuration: orig["currentTotalDuration"],
-            currentPace: orig["currentPace"],
-            pressure: orig["pressure"],
-            accuracyRadius: orig["accuracyRadius"],
-            verticalAccuracy: orig["verticalAccuracy"],
-            locationType: orig["locationType"],
-            isPause: orig["isPause"],
-            flags: orig["flags"],
-            processLabel: orig["processLabel"],
-            crossKmMark: orig["crossKmMark"],
-            currentTotalSteps: orig["currentTotalSteps"]
+            speed: orig['speed'],
+            currentTotalDistance: orig['currentTotalDistance'],
+            currentTotalDuration: orig['currentTotalDuration'],
+            currentPace: orig['currentPace'],
+            pressure: orig['pressure'],
+            accuracyRadius: orig['accuracyRadius'],
+            verticalAccuracy: orig['verticalAccuracy'],
+            locationType: orig['locationType'],
+            isPause: orig['isPause'],
+            flags: orig['flags'],
+            processLabel: orig['processLabel'],
+            crossKmMark: orig['crossKmMark'],
+            currentTotalSteps: orig['currentTotalSteps']
           }
         end
 
@@ -376,7 +378,7 @@ module GitFit
 
       def extract_id(id_str)
         return nil unless id_str
-        id_str.split("_")[1]
+        id_str.split('_')[1]
       end
 
       def decode_geo_points(geo_data)
@@ -399,7 +401,7 @@ module GitFit
       end
 
       def aes_decrypt(data)
-        cipher = OpenSSL::Cipher.new("AES-128-CBC")
+        cipher = OpenSSL::Cipher.new('AES-128-CBC')
         cipher.decrypt
         cipher.key = AES_KEY
         cipher.iv = AES_IV
@@ -418,7 +420,7 @@ module GitFit
             next
           end
         end
-        raise Zlib::DataError, "cannot inflate data"
+        raise Zlib::DataError, 'cannot inflate data'
       end
 
       def find_nearest_hr(hr_data, geo_ts, start_time, threshold: HR_THRESHOLD)
@@ -438,7 +440,7 @@ module GitFit
         min_diff = Float::INFINITY
 
         hr_data.each do |item|
-          ts = item["timestamp"]
+          ts = item['timestamp']
           next unless ts
 
           diff = (normalize.call(ts) - target).abs
@@ -448,7 +450,7 @@ module GitFit
           end
         end
 
-        hr = nearest&.dig("beatsPerMinute")
+        hr = nearest&.dig('beatsPerMinute')
         hr&.positive? ? hr : nil
       end
 

data/lib/git_fit/sync/lorem.rb

@@ -1,6 +1,8 @@
-require "json"
-require "fileutils"
-require "time"
+# frozen_string_literal: true
+
+require 'json'
+require 'fileutils'
+require 'time'
 
 module GitFit
   module Sync
@@ -9,41 +11,41 @@ module GitFit
       register_test_adapter
 
       DEMO_ACTIVITIES = [
-        { id: "alpha_001", name: "Lorem Morning Run", sport_category: "run",
+        { id: 'alpha_001', name: 'Lorem Morning Run', sport_category: 'run',
           distance: 5200.0, moving_time: 1800, elapsed_time: 2000,
-          start_date: "2025-01-15T06:30:00Z", start_date_local: "2025-01-15T14:30:00+08:00",
-          location_country: "CN", average_heartrate: 148.0, max_heartrate: 165.0,
+          start_date: '2025-01-15T06:30:00Z', start_date_local: '2025-01-15T14:30:00+08:00',
+          location_country: 'CN', average_heartrate: 148.0, max_heartrate: 165.0,
           average_cadence: 172.0, max_cadence: 185.0, average_power: nil, max_power: nil,
           average_temperature: 22.0, calories: 380,
-          average_speed: 5200.0 / 1800, elevation_gain: 125.0, external_id: "lorem_001" },
-        { id: "beta_002", name: "Ipsum Cycling Session", sport_category: "ride",
+          average_speed: 5200.0 / 1800, elevation_gain: 125.0, external_id: 'lorem_001' },
+        { id: 'beta_002', name: 'Ipsum Cycling Session', sport_category: 'ride',
           distance: 35000.0, moving_time: 5400, elapsed_time: 6000,
-          start_date: "2025-01-14T08:00:00Z", start_date_local: "2025-01-14T16:00:00+08:00",
-          location_country: "CN", average_heartrate: 138.0, max_heartrate: 155.0,
+          start_date: '2025-01-14T08:00:00Z', start_date_local: '2025-01-14T16:00:00+08:00',
+          location_country: 'CN', average_heartrate: 138.0, max_heartrate: 155.0,
           average_cadence: 85.0, max_cadence: 105.0, average_power: 185.0, max_power: 420.0,
           average_temperature: 18.0, calories: 850,
-          average_speed: 35000.0 / 5400, elevation_gain: 450.0, external_id: "lorem_002" },
-        { id: "gamma_003", name: "Dolor Hike", sport_category: "hike",
+          average_speed: 35000.0 / 5400, elevation_gain: 450.0, external_id: 'lorem_002' },
+        { id: 'gamma_003', name: 'Dolor Hike', sport_category: 'hike',
           distance: 12000.0, moving_time: 7200, elapsed_time: 8100,
-          start_date: "2025-01-13T09:00:00Z", start_date_local: "2025-01-13T17:00:00+08:00",
-          location_country: "CN", average_heartrate: 122.0, max_heartrate: 142.0,
+          start_date: '2025-01-13T09:00:00Z', start_date_local: '2025-01-13T17:00:00+08:00',
+          location_country: 'CN', average_heartrate: 122.0, max_heartrate: 142.0,
           average_cadence: 110.0, max_cadence: 135.0, average_power: nil, max_power: nil,
           average_temperature: 15.0, calories: 620,
-          average_speed: 12000.0 / 7200, elevation_gain: 820.0, external_id: "lorem_003" },
-        { id: "delta_004", name: "Sit Amet Walk", sport_category: "walk",
+          average_speed: 12000.0 / 7200, elevation_gain: 820.0, external_id: 'lorem_003' },
+        { id: 'delta_004', name: 'Sit Amet Walk', sport_category: 'walk',
           distance: 5000.0, moving_time: 3600, elapsed_time: 3900,
-          start_date: "2025-01-12T18:00:00Z", start_date_local: "2025-01-12T18:00:00+08:00",
-          location_country: "CN", average_heartrate: 108.0, max_heartrate: 125.0,
+          start_date: '2025-01-12T18:00:00Z', start_date_local: '2025-01-12T18:00:00+08:00',
+          location_country: 'CN', average_heartrate: 108.0, max_heartrate: 125.0,
           average_cadence: 105.0, max_cadence: 118.0, average_power: nil, max_power: nil,
           average_temperature: 20.0, calories: 280,
-          average_speed: 5000.0 / 3600, elevation_gain: 35.0, external_id: "lorem_004" },
-        { id: "epsilon_005", name: "Consectetur Swim", sport_category: "swim",
+          average_speed: 5000.0 / 3600, elevation_gain: 35.0, external_id: 'lorem_004' },
+        { id: 'epsilon_005', name: 'Consectetur Swim', sport_category: 'swim',
           distance: 2000.0, moving_time: 2400, elapsed_time: 2700,
-          start_date: "2025-01-11T07:00:00Z", start_date_local: "2025-01-11T15:00:00+08:00",
-          location_country: "CN", average_heartrate: 135.0, max_heartrate: 150.0,
+          start_date: '2025-01-11T07:00:00Z', start_date_local: '2025-01-11T15:00:00+08:00',
+          location_country: 'CN', average_heartrate: 135.0, max_heartrate: 150.0,
           average_cadence: 28.0, max_cadence: 32.0, average_power: nil, max_power: nil,
           average_temperature: 26.0, calories: 520,
-          average_speed: 2000.0 / 2400, elevation_gain: 0.0, external_id: "lorem_005" }
+          average_speed: 2000.0 / 2400, elevation_gain: 0.0, external_id: 'lorem_005' }
       ].freeze
 
       def authenticate
@@ -97,8 +99,8 @@ module GitFit
           calories: act[:calories],
           average_speed: act[:average_speed],
           elevation_gain: act[:elevation_gain],
-          source: "lorem",
-          external_id: act[:external_id]
+          source: 'lorem',
+          external_id: act[:external_id],
         }
       end
 
@@ -108,13 +110,13 @@ module GitFit
         num_points = [(distance / 500.0).ceil, 20].max
 
         case category
-        when "run"
+        when 'run'
           (0...num_points).map { |i| [base_lat + i * 0.0002, base_lng + i * 0.0003] }
-        when "ride"
+        when 'ride'
           (0...num_points).map { |i| [base_lat + i * 0.0005, base_lng + i * 0.0008] }
-        when "hike"
+        when 'hike'
           (0...num_points).map { |i| [base_lat + i * 0.0003 + Math.sin(i * 0.5) * 0.0001, base_lng + i * 0.0004] }
-        when "swim"
+        when 'swim'
           [[base_lat, base_lng]]
         else
           (0...num_points).map { |i| [base_lat + i * 0.0002, base_lng + i * 0.0002] }

data/lib/git_fit/sync/runner.rb

@@ -1,4 +1,6 @@
-require "thread"
+# frozen_string_literal: true
+
+require 'thread'
 
 module GitFit
   module Sync
@@ -76,29 +78,30 @@ module GitFit
         actual_key = klass&.config_key || source
         cfg = @config.sync_config(actual_key)
         unless klass
-          output_queue << { type: :banner, source:, text: "no adapter" }
+          output_queue << { type: :banner, source:, text: 'no adapter' }
           clear_source(source)
           return false
         end
 
-        output_queue << { type: :banner, source:, text: "authenticating" }
-        adapter = klass.new(config: cfg, db: @db, activity_filter: @activity_filter, privacy: @privacy, time_budget: @time_budget)
+        output_queue << { type: :banner, source:, text: 'authenticating' }
+        adapter = klass.new(config: cfg, db: @db, activity_filter: @activity_filter, privacy: @privacy,
+                            time_budget: @time_budget)
         unless adapter.before_call
-          output_queue << { type: :banner, source:, text: "before_call failed" }
+          output_queue << { type: :banner, source:, text: 'before_call failed' }
           clear_source(source)
           return false
         end
 
         unless adapter.authenticate
-          output_queue << { type: :banner, source:, text: "auth failed" }
+          output_queue << { type: :banner, source:, text: 'auth failed' }
           clear_source(source)
           return false
         end
 
-        output_queue << { type: :banner, source:, text: "fetching activity list" }
+        output_queue << { type: :banner, source:, text: 'fetching activity list' }
         ids = adapter.pending_ids
         if ids.nil? || ids.empty?
-          output_queue << { type: :banner, source:, text: "no new activities" }
+          output_queue << { type: :banner, source:, text: 'no new activities' }
           clear_source(source)
           return false
         end
@@ -125,7 +128,7 @@ module GitFit
 
           begin
             process_source(source)
-          rescue => e
+          rescue StandardError => e
             @output_queue << { type: :error, source:, message: "Worker crashed: #{e.message}" }
             @stats_lock.synchronize do
               @pending_ids.delete(source)
@@ -194,7 +197,7 @@ module GitFit
                 info: nil, done: processed, total: total
               }
             end
-          rescue => e
+          rescue StandardError => e
             @output_queue << { type: :error, source:, message: e.message }
           end
 
@@ -306,7 +309,7 @@ module GitFit
           end
         end
         $stdout.flush
-      rescue => e
+      rescue StandardError => e
         $stdout.puts "    Runner output error: #{e.message}"
         $stdout.flush
       end