ty

.github/release-drafter.yml

@@ -0,0 +1,43 @@
+exclude-labels:
+  - 'no-changelog'
+categories:
+  - title: '🚀 Features'
+    labels:
+      - 'feature'
+      - 'enhancement'
+  - title: '🐛 Bug Fixes'
+    collapse-after: 5
+    labels:
+      - 'fix'
+      - 'bugfix'
+      - 'bug'
+  - title: '🧰 Maintenance'
+    collapse-after: 5
+    label: 'chore'
+change-template: '- $TITLE @$AUTHOR (#$NUMBER)'
+change-title-escapes: '\<*_&'
+replacers:
+  - search: '/[Ss][Uu][Nn][Nn][Yy][Pp][Ii][Ll][Oo][Tt]/g'
+    replace: 'sunnypilot'
+  - search: '/\b[Ss][Pp]\b/g'
+    replace: 'SP'
+version-resolver:
+  major:
+    labels:
+      - 'major'
+  minor:
+    labels:
+      - 'minor'
+  patch:
+    labels:
+      - 'patch'
+  default: patch
+name-template: 'v$RESOLVED_VERSION 🚀'
+tag-template: 'v$RESOLVED_VERSION'
+version-template: "0.$MAJOR.$MINOR.$PATCH" # The day OP becomes v1, we need to bump this
+tag-prefix: "v0." # The day OP becomes v1, we need to bump this
+prerelease-identifier: "staging"
+template: |
+  ## Changes
+
+  $CHANGES

.github/workflows/build-all-tinygrad-models.yaml

@@ -20,11 +20,6 @@ on:
         required: false
         type: string
         default: 'sunnypilot/sunnypilot_models_v1'
-      docs_repo:
-        description: 'GitHub repo holding the driving_models JSON on its gh-pages branch'
-        required: false
-        type: string
-        default: 'sunnypilot/sunnypilot-models'
 
 jobs:
   setup:
@@ -39,6 +34,7 @@ jobs:
       - name: Checkout sunnypilot repo
         uses: actions/checkout@v4
         with:
+          repository: sunnypilot/sunnypilot
           path: sunnypilot
           submodules: recursive
 
@@ -51,10 +47,10 @@ jobs:
           echo "tinygrad_ref=$ref" >> $GITHUB_OUTPUT
           echo "tinygrad_ref is $ref"
 
-      - name: Checkout docs repo (gh-pages)
+      - name: Checkout docs repo (sunnypilot-models, gh-pages)
         uses: actions/checkout@v4
         with:
-          repository: ${{ inputs.docs_repo }}
+          repository: sunnypilot/sunnypilot-models
           ref: gh-pages
           path: docs
           ssh-key: ${{ secrets.CI_SUNNYPILOT_DOCS_PRIVATE_KEY }}
@@ -122,7 +118,6 @@ jobs:
       json_version: ${{ needs.setup.outputs.json_version }}
       target_hardware: ${{ github.event.inputs.target_hardware }}
       hf_repo: ${{ github.event.inputs.hf_repo }}
-      docs_repo: ${{ inputs.docs_repo }}
       set_min_version: ${{ github.event.inputs.set_min_version }}
       tinygrad_ref: ${{ needs.setup.outputs.tinygrad_ref }}
     secrets: inherit
@@ -167,7 +162,6 @@ jobs:
       target_hardware: ${{ github.event.inputs.target_hardware }}
       artifact_suffix: -retry
       hf_repo: ${{ github.event.inputs.hf_repo }}
-      docs_repo: ${{ inputs.docs_repo }}
       set_min_version: ${{ github.event.inputs.set_min_version }}
       tinygrad_ref: ${{ needs.setup.outputs.tinygrad_ref }}
     secrets: inherit

.github/workflows/build-single-tinygrad-model.yaml

@@ -39,11 +39,6 @@ on:
         required: false
         type: string
         default: 'sunnypilot/sunnypilot_models_v1'
-      docs_repo:
-        description: 'GitHub repo holding the driving_models JSON on its gh-pages branch'
-        required: false
-        type: string
-        default: 'sunnypilot/sunnypilot-models'
       set_min_version:
         description: 'Minimum selector version'
         required: false
@@ -112,11 +107,6 @@ on:
         required: false
         type: string
         default: 'sunnypilot/sunnypilot_models_v1'
-      docs_repo:
-        description: 'GitHub repo holding the driving_models JSON on its gh-pages branch'
-        required: false
-        type: string
-        default: 'sunnypilot/sunnypilot-models'
 env:
   RECOMPILED_DIR: recompiled${{ inputs.recompiled_dir }}
   JSON_FILE: docs/docs/driving_models_${{ inputs.target_hardware == 'chestnut' && 'chestnut_v' || 'v' }}${{ inputs.json_version }}.json
@@ -146,7 +136,7 @@ jobs:
       - name: Checkout docs repo
         uses: actions/checkout@v4
         with:
-          repository: ${{ inputs.docs_repo }}
+          repository: sunnypilot/sunnypilot-models
           ref: gh-pages
           path: docs
           ssh-key: ${{ secrets.CI_SUNNYPILOT_DOCS_PRIVATE_KEY }}

.github/workflows/release-drafter.yml

@@ -0,0 +1,28 @@
+name: Release Drafter
+
+on:
+  push:
+    branches:
+      - master
+    tags:
+      - 'v*'
+  pull_request_target:
+    types: [opened, reopened, synchronize]
+  workflow_dispatch:
+
+permissions:
+  contents: read
+
+jobs:
+  update_release_draft:
+    permissions:
+      contents: write
+      pull-requests: write
+    runs-on: ubuntu-latest
+    steps:
+      - uses: release-drafter/release-drafter@v6
+        with:
+          config-name: release-drafter.yml
+          prerelease: ${{ !startsWith(github.ref, 'refs/tags/v') }}
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}

.github/workflows/test-discourse.yaml.yml

@@ -0,0 +1,78 @@
+name: Debug Discourse Posting
+
+on:
+  push:
+
+jobs:
+  test-discourse-post:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Post test message to Discourse
+        uses: ./.github/workflows/post-to-discourse
+        with:
+          discourse-url: ${{ vars.DISCOURSE_URL }}
+          api-key: ${{ secrets.DISCOURSE_API_KEY }}
+          api-username: ${{ secrets.DISCOURSE_API_USERNAME }}
+          topic-id: ${{ vars.DISCOURSE_UPDATES_TOPIC_ID }}
+          message: |
+            ## 🧪 Test Post from GitHub Actions
+            
+            **This is a test post to verify Discourse integration**
+            
+            - **Workflow**: ${{ github.workflow }}
+            - **Run Number**: #${{ github.run_number }}
+            - **Branch**: `${{ github.ref_name }}`
+            - **Commit**: ${{ github.sha }}
+            - **Actor**: @${{ github.actor }}
+            - **Timestamp**: ${{ github.event.head_commit.timestamp }}
+            
+            ---
+            
+            ### Fake Build Info (for testing)
+            - **Version**: 0.9.8-test
+            - **Build**: #42
+            - **Branch**: release-test
+            
+            [View workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
+            
+            *This is an automated test message. Drive safe! 🚗💨*
+      
+      
+      - name: Create topic on Discourse
+        uses: ./.github/workflows/post-to-discourse
+        with:
+          discourse-url: ${{ vars.DISCOURSE_URL }}
+          api-key: ${{ secrets.DISCOURSE_API_KEY }}
+          api-username: ${{ secrets.DISCOURSE_API_USERNAME }}
+          #topic-id: ${{ vars.DISCOURSE_UPDATES_TOPIC_ID }}
+          category-id: 4
+          title: "This is a test of a new topic instead of a reply"
+          message: |
+            ## 🧪 Test Post from GitHub Actions
+            
+            **This is a test post to verify Discourse integration**
+            
+            - **Workflow**: ${{ github.workflow }}
+            - **Run Number**: #${{ github.run_number }}
+            - **Branch**: `${{ github.ref_name }}`
+            - **Commit**: ${{ github.sha }}
+            - **Actor**: @${{ github.actor }}
+            - **Timestamp**: ${{ github.event.head_commit.timestamp }}
+            
+            ---
+            
+            ### Fake Build Info (for testing)
+            - **Version**: 0.9.8-test
+            - **Build**: #42
+            - **Branch**: release-test
+            
+            [View workflow run](${{ github.server_url }}/${{ github.repository }}/actions/runs/${{ github.run_id }})
+            
+            *This is an automated test message. Drive safe! 🚗💨*
+      - name: Display results
+        if: always()
+        run: |
+          echo "::notice::Discourse post test completed"
+          echo "Check your Discourse topic to verify the post appeared correctly"

.github/workflows/test_models.yml

@@ -1,79 +0,0 @@
-name: Test Models Compatibility With Tinygrad Changes
-on:
-  pull_request:
-    paths:
-      - 'tinygrad_repo'
-  workflow_dispatch:
-
-jobs:
-  generate-matrix:
-    runs-on: ubuntu-latest
-    outputs:
-      models: ${{ steps.set-matrix.outputs.models }}
-    steps:
-      - uses: actions/checkout@v4
-      - name: Fetch and Parse json
-        id: set-matrix
-        run: |
-          python3 -c '
-          import json, urllib.request, os, re
-
-          with open("openpilot/sunnypilot/models/fetcher.py", "r") as f:
-            urls = re.findall(r"MODEL_URL(?:_CHESTNUT)?\s*=\s*[\"'"'"']([^\"'"'"']+)[\"'"'"']", f.read())
-
-          artifacts = []
-          for url in urls:
-            data = json.loads(urllib.request.urlopen(url).read())
-            for bundle in data.get("bundles", []):
-              for model in bundle.get("models", []):
-                if "artifact" in model:
-                  artifacts.append(model["artifact"])
-
-          with open(os.environ["GITHUB_OUTPUT"], "a") as f:
-            f.write(f"models={json.dumps(artifacts)}\n")
-          '
-
-  test-model:
-    name: Test ${{ matrix.artifact.file_name }}
-    needs: generate-matrix
-    runs-on: ubuntu-latest
-    container: ghcr.io/commaai/openpilot-base:latest
-    strategy:
-      fail-fast: false
-      matrix:
-        artifact: ${{ fromJson(needs.generate-matrix.outputs.models) }}
-    steps:
-      - uses: actions/checkout@v4
-        with:
-          submodules: true
-
-      - name: Download Model Chunks in Parallel
-        run: |
-          mkdir -p /tmp/model_chunks
-          echo '${{ toJson(matrix.artifact.chunks) }}' > chunks.json
-
-          BASE_URL="${{ matrix.artifact.download_uri.url }}"
-          export BASE_DIR=$(dirname "$BASE_URL")
-
-          python3 -c '
-          import json, os
-          with open("chunks.json") as f:
-            chunks = json.load(f)
-          manifest_path = f"/tmp/model_chunks/${{ matrix.artifact.file_name }}.chunkmanifest"
-          with open(manifest_path, "w") as f:
-            f.write(str(len(chunks)))
-          base_dir = os.environ["BASE_DIR"]
-          with open("/tmp/curl_config.txt", "w") as f:
-            for c in chunks:
-              fn = c["file_name"]
-              f.write(f"url = \"{base_dir}/{fn}\"\noutput = \"/tmp/model_chunks/{fn}\"\n")
-          '
-          curl -Z --parallel-immediate --parallel-max 16 -s -S -f -L -K /tmp/curl_config.txt
-
-      - name: Run Model Compatibility Test
-        env:
-          MODEL_BASE_NAME: ${{ matrix.artifact.file_name }}
-          MODEL_CHUNK_DIR: "/tmp/model_chunks"
-          PYTHONPATH: ".:./tinygrad_repo"
-        run: |
-          python3 -m pytest openpilot/sunnypilot/modeld_v2/tests/test_models.py

openpilot/common/params_keys.h

@@ -227,6 +227,11 @@ inline static std::unordered_map<std::string, ParamKeyAttributes> keys = {
     {"SunnylinkEnabled", {PERSISTENT, BOOL, "1"}},
     {"SunnylinkTempFault", {CLEAR_ON_MANAGER_START | CLEAR_ON_OFFROAD_TRANSITION, BOOL, "0"}},
 
+    {"SunnylinkLocalApps", {PERSISTENT, JSON}},
+    {"SunnylinkLocalPairingCode", {CLEAR_ON_MANAGER_START, JSON}},
+    {"SunnylinkLocalDiscoveredApp", {CLEAR_ON_MANAGER_START, JSON}},
+    {"SunnylinkLocalPairingRequest", {CLEAR_ON_MANAGER_START, BOOL}},
+
     // Backup Manager params
     {"BackupManager_CreateBackup", {PERSISTENT, BOOL}},
     {"BackupManager_RestoreVersion", {PERSISTENT, STRING}},

openpilot/selfdrive/controls/lib/longcontrol.py

@@ -4,7 +4,6 @@ from openpilot.common.realtime import DT_CTRL
 from openpilot.selfdrive.controls.lib.drive_helpers import CONTROL_N
 from openpilot.common.pid import PIDController
 from openpilot.selfdrive.modeld.constants import ModelConstants
-from openpilot.sunnypilot.selfdrive.controls.lib.longcontrol import LongControlSP
 
 CONTROL_N_T_IDX = ModelConstants.T_IDXS[:CONTROL_N]
 
@@ -40,7 +39,7 @@ def long_control_state_trans(CP_SP, active, long_control_state,
 
   return long_control_state
 
-class LongControl(LongControlSP):
+class LongControl:
   def __init__(self, CP, CP_SP):
     self.CP = CP
     self.CP_SP = CP_SP
@@ -66,10 +65,10 @@ class LongControl(LongControlSP):
 
     elif self.long_control_state == LongCtrlState.stopping:
       output_accel = self.last_output_accel
-      if output_accel > self.CP.stopAccel and not LongControlSP.should_hold_stopping(self, CS, a_target):
+      if output_accel > self.CP.stopAccel:
         output_accel = min(output_accel, 0.0)
         # TODO: can we just go straight to stopAccel?
-        output_accel -= self.stopping_decel_rate(CS.vEgo) * DT_CTRL
+        output_accel -= 1.0 * DT_CTRL  # m/s^2/s while trying to stop
       self.reset()
 
     else:  # LongCtrlState.pid

openpilot/selfdrive/controls/tests/test_longcontrol.py

@@ -1,10 +1,6 @@
-from types import SimpleNamespace
-from typing import cast
-
 from openpilot.common.test import OpenpilotTestCase
 from openpilot.cereal import custom
 from openpilot.selfdrive.controls.lib.longcontrol import LongCtrlState, long_control_state_trans
-from openpilot.sunnypilot.selfdrive.controls.lib.longcontrol import LongControlSP
 
 
 class TestLongControlStateTransition(OpenpilotTestCase):
@@ -46,21 +42,3 @@ class TestLongControlStateTransition(OpenpilotTestCase):
     next_state = long_control_state_trans(CP_SP, active, current_state,
                              should_stop=False, brake_pressed=False, cruise_standstill=False)
     assert next_state == LongCtrlState.pid
-
-
-class TestStoppingHold:
-  def test_weak_brake_does_not_hold_stopping(self):
-    control = SimpleNamespace(last_output_accel=-0.109)
-    car_state = SimpleNamespace(vEgo=0.277, aEgo=-0.406)
-    assert not LongControlSP.should_hold_stopping(cast(LongControlSP, control), car_state, -0.072)
-
-  def test_sufficient_brake_holds_stopping(self):
-    control = SimpleNamespace(last_output_accel=-0.543)
-    car_state = SimpleNamespace(vEgo=0.209, aEgo=-0.534)
-    assert LongControlSP.should_hold_stopping(cast(LongControlSP, control), car_state, -0.469)
-
-  def test_stopping_decel_rate_is_smooth_while_rolling(self):
-    assert LongControlSP.stopping_decel_rate(0.1) == 0.3
-
-  def test_stopping_decel_rate_builds_holding_brake_at_stop(self):
-    assert LongControlSP.stopping_decel_rate(0.0) == 2.0

openpilot/selfdrive/modeld/modeld.py

@@ -474,7 +474,6 @@ def main(demo=False):
       DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob, left_edge, right_edge)
       modelv2_send.modelV2.meta.laneChangeState = DH.lane_change_state
       modelv2_send.modelV2.meta.laneChangeDirection = DH.lane_change_direction
-      mdv2sp_send.valid = modelv2_send.valid
       mdv2sp_send.modelDataV2SP.laneTurnDirection = DH.lane_turn_direction
 
       fill_driving_model_data(drivingdata_send, modelv2_send)

openpilot/selfdrive/ui/sunnypilot/layouts/settings/models.py

@@ -4,6 +4,7 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
+import os
 import re
 import time
 import pyray as rl
@@ -12,8 +13,7 @@ from openpilot.cereal import custom
 from openpilot.sunnypilot.models.helpers import ACTIVE_BUNDLE_KEYS, get_selected_bundle, resolve_bundle_by_ref
 from openpilot.common.constants import CV
 from openpilot.selfdrive.ui.ui_state import device, ui_state
-from openpilot.selfdrive.ui.sunnypilot.model_info import (big_model_state, bundles_for_source, carrying_model, default_model_name,
-                                                           model_cache_size_mb, queued_name, refresh_in_progress, refresh_model_list)
+from openpilot.selfdrive.ui.sunnypilot.model_info import big_model_state, bundles_for_source, carrying_model, default_model_name, queued_name
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.lib.application import gui_app
 from openpilot.system.ui.widgets import DialogResult, Widget
@@ -21,6 +21,7 @@ from openpilot.system.ui.widgets.confirm_dialog import alert_dialog, ConfirmDial
 from openpilot.system.ui.widgets.scroller_tici import Scroller
 from openpilot.system.ui.widgets.toggle import ON_COLOR
 
+from openpilot.sunnypilot.models.runners.constants import CUSTOM_MODEL_PATH
 from openpilot.system.ui.sunnypilot.lib.styles import style
 from openpilot.system.ui.sunnypilot.lib.utils import NoElideButtonAction, ScrollingButtonAction
 from openpilot.system.ui.sunnypilot.widgets.list_view import ListItemSP, toggle_item_sp, option_item_sp
@@ -39,9 +40,6 @@ class ModelsLayout(Widget):
     self._selection_source = None
     self._downloading = False
     self._verifying = False
-    self._clearing = False
-    self._refreshing = False
-    self._refresh_start: float | None = None
     self._last_note = None
     self.last_cache_calc_time = 0
 
@@ -69,14 +67,15 @@ class ModelsLayout(Widget):
 
     self.download_item = download_status_item(lambda: tr("Download") if self._downloading else tr("Model Status"))
 
-    self.refresh_item = button_item(tr("Refresh Model List"),
-                                    lambda: tr("FETCHING...") if self._refreshing else tr("REFRESH"), "",
-                                    self._refresh_models)
+    self.refresh_item = button_item(tr("Refresh Model List"), tr("REFRESH"), "",
+                                    lambda: (ui_state.params.put("ModelManager_LastSyncTime", 0),
+                                             ui_state.params.put("ModelManager_LastSyncTime_Chestnut", 0),
+                                             gui_app.push_widget(alert_dialog(tr("Fetching Latest Models")))))
 
     self.clear_cache_item = ListItemSP(
       title=tr("Clear Model Cache"),
       description="",
-      action_item=NoElideButtonAction(lambda: tr("CLEARING...") if self._clearing else tr("CLEAR")),
+      action_item=NoElideButtonAction(tr("CLEAR")),
       callback=self._clear_cache
     )
 
@@ -116,38 +115,39 @@ class ModelsLayout(Widget):
     if lagd_toggle:
       desc += f"<br>{tr('Live Steer Delay:')} {ui_state.sm['lateralDelay'].lateralDelay:.3f} s"
     elif ui_state.CP is not None:
-      sw = float(ui_state.params.get("LagdToggleDelay", return_default=True))
+      sw = float(ui_state.params.get("LagdToggleDelay", "0.2"))
       cp = ui_state.CP.steerActuatorDelay
       desc += f"<br>{tr('Actuator Delay:')} {cp:.2f} s + {tr('Software Delay:')} {sw:.2f} s = {tr('Total Delay:')} {cp + sw:.2f} s"
     self.lagd_toggle.set_description(desc)
 
   @staticmethod
   def calculate_cache_size():
-    return model_cache_size_mb()
+    cache_size = 0.0
+    if os.path.exists(CUSTOM_MODEL_PATH):
+      for file in os.listdir(CUSTOM_MODEL_PATH):
+        try:
+          cache_size += os.path.getsize(os.path.join(CUSTOM_MODEL_PATH, file))
+        except OSError:
+          continue
+    return cache_size / (1024**2)
 
   def _clear_cache(self):
     def _callback(response):
       if response == DialogResult.CONFIRM:
         ui_state.params.put_bool("ModelManager_ClearCache", True)
+        self.clear_cache_item.action_item.set_value(f"{self.calculate_cache_size():.2f} MB")
 
     dialog = ConfirmDialog(tr("This will delete ALL downloaded models from the cache except the currently active model. Are you sure?"),
                            tr("Clear Cache"), callback=_callback)
     gui_app.push_widget(dialog)
 
-  def _refresh_models(self):
-    refresh_model_list()
-    self._refresh_start = time.monotonic()
-
   def _handle_bundle_download_progress(self):
     self.cancel_download_item.set_visible(False)
     self._downloading = False
     self._verifying = False
     self.download_item.set_visible(True)
 
-    self._clearing = ui_state.params.get_bool("ModelManager_ClearCache")
-    if self._clearing:
-      self.last_cache_calc_time = 0.0  # refresh the size as soon as clearing finishes
-    elif (current_time := time.monotonic()) - self.last_cache_calc_time > 0.5:
+    if (current_time := time.monotonic()) - self.last_cache_calc_time > 0.5:
       self.last_cache_calc_time = current_time
       self.clear_cache_item.action_item.set_value(f"{self.calculate_cache_size():.2f} MB")
 
@@ -345,13 +345,6 @@ class ModelsLayout(Widget):
     self.big_model_item.action_item.set_enabled(offroad)
     self.small_model_item.set_description("" if offroad else tr("Only available when vehicle is off, or always offroad mode is on"))
 
-    # manager is offroad-only, so an onroad clear would never be serviced
-    self.clear_cache_item.action_item.set_enabled(offroad and not self._downloading and not self._clearing)
-
-    # manager is offroad-only, so a refresh queued onroad would never be serviced
-    self._refreshing = refresh_in_progress(self._refresh_start)
-    self.refresh_item.action_item.set_enabled(offroad and not self._downloading and not self._refreshing)
-
   def _render(self, rect):
     self._scroller.render(rect)
 

openpilot/selfdrive/ui/sunnypilot/layouts/settings/sunnylink.py

@@ -5,22 +5,42 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 import pyray as rl
+from functools import partial
 from openpilot.cereal import custom
+from openpilot.common.version import sunnylink_consent_version
 from openpilot.selfdrive.ui.sunnypilot.layouts.onboarding import SunnylinkConsentPage
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
+from openpilot.sunnypilot.sunnylink.athena.local_discovery import latest_discovered_app
+from openpilot.sunnypilot.sunnylink.athena.local_pairing import (
+  LocalApp,
+  arm_pairing,
+  clear_pairing_request,
+  get_local_apps,
+  local_app_display_name,
+  pairing_requested,
+  read_pairing_code,
+  remove_local_app,
+)
 from openpilot.system.ui.lib.application import gui_app, FontWeight, TextAlignment, TextAlignmentVertical
 from openpilot.system.ui.lib.multilang import tr
-from openpilot.system.ui.sunnypilot.widgets.list_view import button_item_sp
-from openpilot.system.ui.sunnypilot.widgets.list_view import toggle_item_sp
+from openpilot.system.ui.lib.text_measure import measure_text_cached
+from openpilot.system.ui.lib.wrap_text import wrap_text
+from openpilot.system.ui.sunnypilot.widgets.list_view import ListItemSP, button_item_sp, toggle_item_sp
 from openpilot.system.ui.sunnypilot.widgets.sunnylink_pairing_dialog import SunnylinkPairingDialog
 from openpilot.system.ui.widgets import Widget, DialogResult
-from openpilot.system.ui.widgets.button import ButtonStyle, Button
+from openpilot.system.ui.widgets.button import ButtonStyle, Button, IconButton
 from openpilot.system.ui.widgets.confirm_dialog import alert_dialog, ConfirmDialog
 from openpilot.system.ui.widgets.label import UnifiedLabel
 from openpilot.system.ui.widgets.list_view import dual_button_item
+from openpilot.system.ui.widgets.network import NavButton
 from openpilot.system.ui.widgets.scroller_tici import Scroller, LineSeparator
-from openpilot.common.version import sunnylink_consent_version
+
+MAX_LOCAL_APPS = 4
+
+# Read-only value colors used by the local-mode rows.
+_LOCAL_DISCOVERED_COLOR = rl.Color(170, 170, 170, 255)  # grey: no app in sight
+_LOCAL_ACTIVE_COLOR = rl.Color(0, 255, 0, 255)          # green: discovered / pairing code
 
 
 class SunnylinkHeader(Widget):
@@ -192,6 +212,15 @@ class SunnylinkLayout(Widget):
     self._backup_btn.set_button_style(ButtonStyle.NORMAL)
     self._restore_btn.set_button_style(ButtonStyle.PRIMARY)
 
+    self._mobile_app_btn = button_item_sp(
+      title=tr("Sunnylink Local Connections"),
+      button_text=tr("CONFIGURE"),
+      description=tr("Manage the mobile app(s) connected over Wi-Fi: pair a new app ") +
+                  tr("or unpair existing ones."),
+      callback=self._open_local_apps,
+    )
+    self._mobile_app_btn.set_visible(lambda: self._sunnylink_enabled)
+
     items = [
       SunnylinkHeader(),
       LineSeparator(),
@@ -202,9 +231,11 @@ class SunnylinkLayout(Widget):
       LineSeparator(),
       self._pair_btn,
       LineSeparator(),
+      self._mobile_app_btn,
+      LineSeparator(),
       self._sunnylink_uploader_toggle,
       LineSeparator(),
-      self._sunnylink_backup_restore_buttons
+      self._sunnylink_backup_restore_buttons,
     ]
     return items
 
@@ -317,6 +348,8 @@ class SunnylinkLayout(Widget):
       gui_app.push_widget(sl_terms_dlg)
     else:
       ui_state.params.put_bool("SunnylinkEnabled", state)
+      if not state:
+        clear_pairing_request()
       self._update_description(state)
 
   def _update_description(self, state: bool):
@@ -352,6 +385,9 @@ class SunnylinkLayout(Widget):
     self._pair_btn.action_item.set_text(pair_btn_text)
     self._pair_btn.action_item.set_enabled(self._sunnylink_enabled)
 
+  def _open_local_apps(self):
+    gui_app.push_widget(SunnylinkLocalAppLayout())
+
   def _render(self, rect):
     self._scroller.render(rect)
 
@@ -364,3 +400,157 @@ class SunnylinkLayout(Widget):
   def hide_event(self):
     super().hide_event()
     ui_state.sunnylink_state.set_settings_open(False)
+
+
+class SunnylinkLocalAppLayout(Widget):
+
+  def __init__(self):
+    super().__init__()
+    self._local_apps_cache: list[LocalApp] = []
+
+    self._back_button = NavButton(tr("Back"))
+    self._back_button.set_click_callback(gui_app.pop_widget)
+
+    self._pair_app_btn = button_item_sp(
+      title=tr("Pair App"),
+      button_text=tr("PAIR"),
+      description=tr("Open a 5-minute pairing window and show the code to ") +
+                  tr("type into the app. Closing the dialog cancels pairing."),
+      callback=self._show_pairing_code_dialog,
+    )
+
+    self._local_app_rows: list[ListItemSP] = []
+    self._local_app_seps: list[LineSeparator] = []
+    for i in range(MAX_LOCAL_APPS):
+      row = button_item_sp(
+        title=lambda i=i: self._local_app_title(i),
+        button_text=tr("UNPAIR"),
+        description=lambda i=i: self._local_app_endpoint(i),
+        callback=partial(self._unpair_local_app, i),
+      )
+      sep = LineSeparator()
+      row.set_visible(lambda i=i: self._local_row_visible(i))
+      sep.set_visible(lambda i=i: self._local_row_visible(i))
+      self._local_app_rows.append(row)
+      self._local_app_seps.append(sep)
+
+    items = [self._pair_app_btn, LineSeparator()]
+    for row, sep in zip(self._local_app_rows, self._local_app_seps, strict=True):
+      items.extend((row, sep))
+    self._scroller = Scroller(items, line_separator=False, spacing=0)
+
+  def _local_row_visible(self, i: int) -> bool:
+    return i < len(self._local_apps_cache)
+
+  def _local_app_title(self, i: int) -> str:
+    if i >= len(self._local_apps_cache):
+      return ""
+    return local_app_display_name(self._local_apps_cache[i])
+
+  def _local_app_endpoint(self, i: int) -> str:
+    if i >= len(self._local_apps_cache):
+      return ""
+    return self._local_apps_cache[i].endpoint
+
+  def _show_pairing_code_dialog(self):
+    gui_app.push_widget(SunnylinkLocalPairingDialog())
+
+  def _unpair_local_app(self, index: int):
+    apps = self._local_apps_cache
+    if index >= len(apps):
+      return
+    app = apps[index]
+    name = local_app_display_name(app)
+
+    def on_confirm(_dialog_result: int):
+      remove_local_app(app.app_id)
+
+    dialog = ConfirmDialog(
+      text=tr("Unpair") + f" {name}? " + tr("You will need the pairing code again to reconnect it."),
+      confirm_text=tr("Unpair"),
+      callback=on_confirm,
+    )
+    gui_app.push_widget(dialog)
+
+  def _update_state(self):
+    super()._update_state()
+    self._local_apps_cache = get_local_apps()
+
+  def _render(self, rect):
+    self._back_button.set_position(self._rect.x, self._rect.y + 20)
+    self._back_button.render()
+    content_rect = rl.Rectangle(rect.x, rect.y + self._back_button.rect.height + 40,
+                                rect.width, rect.height - self._back_button.rect.height - 40)
+    self._scroller.render(content_rect)
+
+  def show_event(self):
+    super().show_event()
+    self._scroller.show_event()
+
+  def hide_event(self):
+    super().hide_event()
+    self._scroller.hide_event()
+
+
+class SunnylinkLocalPairingDialog(Widget):
+
+  def __init__(self):
+    super().__init__()
+    self._apps_before = len(get_local_apps())
+    arm_pairing()
+    self._close_btn = IconButton(gui_app.texture("icons/close.png", 80, 80))
+    self._close_btn.set_click_callback(self._cancel)
+
+  def _cancel(self):
+    clear_pairing_request()
+    gui_app.pop_widget()
+
+  def _update_state(self):
+    if len(get_local_apps()) > self._apps_before:
+      gui_app.pop_widget()  # paired — window already cleared
+    elif not pairing_requested():
+      gui_app.pop_widget()  # window expired
+
+  def _render(self, rect) -> int:
+    rl.clear_background(rl.Color(224, 224, 224, 255))
+
+    margin = 70
+    content_rect = rl.Rectangle(rect.x + margin, rect.y + margin,
+                                rect.width - 2 * margin, rect.height - 2 * margin)
+    y = content_rect.y
+
+    close_size = 80
+    pad = 20
+    close_rect = rl.Rectangle(content_rect.x - pad, y - pad, close_size + pad * 2, close_size + pad * 2)
+    self._close_btn.render(close_rect)
+    y += close_size + 40
+
+    title_font = gui_app.font(FontWeight.NORMAL)
+    title_wrapped = wrap_text(title_font, tr("Pair with mobile app"), 75, int(content_rect.width))
+    rl.draw_text_ex(title_font, "\n".join(title_wrapped), rl.Vector2(content_rect.x, y), 75, 0.0, rl.BLACK)
+    y += len(title_wrapped) * 75 + 40
+
+    code = read_pairing_code() or "—"
+    code_font = gui_app.font(FontWeight.BOLD)
+    code_size = measure_text_cached(code_font, code, 110)
+    rl.draw_text_ex(code_font, code, rl.Vector2(content_rect.x + (content_rect.width - code_size.x) / 2, y),
+                    110, 0.0, rl.BLACK)
+    y += 170
+
+    hint_font = gui_app.font(FontWeight.NORMAL)
+    hint_wrapped = wrap_text(hint_font, tr("Enter this code in the sunnylink app on your phone."), 45,
+                             int(content_rect.width))
+    rl.draw_text_ex(hint_font, "\n".join(hint_wrapped), rl.Vector2(content_rect.x, y), 45, 0.0, rl.BLACK)
+    y += len(hint_wrapped) * 45 + 30
+
+    discovered = latest_discovered_app()
+    if discovered is not None:
+      endpoint, age = discovered
+      status = endpoint if age < 2 else f"{endpoint} ({age}s)"
+      color = _LOCAL_ACTIVE_COLOR
+    else:
+      status = tr("Waiting for the app…")
+      color = _LOCAL_DISCOVERED_COLOR
+    status_font = gui_app.font(FontWeight.NORMAL)
+    rl.draw_text_ex(status_font, status, rl.Vector2(content_rect.x, y), 40, 0.0, color)
+    return -1

openpilot/selfdrive/ui/sunnypilot/mici/layouts/models.py

@@ -4,18 +4,15 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
-import time
-
 import pyray as rl
 
 from openpilot.cereal import custom
-from openpilot.selfdrive.ui.mici.widgets.dialog import BigConfirmationDialog, BigDialog
+from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog
 from openpilot.sunnypilot.models.helpers import ACTIVE_BUNDLE_KEYS, get_selected_bundle
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton
 from openpilot.selfdrive.ui.ui_state import ui_state, device
 from openpilot.selfdrive.ui.sunnypilot.model_info import (active_source, big_model_state, bundles_for_source, carrying_model,
-                                                           default_model_name, model_cache_size_mb, model_info, queued_name,
-                                                           refresh_in_progress, refresh_model_list)
+                                                           default_model_name, model_info, queued_name)
 from openpilot.system.ui.lib.application import FontWeight, gui_app
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.widgets import Widget
@@ -84,18 +81,10 @@ class ModelsLayoutMici(NavScroller):
     self.select_model_btn = BigButton(tr("select model"))
     self.select_model_btn.set_click_callback(self._show_folders)
 
-    self.refresh_btn = BigButton(tr("refresh models"))
-    self.refresh_btn.set_click_callback(self._refresh_models)
-    self._refresh_start: float | None = None
-
     self.cancel_download_btn = BigButton(tr("cancel download"))
     self.cancel_download_btn.set_click_callback(lambda: ui_state.params.remove("ModelManager_DownloadRef"))
 
-    self.clear_cache_btn = BigButton(tr("clear cache"), value=f"{model_cache_size_mb():.1f} MB")
-    self.clear_cache_btn.set_click_callback(self._confirm_clear_cache)
-    self._cache_size_time = 0.0
-
-    self.main_items = [self.current_model_info, self.select_model_btn, self.cancel_download_btn, self.refresh_btn, self.clear_cache_btn]
+    self.main_items = [self.current_model_info, self.select_model_btn, self.cancel_download_btn]
     self._scroller.add_widgets(self.main_items)
 
   @property
@@ -173,15 +162,6 @@ class ModelsLayoutMici(NavScroller):
     ui_state.params.remove(ACTIVE_BUNDLE_KEYS[source])
     self._pop_to_main()
 
-  def _confirm_clear_cache(self):
-    icon = gui_app.texture("icons_mici/settings/network/new/trash.png", 54, 64)
-    gui_app.push_widget(BigConfirmationDialog(f"{tr('slide to')}\n{tr('clear cache')}", icon,
-                                              lambda: ui_state.params.put_bool("ModelManager_ClearCache", True), red=True))
-
-  def _refresh_models(self):
-    refresh_model_list()
-    self._refresh_start = time.monotonic()
-
   def _select_folder(self, folder_name):
     source = self._selection_source
     if source is None:  # folders are only reachable after picking a hardware
@@ -225,21 +205,6 @@ class ModelsLayoutMici(NavScroller):
       device.set_override_interactive_timeout(None)
     self._was_downloading = is_downloading
 
-    # manager is offroad-only, so an onroad clear would never be serviced
-    clearing = ui_state.params.get_bool("ModelManager_ClearCache")
-    self.clear_cache_btn.set_enabled(ui_state.is_offroad() and not is_downloading and not clearing)
-    if clearing:
-      self.clear_cache_btn.set_value(tr("clearing..."))
-      self._cache_size_time = 0.0  # refresh the size as soon as clearing finishes
-    elif (now := time.monotonic()) - self._cache_size_time > 0.5:
-      self._cache_size_time = now
-      self.clear_cache_btn.set_value(f"{model_cache_size_mb():.1f} MB")
-
-    # manager is offroad-only, so a refresh queued onroad would never be serviced
-    refreshing = refresh_in_progress(self._refresh_start)
-    self.refresh_btn.set_enabled(ui_state.is_offroad() and not is_downloading and not refreshing)
-    self.refresh_btn.set_value(tr("fetching...") if refreshing else "")
-
     self.current_model_info.current_model_header.set_text(tr("active model"))
     active_text, info_header, info_text = _model_info()
     self.current_model_info.current_model_text.set_text(active_text)

openpilot/selfdrive/ui/sunnypilot/mici/layouts/sunnylink.py

@@ -5,21 +5,34 @@ This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
 import pyray as rl
-
+from functools import partial
 
 from openpilot.cereal import custom
+from openpilot.common.version import sunnylink_consent_version, sunnylink_consent_declined
 from openpilot.selfdrive.ui.mici.widgets.button import BigButton, BigToggle
-from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog, BigConfirmationDialog
+from openpilot.selfdrive.ui.mici.widgets.dialog import BigDialog, BigConfirmationDialog, BigDialogBase
 from openpilot.selfdrive.ui.sunnypilot.mici.layouts.onboarding import SunnylinkConsentPage
 from openpilot.selfdrive.ui.sunnypilot.mici.widgets.sunnylink_pairing_dialog import SunnylinkPairingDialog
 from openpilot.selfdrive.ui.ui_state import ui_state
 from openpilot.sunnypilot.sunnylink.api import UNREGISTERED_SUNNYLINK_DONGLE_ID
+from openpilot.sunnypilot.sunnylink.athena.local_discovery import latest_discovered_app
+from openpilot.sunnypilot.sunnylink.athena.local_pairing import (
+  LocalApp,
+  arm_pairing,
+  clear_pairing_request,
+  get_local_apps,
+  local_app_display_name,
+  pairing_requested,
+  read_pairing_code,
+  remove_local_app,
+)
 from openpilot.system.ui.lib.application import gui_app, MousePos, FontWeight
 from openpilot.system.ui.lib.multilang import tr
 from openpilot.system.ui.widgets import Widget
 from openpilot.system.ui.widgets.label import UnifiedLabel
 from openpilot.system.ui.widgets.scroller import NavScroller
-from openpilot.common.version import sunnylink_consent_version, sunnylink_consent_declined
+
+MAX_LOCAL_APPS = 4
 
 class SunnylinkInfo(Widget):
   def __init__(self):
@@ -73,11 +86,15 @@ class SunnylinkLayoutMici(NavScroller):
     self._sunnylink_uploader_toggle = BigToggle(text=tr("sunnylink uploader"), initial_state=False,
                                                 toggle_callback=self._sunnylink_uploader_callback)
 
+    self._mobile_app_btn = BigButton(tr("sunnylink local"), "")
+    self._mobile_app_btn.set_click_callback(lambda: gui_app.push_widget(LocalAppsPanelMici()))
+
     self._scroller.add_widgets([
       self._sunnylink_info,
       self._sunnylink_toggle,
       self._sunnylink_sponsor_button,
       self._sunnylink_pair_button,
+      self._mobile_app_btn,
       self._backup_btn,
       self._restore_btn,
       self._sunnylink_uploader_toggle
@@ -110,6 +127,7 @@ class SunnylinkLayoutMici(NavScroller):
       self._sunnylink_pair_button.set_text(tr("paired"))
     else:
       self._sunnylink_pair_button.set_text(tr("pair"))
+    self._mobile_app_btn.set_visible(self._sunnylink_enabled)
 
   def show_event(self):
     super().show_event()
@@ -140,6 +158,8 @@ class SunnylinkLayoutMici(NavScroller):
       gui_app.push_widget(sl_terms_dlg)
     else:
       ui_state.params.put_bool("SunnylinkEnabled", state)
+      if not state:
+        clear_pairing_request()
 
     ui_state.update_params()
 
@@ -252,3 +272,108 @@ class SunnylinkPairBigButton(BigButton):
       dlg = SunnylinkPairingDialog(sponsor_pairing=False)
     if dlg:
       gui_app.push_widget(dlg)
+
+
+class LocalAppsPanelMici(NavScroller):
+
+  def __init__(self):
+    super().__init__()
+    self._local_apps_cache: list[LocalApp] = []
+
+    self._pair_app_btn = BigButton(tr("pair app"), "")
+    self._pair_app_btn.set_click_callback(lambda: gui_app.push_widget(LocalPairingCodeDialogMici()))
+
+    self._local_app_btns: list[BigButton] = []
+    for i in range(MAX_LOCAL_APPS):
+      btn = BigButton("", "")
+      btn.set_click_callback(partial(self._confirm_unpair_local_app, i))
+      self._local_app_btns.append(btn)
+
+    self._scroller.add_widgets([self._pair_app_btn, *self._local_app_btns])
+
+  def _update_state(self):
+    super()._update_state()
+    self._local_apps_cache = get_local_apps()
+    for i, btn in enumerate(self._local_app_btns):
+      btn.set_visible(i < len(self._local_apps_cache))
+      if i < len(self._local_apps_cache):
+        app = self._local_apps_cache[i]
+        btn.set_text(local_app_display_name(app))
+        btn.set_value(app.endpoint)
+
+  def _confirm_unpair_local_app(self, index: int):
+    apps = self._local_apps_cache
+    if index >= len(apps):
+      return
+    app = apps[index]
+
+    def unpair():
+      remove_local_app(app.app_id)
+
+    icon = gui_app.texture("icons_mici/settings/device/update.png", 64, 64)
+    dlg = BigConfirmationDialog(
+      tr("slide to unpair"),
+      icon,
+      confirm_callback=unpair,
+      red=True,
+    )
+    gui_app.push_widget(dlg)
+
+
+class LocalPairingCodeDialogMici(BigDialogBase):
+
+  def __init__(self):
+    super().__init__()
+    self._apps_before = len(get_local_apps())
+    arm_pairing()
+    self.set_back_callback(clear_pairing_request)
+
+    header_color = rl.Color(255, 255, 255, int(255 * 0.9))
+    subheader_color = rl.Color(255, 255, 255, int(255 * 0.9 * 0.65))
+    self._title = UnifiedLabel(tr("pair with mobile app"), font_size=48, font_weight=FontWeight.BOLD,
+                               text_color=header_color, line_height=0.8)
+    self._code_label = UnifiedLabel("", font_size=110, font_weight=FontWeight.DISPLAY,
+                                    text_color=rl.Color(0, 255, 0, 255))
+    self._hint = UnifiedLabel(tr("enter this code in the sunnylink app"), font_size=32,
+                              text_color=subheader_color, line_height=0.9)
+    self._status = UnifiedLabel("", font_size=28,
+                                text_color=rl.Color(255, 255, 255, int(255 * 0.45)), line_height=0.9)
+
+  def _update_state(self):
+    super()._update_state()
+    if self.is_dismissing:
+      return
+    if len(get_local_apps()) > self._apps_before:
+      self.dismiss()  # paired — window already cleared
+    elif not pairing_requested():
+      self.dismiss()  # window expired
+
+  def _render(self, _):
+    self._code_label.set_text(read_pairing_code() or "—")
+
+    discovered = latest_discovered_app()
+    if discovered is not None:
+      endpoint, age = discovered
+      self._status.set_text(endpoint if age < 2 else f"{endpoint} ({age}s)")
+      self._status.set_text_color(rl.Color(0, 255, 0, 255))
+    else:
+      self._status.set_text(tr("waiting for the app…"))
+      self._status.set_text_color(rl.Color(255, 255, 255, int(255 * 0.45)))
+
+    x = self._rect.x + 20
+    width = int(self._rect.width - 40)
+    self._title.set_max_width(width)
+    self._title.set_position(x, self._rect.y + 40)
+    self._title.render()
+
+    self._code_label.set_max_width(width)
+    self._code_label.set_position(x, self._rect.y + 130)
+    self._code_label.render()
+
+    self._hint.set_max_width(width)
+    self._hint.set_position(x, self._rect.y + 290)
+    self._hint.render()
+
+    self._status.set_max_width(width)
+    self._status.set_position(x, self._rect.y + 360)
+    self._status.render()

openpilot/selfdrive/ui/sunnypilot/model_info.py

@@ -4,28 +4,12 @@ Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
 This file is part of sunnypilot and is licensed under the MIT License.
 See the LICENSE.md file in the root directory for more details.
 """
-import contextlib
-import os
-import time
-
-from openpilot.common.hardware.hw import Paths
 from openpilot.selfdrive.ui.ui_state import ui_state, ChestnutState
 from openpilot.sunnypilot.models.fetcher import get_cached_bundles
 from openpilot.sunnypilot.models.helpers import get_active_source, get_selected_bundle, resolve_bundle_by_ref
 from openpilot.sunnypilot.models.model_name import DEFAULT_BIG_MODEL, DEFAULT_MODEL
 
 
-def model_cache_size_mb() -> float:
-  """Bytes on disk under the model cache directory, in MB."""
-  model_root = Paths.model_root()
-  total = 0
-  if os.path.isdir(model_root):
-    for name in os.listdir(model_root):
-      with contextlib.suppress(OSError):
-        total += os.path.getsize(os.path.join(model_root, name))
-  return total / (1024 ** 2)
-
-
 def active_source() -> str:
   return get_active_source(chestnut=ui_state.chestnut_present,
                            chestnut_active=ui_state.chestnut_active, chestnut_loading=ui_state.chestnut_loading,
@@ -99,22 +83,3 @@ def model_info() -> tuple[str, str, str]:
   active_name = active_bundle.displayName if active_bundle else default_model_name(source)
   other_name = other_bundle.displayName if other_bundle else default_model_name(other)
   return source, active_name, other_name
-
-
-# mirrors the manager's ModelCache keys; the manager restamps them on a successful fetch
-MODEL_SYNC_KEYS = ("ModelManager_LastSyncTime", "ModelManager_LastSyncTime_Chestnut")
-MODEL_SYNC_TIMEOUT = 20.0
-
-
-def refresh_model_list() -> None:
-  # zeroing the sync keys makes the manager refetch each manifest on its next tick
-  for key in MODEL_SYNC_KEYS:
-    ui_state.params.put(key, 0)
-
-
-def refresh_in_progress(started_at: float | None) -> bool:
-  """Whether a user refresh is still outstanding. A failed fetch never restamps the
-  sync keys, so the spinner is bounded by MODEL_SYNC_TIMEOUT rather than sticking."""
-  if started_at is None or time.monotonic() - started_at > MODEL_SYNC_TIMEOUT:
-    return False
-  return not all(ui_state.params.get(key) for key in MODEL_SYNC_KEYS)

openpilot/sunnypilot/modeld_v2/camera_offset_helper.py

@@ -15,19 +15,11 @@ class CameraOffsetHelper:
     self.actual_camera_offset = 0.0
 
   @staticmethod
-  def get_v_horizon(intrinsics, rpy_calib):
+  def apply_camera_offset(model_transform, intrinsics, height, offset_param):
     cy = intrinsics[1, 2]
-    if len(rpy_calib) == 3 and np.isfinite(rpy_calib).all():
-      fy = intrinsics[1, 1]
-      pitch = rpy_calib[1]
-      return float(cy - fy * np.tan(pitch))
-    return float(cy)
-
-  @staticmethod
-  def apply_camera_offset(model_transform, height, offset_param, v_horizon):
     shear = np.eye(3, dtype=np.float32)
     shear[0, 1] = offset_param / height
-    shear[0, 2] = -offset_param / height * v_horizon
+    shear[0, 2] = -offset_param / height * cy
     model_transform = (shear @ model_transform).astype(np.float32)
     return model_transform
 
@@ -38,13 +30,10 @@ class CameraOffsetHelper:
     self.actual_camera_offset = (0.9 * self.actual_camera_offset) + (0.1 * self.camera_offset)
     dc = DEVICE_CAMERAS[(str(sm['deviceState'].deviceType), str(sm['narrowRoadCameraState'].sensor))]
     height = sm["extrinsicsCalibration"].height[0] if sm['extrinsicsCalibration'].height else 1.22
-    rpy_calib = sm['extrinsicsCalibration'].rpyCalib
 
     intrinsics_main = dc.wide_road.intrinsics if main_wide_camera else dc.narrow_road.intrinsics
-    v_horizon_main = self.get_v_horizon(intrinsics_main, rpy_calib)
-    model_transform_main = self.apply_camera_offset(model_transform_main, height, self.actual_camera_offset, v_horizon_main)
+    model_transform_main = self.apply_camera_offset(model_transform_main, intrinsics_main, height, self.actual_camera_offset)
 
     intrinsics_extra = dc.wide_road.intrinsics
-    v_horizon_extra = self.get_v_horizon(intrinsics_extra, rpy_calib)
-    model_transform_extra = self.apply_camera_offset(model_transform_extra, height, self.actual_camera_offset, v_horizon_extra)
+    model_transform_extra = self.apply_camera_offset(model_transform_extra, intrinsics_extra, height, self.actual_camera_offset)
     return model_transform_main, model_transform_extra

openpilot/sunnypilot/modeld_v2/helpers.py

@@ -1,100 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import io
-import struct
-import pickle
-import inspect
-import importlib
-import enum
-
-
-def _pad_args(func, args, kwargs):
-  try:
-    sig = inspect.signature(func)
-  except Exception:
-    return args, kwargs
-  params = list(sig.parameters.values())
-  if inspect.isfunction(func) and params and params[0].name in ('cls', 'self'):
-    params = params[1:]
-
-  new_args = list(args)
-  has_varargs = any(p.kind == inspect.Parameter.VAR_POSITIONAL for p in params)
-  if len(new_args) > len(params) and not has_varargs:
-    new_args = new_args[:len(params)]
-
-  for i in range(len(new_args), len(params)):
-    param = params[i]
-    if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
-      continue
-    val = param.default if param.default is not inspect.Parameter.empty else None
-    new_args.append(val)
-  return new_args, kwargs
-
-
-def _enum_factory(enum_class):
-  def factory(*args, **kwargs):
-    try:
-      return enum_class(*args, **kwargs)
-    # OptOps and UOp objects in the .pkl are left over from the compilation phase,
-    # reassignment does nothing because they aren't tied to the execution graph
-    # It never executes or evaluates the UOp nodes again.
-    except ValueError:
-      return list(enum_class)[0]
-  factory.__name__ = enum_class.__name__
-  factory.__module__ = enum_class.__module__
-  return factory
-
-
-def _dynamic_factory(real_class):
-  if isinstance(real_class, type) and issubclass(real_class, enum.Enum):
-    return _enum_factory(real_class)
-
-  def factory(*args, **kwargs):
-    try:
-      return real_class(*args, **kwargs)
-    except TypeError:
-      new_args, new_kwargs = _pad_args(real_class, args, kwargs)
-      return real_class(*new_args, **new_kwargs)
-
-  class DynamicMeta(type(real_class)):
-    def __call__(cls, *args, **kwargs):
-      return factory(*args, **kwargs)
-
-  class DynamicProxy(real_class, metaclass=DynamicMeta):
-    __slots__ = ()
-
-    def __new__(cls, *args, **kwargs):
-      return factory(*args, **kwargs)
-
-  DynamicProxy.__name__ = real_class.__name__
-  DynamicProxy.__module__ = real_class.__module__
-  return DynamicProxy
-
-
-class DynamicTinygradUnpickler(pickle.Unpickler):
-  def find_class(self, module, name):
-    if module == "tinygrad.ops":
-      try:
-        importlib.import_module("tinygrad.uops")
-        module = "tinygrad.uops"
-      except ImportError:
-        pass
-    real_class = getattr(importlib.import_module(module), name)
-    if module.startswith("tinygrad"):
-      return _dynamic_factory(real_class)
-    return real_class
-
-
-def load_oob(f):
-  opcodes = f.read(struct.unpack('<q', f.read(8))[0])
-  def buffers():
-    while (h := f.read(8)):
-      pb = pickle.PickleBuffer(bytearray(struct.unpack('<q', h)[0]))
-      f.readinto(pb)
-      yield pb
-  return DynamicTinygradUnpickler(io.BytesIO(opcodes), buffers=buffers()).load()

openpilot/sunnypilot/modeld_v2/modeld.py

@@ -17,7 +17,7 @@ from tinygrad.tensor import Tensor
 
 import openpilot.cereal.messaging as messaging
 from openpilot.common.hardware import COMMA_HARDWARE
-from openpilot.selfdrive.modeld.helpers import chestnut_present
+from openpilot.selfdrive.modeld.helpers import chestnut_present, load_oob
 from openpilot.cereal import log
 from opendbc.car.structs import car
 from openpilot.cereal.services import SERVICE_LIST
@@ -52,7 +52,6 @@ from openpilot.sunnypilot.modeld_v2.compile_modeld import (derive_frame_skip, ma
                                                            WARP_INPUTS, POLICY_INPUTS)
 from openpilot.sunnypilot.livedelay.helpers import get_lat_delay
 from openpilot.sunnypilot.modeld_v2.modeld_base import ModelStateBase
-from openpilot.sunnypilot.modeld_v2.helpers import load_oob
 from openpilot.sunnypilot.models.helpers import get_active_bundle
 from openpilot.sunnypilot.selfdrive.controls.lib.relc import RoadEdgeLaneChangeController
 
@@ -552,7 +551,6 @@ def main(demo=False):
       DH.update(sm['carState'], sm['carControl'].latActive, lane_change_prob, left_edge, right_edge)
       modelv2_send.modelV2.meta.laneChangeState = DH.lane_change_state
       modelv2_send.modelV2.meta.laneChangeDirection = DH.lane_change_direction
-      mdv2sp_send.valid = modelv2_send.valid
       mdv2sp_send.modelDataV2SP.laneTurnDirection = DH.lane_turn_direction
       drivingdata_send.drivingModelData.meta.laneChangeState = DH.lane_change_state
       drivingdata_send.drivingModelData.meta.laneChangeDirection = DH.lane_change_direction

openpilot/sunnypilot/modeld_v2/tests/test_camera_offset_helper.py

@@ -6,9 +6,8 @@ See the LICENSE.md file in the root directory for more details.
 """
 import numpy as np
 
-from openpilot.common.transformations.camera import DEVICE_CAMERAS, view_frame_from_device_frame
+from openpilot.common.transformations.camera import DEVICE_CAMERAS
 from openpilot.common.transformations.model import get_warp_matrix
-from openpilot.common.transformations.orientation import rot_from_euler
 from openpilot.sunnypilot.modeld_v2.camera_offset_helper import CameraOffsetHelper
 from openpilot.common.test import OpenpilotTestCase
 
@@ -47,50 +46,29 @@ class TestCameraOffset(OpenpilotTestCase):
     self.camera_offset.update(main_transform, extra_transform, sm, False)
     np.testing.assert_almost_equal(self.camera_offset.actual_camera_offset, 0.038)
 
-  def test_apply_camera_offset(self):
+  def test_camera_offset_(self):
     intrinsics = self.dc.narrow_road.intrinsics
-    v_horizon = CameraOffsetHelper.get_v_horizon(intrinsics, [])  # pitch = 0 fallback: v_horizon == cy
     transform = np.eye(3, dtype=np.float32)
     height = 1.22
     offset = 0.1
 
+    cy = intrinsics[1, 2]
     expected_shear = np.eye(3, dtype=np.float32)
     expected_shear[0, 1] = offset / height
-    expected_shear[0, 2] = -offset / height * v_horizon
+    expected_shear[0, 2] = -offset / height * cy
 
-    result = CameraOffsetHelper.apply_camera_offset(transform, height, offset, v_horizon)
+    result = CameraOffsetHelper.apply_camera_offset(transform, intrinsics, height, offset)
     np.testing.assert_array_almost_equal(result, expected_shear)
 
-  def test_v_horizon_empty_rpy(self):
-    intrinsics = self.dc.narrow_road.intrinsics
-    v_horizon = CameraOffsetHelper.get_v_horizon(intrinsics, [])
-    np.testing.assert_almost_equal(v_horizon, intrinsics[1, 2])
-
-  def test_v_horizon_projection(self):
-    intrinsics = self.dc.narrow_road.intrinsics
-    f, cy = intrinsics[1, 1], intrinsics[1, 2]
-
-    for pitch_deg in [6.0, -6.0, 0.0]:
-      rpy = [0.0, np.radians(pitch_deg), 0.0]
-      d_dev = rot_from_euler(rpy) @ np.array([1.0, 0.0, 0.0])
-      view = view_frame_from_device_frame @ d_dev
-      expected = cy + f * view[1] / view[2]
-
-      v_horizon = CameraOffsetHelper.get_v_horizon(intrinsics, rpy)
-      np.testing.assert_almost_equal(v_horizon, expected, decimal=4)
-
   def test_update(self):
-    height = 1.2
-    pitch = np.radians(-8.0)
-
     sm = MockStruct(
       deviceState=MockStruct(deviceType='mici'),
       narrowRoadCameraState=MockStruct(sensor='os04c10'),
-      extrinsicsCalibration=MockStruct(rpyCalib=[0.0, pitch, 0.0], height=[height])
+      extrinsicsCalibration=MockStruct(rpyCalib=[0.0, 0.0, 0.0], height=[1.22])
     )
     intrinsics_main = self.dc.narrow_road.intrinsics
     intrinsics_extra = self.dc.wide_road.intrinsics
-    device_from_calib_euler = np.array(sm['extrinsicsCalibration'].rpyCalib, dtype=np.float32)
+    device_from_calib_euler = np.array([0.0, 0.0, 0.0], dtype=np.float32)
     main_transform = get_warp_matrix(device_from_calib_euler, intrinsics_main, False).astype(np.float32)
     extra_transform = get_warp_matrix(device_from_calib_euler, intrinsics_extra, True).astype(np.float32)
 
@@ -103,13 +81,5 @@ class TestCameraOffset(OpenpilotTestCase):
     main_out, extra_out = self.camera_offset.update(main_transform, extra_transform, sm, False)
     assert not np.array_equal(main_out, main_transform)
     assert not np.array_equal(extra_out, extra_transform)
-
-    # settle the low-pass filter
-    for _ in range(100):
-      main_out, extra_out = self.camera_offset.update(main_transform, extra_transform, sm, False)
-
-    # undo main_transform dot product to get shear matrix
-    shear = main_out @ np.linalg.inv(main_transform)
-    expected_v_horizon = intrinsics_main[1, 2] - intrinsics_main[1, 1] * np.tan(pitch)
-    np.testing.assert_almost_equal(shear[0, 1], self.camera_offset.actual_camera_offset / height, decimal=4)
-    np.testing.assert_almost_equal(shear[0, 2], -self.camera_offset.actual_camera_offset / height * expected_v_horizon, decimal=4)
+    assert main_out[0, 1] != 0.0
+    assert main_out[0, 2] != 0.0

openpilot/sunnypilot/modeld_v2/tests/test_models.py

@@ -1,43 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import os
-import unittest
-from unittest.mock import patch
-from openpilot.common.file_chunker import open_file_chunked
-from openpilot.sunnypilot.modeld_v2.helpers import load_oob
-from tinygrad.device import Device
-
-
-class TestLegacyModels(unittest.TestCase):
-  def test_legacy_model_load(self):
-    base_name = os.environ.get("MODEL_BASE_NAME")
-    if not base_name:
-      raise unittest.SkipTest("MODEL_BASE_NAME env var not set, skipping integration test.")
-    chunk_dir = os.environ.get("MODEL_CHUNK_DIR", "/tmp/model_chunks")
-    base_path = os.path.join(chunk_dir, base_name)
-
-    try:
-      f = open_file_chunked(base_path)
-    except Exception as error:
-      self.fail(f"Failed to open chunked file {base_path}: {error}")
-    self.addCleanup(f.close)
-
-    real_getitem = Device.__class__.__getitem__
-
-    def safe_getitem(device_self, ix):
-      if ix == "QCOM" and not os.path.exists("/dev/kgsl-3d0"):
-        return real_getitem(device_self, "CPU")
-      if ix == "AMD" and not os.path.exists("/dev/kfd"):
-        return real_getitem(device_self, "CPU")
-      return real_getitem(device_self, ix)
-
-    with patch.object(Device.__class__, "__getitem__", safe_getitem):
-      obj = load_oob(f)
-
-    assert isinstance(obj, dict), "Parsed object is not a dictionary"
-    assert "metadata" in obj, "Metadata key is missing"

openpilot/sunnypilot/models/tests/test_tinygrad_ref.py

@@ -0,0 +1,24 @@
+import requests
+
+from openpilot.sunnypilot.models.tinygrad_ref import get_tinygrad_ref
+from openpilot.sunnypilot.models.fetcher import ModelFetcher
+from openpilot.common.test import OpenpilotTestCase
+
+def fetch_tinygrad_ref():
+  response = requests.get(ModelFetcher.MODEL_URL, timeout=10)
+  response.raise_for_status()
+  json_data = response.json()
+  return json_data.get("tinygrad_ref")
+
+
+class TestTinygradRef(OpenpilotTestCase):
+  def test_tinygrad_ref(self):
+    current_ref = get_tinygrad_ref()
+    remote_ref = fetch_tinygrad_ref()
+    assert remote_ref == current_ref, (
+      f"""tinygrad_repo ref does not match remote tinygrad_ref of current compiled driving models json.
+    Current: {current_ref}
+    Remote: {remote_ref}
+    Please run build-all workflow to update models."""
+    )
+    print("tinygrad_repo ref matches current compiled driving models json ref.")

openpilot/sunnypilot/selfdrive/controls/lib/longcontrol.py

@@ -1,25 +0,0 @@
-"""
-Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
-
-This file is part of sunnypilot and is licensed under the MIT License.
-See the LICENSE.md file in the root directory for more details.
-"""
-
-import numpy as np
-
-STOPPING_DISTANCE = 1.5
-STOPPED_SPEED = 0.02
-STOPPING_TIME = 2.5
-MIN_STOPPING_HOLD_ACCEL = -0.2
-STOPPING_DECEL_RATE = 0.3
-STOPPED_DECEL_RATE = 0.3
-
-
-class LongControlSP:
-  def should_hold_stopping(self, CS, a_target: float) -> bool:
-    return (self.last_output_accel <= MIN_STOPPING_HOLD_ACCEL and a_target >= self.last_output_accel and CS.vEgo > STOPPED_SPEED and CS.aEgo < 0.0
-            and CS.vEgo <= -CS.aEgo * STOPPING_TIME and CS.vEgo ** 2 <= -2.0 * CS.aEgo * STOPPING_DISTANCE)
-
-  @staticmethod
-  def stopping_decel_rate(v_ego: float) -> float:
-    return float(np.interp(v_ego, [0.0, STOPPED_SPEED], [STOPPED_DECEL_RATE, STOPPING_DECEL_RATE]))

openpilot/sunnypilot/sunnylink/athena/local_discovery.py

@@ -0,0 +1,261 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from __future__ import annotations
+
+import json
+import socket
+import threading
+import time
+from collections.abc import Callable
+from dataclasses import dataclass
+
+from openpilot.common.params import Params
+from openpilot.common.swaglog import cloudlog
+
+from openpilot.sunnypilot.sunnylink.athena.local_pairing import (
+  BEACON_PREFIX,
+  DISCOVERED_APP_KEY,
+  SUNNYLINK_LOCAL_UDP_PORT,
+  format_endpoint,
+  get_local_apps,
+  pairing_requested,
+  update_local_app_endpoint,
+)
+
+LOCAL_BEACON_FRESH_S = 30
+
+@dataclass
+class AppBeacon:
+  """A parsed app beacon — the app announcing it is acting as the local backend."""
+  app_id: str
+  ws_port: int
+  source_ip: str
+
+  @property
+  def endpoint(self) -> str:
+    return format_endpoint(self.source_ip, self.ws_port)
+
+
+def parse_beacon(raw: str | bytes, source_ip: str = "") -> AppBeacon | None:
+  """
+  Parse one UDP beacon line from the app.
+
+  Wire format: `SUNNYLINK1 {"v":1,"role":"app","app_id":"<uuid>","ws_port":8443}`
+  Returns None for anything else. Beacons carry ids + addresses only — no secrets.
+  """
+  if isinstance(raw, bytes):
+    raw = raw.decode("utf-8", errors="replace")
+  raw = raw.strip()
+  if not raw.startswith(BEACON_PREFIX + " "):
+    return None
+  try:
+    data = json.loads(raw[len(BEACON_PREFIX) + 1:])
+  except ValueError:
+    return None
+  if not isinstance(data, dict):
+    return None
+  if data.get("role") != "app" or data.get("v") != 1:
+    return None
+  app_id = data.get("app_id")
+  ws_port = data.get("ws_port")
+  if not isinstance(app_id, str) or not app_id:
+    return None
+  if not isinstance(ws_port, int) or not (0 < ws_port <= 65535):
+    return None
+  return AppBeacon(app_id=app_id, ws_port=ws_port, source_ip=source_ip)
+
+
+class LocalDiscovery(threading.Thread):
+  """
+  Passive UDP listener
+
+  - While a pairing window is armed: track the freshest app beacon so the
+    daemon can offer pairing to a NEW app, and mirror it into a status param
+    for the settings UI.
+  - Independently of any window: a beacon from an app ALREADY in the paired
+    registry refreshes its cached endpoint — IPs are not identity, the app can
+    move between networks.
+  """
+
+  def __init__(self, params: Params | None = None, port: int = SUNNYLINK_LOCAL_UDP_PORT,
+               sock: socket.socket | None = None, write_interval_s: float = 5.0,
+               paired_refresh_cb: Callable[[AppBeacon], None] | None = None):
+    super().__init__(name="local_discovery_listener", daemon=True)
+    self.params = params or Params()
+    self.port = port
+    self._sock = sock
+    self.paired_refresh_cb = paired_refresh_cb
+    self._latest_endpoint: str | None = None
+    self._latest_app_id: str | None = None
+    self._last_seen_monotonic: float = 0.0
+    self._latest_paired_endpoint: str | None = None
+    self._latest_paired_app_id: str | None = None
+    self._last_paired_seen_monotonic: float = 0.0
+    self._lock = threading.Lock()
+    self._stop_event = threading.Event()
+    self.write_interval_s = write_interval_s
+    self._last_write_monotonic = 0.0
+    self._last_written_endpoint: str | None = None
+    self._last_written_app_id: str | None = None
+    self._discovered_cleared = False
+
+  def stop(self) -> None:
+    self._stop_event.set()
+    if self._sock is not None:
+      try:
+        self._sock.close()
+      except OSError:
+        pass
+
+  def latest_endpoint(self) -> str | None:
+    """The most recently announced app endpoint (None outside a pairing window)."""
+    with self._lock:
+      return self._latest_endpoint
+
+  def latest_app_id(self) -> str | None:
+    """The app_id of the most recently announced beacon (None outside a window)."""
+    with self._lock:
+      return self._latest_app_id
+
+  def last_seen_ago(self) -> float | None:
+    """Seconds since the last app beacon was heard (None when none heard yet)."""
+    with self._lock:
+      if self._last_seen_monotonic == 0.0:
+        return None
+      return time.monotonic() - self._last_seen_monotonic
+
+  def latest_paired_endpoint(self) -> str | None:
+    """The freshest beacon endpoint announced by an ALREADY-PAIRED."""
+    with self._lock:
+      return self._latest_paired_endpoint
+
+  def latest_paired_app_id(self) -> str | None:
+    """The app_id of the freshest paired-app beacon (None until one is heard)."""
+    with self._lock:
+      return self._latest_paired_app_id
+
+  def latest_paired_seen_ago(self) -> float | None:
+    """Seconds since the freshest paired-app beacon was heard (None when none)."""
+    with self._lock:
+      if self._last_paired_seen_monotonic == 0.0:
+        return None
+      return time.monotonic() - self._last_paired_seen_monotonic
+
+  def _handle(self, raw: bytes, source_ip: str) -> None:
+    beacon = parse_beacon(raw, source_ip)
+    if beacon is None:
+      return
+    if pairing_requested(self.params):
+      with self._lock:
+        self._latest_endpoint = beacon.endpoint
+        self._latest_app_id = beacon.app_id
+        self._last_seen_monotonic = time.monotonic()
+      self._write_discovered_param(beacon)
+      cloudlog.debug(f"local_discovery.app_found {beacon.app_id} at {beacon.endpoint}")
+    else:
+      with self._lock:
+        self._latest_endpoint = None
+        self._latest_app_id = None
+        self._last_seen_monotonic = 0.0
+      self._clear_discovered_param()
+    self._maybe_refresh_paired_app(beacon)
+
+  def _maybe_refresh_paired_app(self, beacon: AppBeacon) -> None:
+    """Refresh a paired app's registry endpoint from its beacon."""
+
+    if not any(app.app_id == beacon.app_id for app in get_local_apps(self.params)):
+      return
+    with self._lock:
+      self._latest_paired_endpoint = beacon.endpoint
+      self._latest_paired_app_id = beacon.app_id
+      self._last_paired_seen_monotonic = time.monotonic()
+    if update_local_app_endpoint(beacon.app_id, beacon.endpoint, self.params):
+      cloudlog.debug(f"local_discovery.paired_refresh {beacon.app_id} -> {beacon.endpoint}")
+    if self.paired_refresh_cb is not None:
+      try:
+        self.paired_refresh_cb(beacon)
+      except Exception:
+        cloudlog.exception("local_discovery.paired_refresh_cb.exception")
+
+  def _clear_discovered_param(self) -> None:
+    if self._discovered_cleared:
+      return
+    self._discovered_cleared = True
+    try:
+      self.params.remove(DISCOVERED_APP_KEY)
+    except Exception:
+      cloudlog.exception("local_discovery.param_clear.exception")
+
+  def _write_discovered_param(self, beacon: AppBeacon) -> None:
+    """Mirror the freshest beacon into a param the settings UI can read."""
+    now = time.monotonic()
+    changed = beacon.endpoint != self._last_written_endpoint or beacon.app_id != self._last_written_app_id
+    if not changed and now - self._last_write_monotonic < self.write_interval_s:
+      return
+    self._last_write_monotonic = now
+    self._last_written_endpoint = beacon.endpoint
+    self._last_written_app_id = beacon.app_id
+    self._discovered_cleared = False
+    payload = {
+      "endpoint": beacon.endpoint,
+      "app_id": beacon.app_id,
+      "ts": int(time.monotonic()),
+    }
+    try:
+      self.params.put(DISCOVERED_APP_KEY, payload, block=True)
+    except Exception:
+      cloudlog.exception("local_discovery.param_write.exception")
+
+  def _bind(self) -> socket.socket:
+    if self._sock is not None:
+      return self._sock
+    sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+    sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+    sock.bind(("0.0.0.0", self.port))
+    sock.settimeout(0.5)
+    return sock
+
+  def run(self) -> None:
+    sock = self._bind()
+    try:
+      while not self._stop_event.is_set():
+        try:
+          data, addr = sock.recvfrom(4096)
+          self._handle(data, addr[0] if len(addr) > 0 else "")
+        except TimeoutError:
+          continue
+        except OSError:
+          # Socket closed by stop() — exit quietly.
+          if self._stop_event.is_set():
+            break
+          cloudlog.exception("local_discovery.recv.exception")
+          break
+    finally:
+      try:
+        sock.close()
+      except OSError:
+        pass
+
+
+def latest_discovered_app(params: Params | None = None,
+                          fresh_s: float = LOCAL_BEACON_FRESH_S) -> tuple[str, int] | None:
+  params = params or Params()
+  data = params.get(DISCOVERED_APP_KEY)
+  if not isinstance(data, dict):
+    return None
+  endpoint = str(data.get("endpoint", ""))
+  try:
+    ts = int(data.get("ts") or 0)
+  except (ValueError, TypeError):
+    return None
+  if not endpoint or ts <= 0:
+    return None
+  age = time.monotonic() - ts
+  # Negative age = written before the last reboot (monotonic restarts at boot).
+  if age < 0 or age > fresh_s:
+    return None
+  return endpoint, max(0, int(age))

openpilot/sunnypilot/sunnylink/athena/local_pairing.py

@@ -0,0 +1,257 @@
+"""
+Copyright (c) 2021-, Haibin Wen, sunnypilot, and a number of other contributors.
+
+This file is part of sunnypilot and is licensed under the MIT License.
+See the LICENSE.md file in the root directory for more details.
+"""
+from __future__ import annotations
+
+import secrets
+import threading
+import time
+from dataclasses import asdict, dataclass
+from datetime import datetime, UTC
+from typing import Any
+from collections.abc import Callable
+
+from openpilot.common.params import Params
+from openpilot.common.swaglog import cloudlog
+
+SUNNYLINK_LOCAL_UDP_PORT = 53133
+SUNNYLINK_LOCAL_WS_PORT = 8443
+
+LOCAL_APPS_KEY = "SunnylinkLocalApps"
+PAIRING_CODE_KEY = "SunnylinkLocalPairingCode"
+PAIRING_REQUEST_KEY = "SunnylinkLocalPairingRequest"
+DISCOVERED_APP_KEY = "SunnylinkLocalDiscoveredApp"
+
+PAIRING_CODE_LENGTH = 6
+PAIRING_CODE_ALPHABET = "0123456789"
+DEFAULT_CODE_ROTATION_S = 10 * 60  # re-roll the displayed code every 10 min
+PAIRING_WINDOW_S = 5 * 60
+
+BEACON_PREFIX = "SUNNYLINK1"
+
+
+@dataclass
+class LocalApp:
+  """One app paired with this device (the app runs the local "backend")."""
+  app_id: str
+  endpoint: str
+  app_name: str = ""
+  alias: str = ""
+  paired_at: int = 0  # epoch seconds
+
+  @staticmethod
+  def from_dict(data: dict[str, Any]) -> LocalApp:
+    return LocalApp(
+      app_id=str(data.get("app_id", "")),
+      endpoint=str(data.get("endpoint", "")),
+      app_name=str(data.get("app_name", "")),
+      alias=str(data.get("alias", "")),
+      paired_at=int(data.get("paired_at") or 0),
+    )
+
+
+def local_app_display_name(app: LocalApp) -> str:
+  return app.alias or app.app_name or app.app_id
+
+
+def is_locally_paired(params: Params | None = None) -> bool:
+  return len(get_local_apps(params)) > 0
+
+
+def get_local_apps(params: Params | None = None) -> list[LocalApp]:
+  """The paired-app registry (a JSON list persisted in `SunnylinkLocalApps`)."""
+  params = params or Params()
+  data = params.get(LOCAL_APPS_KEY)
+  if not isinstance(data, list):
+    return []
+  return [LocalApp.from_dict(item) for item in data if isinstance(item, dict) and item.get("app_id")]
+
+
+def _save_local_apps(apps: list[LocalApp], params: Params | None = None) -> None:
+  params = params or Params()
+  if apps:
+    params.put(LOCAL_APPS_KEY, [asdict(app) for app in apps], block=True)
+  else:
+    params.remove(LOCAL_APPS_KEY)
+
+
+def add_local_app(app: LocalApp, params: Params | None = None) -> None:
+  """Append (or update by app_id) and persist."""
+  if not app.paired_at:
+    app.paired_at = int(datetime.now(UTC).replace(tzinfo=None).timestamp())
+  apps = [existing for existing in get_local_apps(params) if existing.app_id != app.app_id]
+  apps.append(app)
+  _save_local_apps(apps, params)
+  cloudlog.event("local_pairing.app_paired", app_id=app.app_id, endpoint=app.endpoint)
+
+
+def update_local_app_endpoint(app_id: str, endpoint: str, params: Params | None = None) -> bool:
+  """Refresh a PAIRED app's cached endpoint from its beacon."""
+  apps = get_local_apps(params)
+  for i, app in enumerate(apps):
+    if app.app_id != app_id or app.endpoint == endpoint:
+      continue
+    apps[i] = LocalApp(app_id=app.app_id, endpoint=endpoint,
+                       app_name=app.app_name, alias=app.alias, paired_at=app.paired_at)
+    _save_local_apps(apps, params)
+    cloudlog.event("local_pairing.app_endpoint_refreshed", app_id=app_id, endpoint=endpoint)
+    return True
+  return False
+
+
+def set_local_app_alias(app_id: str, alias: str, params: Params | None = None) -> bool:
+  apps = get_local_apps(params)
+  for i, app in enumerate(apps):
+    if app.app_id != app_id:
+      continue
+    if app.alias == alias:
+      return False
+    apps[i] = LocalApp(app_id=app.app_id, endpoint=app.endpoint,
+                       app_name=app.app_name, alias=alias, paired_at=app.paired_at)
+    _save_local_apps(apps, params)
+    cloudlog.event("local_pairing.app_alias_updated", app_id=app_id, alias=alias)
+    return True
+  return False
+
+
+def remove_local_app(app_id: str, params: Params | None = None) -> bool:
+  """Unpair an app by id. Returns True when an app was removed."""
+  apps = get_local_apps(params)
+  remaining = [app for app in apps if app.app_id != app_id]
+  if len(remaining) == len(apps):
+    return False
+  _save_local_apps(remaining, params)
+  cloudlog.event("local_pairing.app_unpaired", app_id=app_id)
+  return True
+
+
+def remove_all_local_apps(params: Params | None = None) -> None:
+  """Unpair every app."""
+  _save_local_apps([], params)
+  cloudlog.event("local_pairing.all_apps_unpaired")
+
+
+def generate_pairing_code() -> str:
+  """A 6-digit numeric pairing code."""
+  return "".join(secrets.choice(PAIRING_CODE_ALPHABET) for _ in range(PAIRING_CODE_LENGTH))
+
+
+def _write_pairing_code(code: str, params: Params) -> None:
+  """Persist the code with its armed-at monotonic timestamp — the window is derived from it."""
+  params.put(PAIRING_CODE_KEY, {"code": code, "ts": int(time.monotonic())}, block=True)
+
+
+def read_pairing_code(params: Params | None = None) -> str | None:
+  """The stored pairing code, or None when cleared / not yet generated."""
+  params = params or Params()
+  data = params.get(PAIRING_CODE_KEY)
+  if not isinstance(data, dict):
+    return None
+  code = data.get("code")
+  return str(code) if code else None
+
+
+def get_pairing_code(params: Params | None = None) -> str:
+  """The displayed pairing code, generating and persisting one on first use."""
+  params = params or Params()
+  code = read_pairing_code(params)
+  if code is None:
+    code = generate_pairing_code()
+    _write_pairing_code(code, params)
+  return code
+
+
+def pairing_requested(params: Params | None = None) -> bool:
+  """True while the pairing window is armed and fresh.
+
+  Self-expiring: if the code (which carries the armed-at timestamp) is missing
+  or older than PAIRING_WINDOW_S, the flag is dropped here."""
+  params = params or Params()
+  if not params.get_bool(PAIRING_REQUEST_KEY):
+    return False
+  data = params.get(PAIRING_CODE_KEY)
+  ts = data.get("ts") if isinstance(data, dict) else None
+  if not isinstance(ts, (int, float)):
+    clear_pairing_request(params)
+    return False
+  age = time.monotonic() - ts
+  # Negative age = armed before the last reboot (monotonic restarts at boot).
+  if age < 0 or age > PAIRING_WINDOW_S:
+    clear_pairing_request(params)
+    return False
+  return True
+
+
+def arm_pairing(params: Params | None = None) -> str:
+  """Arm a pairing window and return the code for the app.
+
+  Rolls a fresh code first, then sets the flag, so pairing_requested never
+  sees an armed flag without a valid code."""
+  params = params or Params()
+  code = generate_pairing_code()
+  _write_pairing_code(code, params)
+  params.put_bool(PAIRING_REQUEST_KEY, True, block=True)
+  return code
+
+
+def clear_pairing_request(params: Params | None = None) -> None:
+  """Close the pairing window: drop the request flag and the code together."""
+  params = params or Params()
+  params.remove(PAIRING_REQUEST_KEY)
+  params.remove(PAIRING_CODE_KEY)
+
+
+def verify_pairing_code(code: str, params: Params | None = None) -> bool:
+  """Constant-time check of a code typed into the app against the displayed one."""
+  params = params or Params()
+  current = read_pairing_code(params)
+  if current is None:
+    return False
+  return secrets.compare_digest(str(code).strip().upper(), current)
+
+
+class PairingCodeRotator(threading.Thread):
+  """Re-roll the displayed code while a pairing window is armed; clear it
+  otherwise — the code is never generated outside a window."""
+
+  def __init__(self, params: Params | None = None, rotation_s: float = DEFAULT_CODE_ROTATION_S,
+               stop_event: threading.Event | None = None, tick_cb: Callable[[], None] | None = None):
+    super().__init__(name="local_pairing_code_rotator", daemon=True)
+    self.params = params or Params()
+    self.rotation_s = rotation_s
+    self.stop_event = stop_event or threading.Event()
+    # Test seam: invoked once per loop iteration after state is updated.
+    self.tick_cb = tick_cb
+
+  def rotate(self) -> None:
+    """Re-roll the code while the window is armed, clear it otherwise."""
+    if pairing_requested(self.params):
+      _write_pairing_code(generate_pairing_code(), self.params)
+    else:
+      self.params.remove(PAIRING_CODE_KEY)
+
+  def run(self) -> None:
+    self.rotate()
+    while not self.stop_event.wait(self.rotation_s):
+      try:
+        self.rotate()
+        if self.tick_cb is not None:
+          self.tick_cb()
+      except Exception:
+        cloudlog.exception("local_pairing.code_rotator.exception")
+
+
+def format_endpoint(host: str, ws_port: int = SUNNYLINK_LOCAL_WS_PORT) -> str:
+  return f"ws://{host}:{ws_port}"
+
+
+def local_identity(params: Params | None = None) -> str:
+  """Identity claim on local connections. DongleId always exists on comma
+  hardware (SunnylinkDongleId is "UnregisteredDevice" until cloud
+  registration) and is what the app matches against the backend device list
+  to dedupe cloud + local entries."""
+  params = params or Params()
+  return params.get("DongleId") or params.get("HardwareSerial") or ""

openpilot/sunnypilot/sunnylink/athena/sunnylinkd.py

@@ -30,10 +30,26 @@ from websocket import (ABNF, WebSocket, WebSocketException, WebSocketTimeoutExce
 import openpilot.cereal.messaging as messaging
 from openpilot.sunnypilot.models.model_name import DEFAULT_MODEL, DEFAULT_BIG_MODEL
 from openpilot.sunnypilot.selfdrive.car.sync_sunnylink_params import update_car_list_param
+from openpilot.system.athena import rpc as rpc_module
 from openpilot.sunnypilot.sunnylink.api import SunnylinkApi
 from openpilot.sunnypilot.sunnylink.utils import sunnylink_need_register, sunnylink_ready, get_param_as_byte, save_param_from_base64_encoded_string
 from openpilot.sunnypilot.sunnylink.capabilities import generate_capabilities, CAPABILITY_LABELS
 from openpilot.sunnypilot.sunnylink.tools.generate_settings_schema import generate_schema
+from openpilot.sunnypilot.sunnylink.athena.local_discovery import LOCAL_BEACON_FRESH_S, AppBeacon, LocalDiscovery
+from openpilot.sunnypilot.sunnylink.athena.local_pairing import (
+  PAIRING_WINDOW_S,
+  LocalApp,
+  PairingCodeRotator,
+  add_local_app,
+  clear_pairing_request,
+  get_local_apps,
+  is_locally_paired,
+  local_identity,
+  pairing_requested,
+  remove_local_app,
+  set_local_app_alias,
+  verify_pairing_code,
+)
 
 SUNNYLINK_ATHENA_HOST = os.getenv('SUNNYLINK_ATHENA_HOST', 'wss://athena.sunnylink.ai')
 HANDLER_THREADS = int(os.getenv('HANDLER_THREADS', "4"))
@@ -42,6 +58,15 @@ SUNNYLINK_LOG_ATTR_NAME = "user.sunny.upload"
 SUNNYLINK_RECONNECT_TIMEOUT_S = 70  # FYI changing this will also would require a change on sidebar.cc
 DISALLOW_LOG_UPLOAD = threading.Event()
 
+LOCAL_PAIRING_SESSION_TIMEOUT_S = PAIRING_WINDOW_S
+LOCAL_PROBE_INTERVAL_S = 60
+LOCAL_ENDPOINT_BACKOFF_S = 300
+PAIRING_WATCHDOG_INTERVAL_S = 2.0
+
+_active_local_endpoint: str | None = None
+_active_ws: WebSocket | None = None
+_pairing_in_progress = threading.Event()
+
 params = Params()
 
 # Parameters that should never be remotely modified
@@ -266,44 +291,302 @@ def startLocalProxy(global_end_event: threading.Event, remote_ws_uri: str, local
   return start_local_proxy_shim(global_end_event, local_port, ws)
 
 
+@dispatcher.add_method
+def pairLocalApp(code: str, app_id: str = "", app_name: str = "", alias: str = "") -> dict[str, bool | str]:
+  """Complete pairing with the app on the CURRENT local connection."""
+  if _active_local_endpoint is None:
+    return {"success": False, "error": "not connected to a local app"}
+  if not verify_pairing_code(code):
+    cloudlog.warning("sunnylinkd.pairLocalApp.invalid_code")
+    return {"success": False, "error": "invalid code"}
+  add_local_app(LocalApp(app_id=app_id or f"app@{_active_local_endpoint}",
+                         endpoint=_active_local_endpoint, app_name=app_name, alias=alias))
+  clear_pairing_request()
+  return {"success": True}
+
+
+@dispatcher.add_method
+def updateLocalAppAlias(app_id: str, alias: str) -> dict[str, bool | str]:
+  if _active_local_endpoint is None:
+    return {"success": False, "error": "not connected to a local app"}
+  updated = set_local_app_alias(app_id, alias)
+  return {"success": True, "updated": updated}
+
+
+@dispatcher.add_method
+def unpairLocalApp(app_id: str) -> dict[str, bool | str]:
+  if _active_local_endpoint is None:
+    return {"success": False, "error": "not connected to a local app"}
+  removed = remove_local_app(app_id)
+  return {"success": True, "removed": removed}
+
+
+def _auth_header(is_local: bool) -> dict[str, str]:
+  """Bearer header for a dial."""
+  api = SunnylinkApi(params.get("SunnylinkDongleId"))
+  payload = {"identity": local_identity()} if is_local else None
+  return {"Authorization": f"Bearer {api.get_token(payload_extra=payload)}"}
+
+
+def _pairing_session(ws: WebSocket, timeout_s: float = LOCAL_PAIRING_SESSION_TIMEOUT_S) -> bool:
+  """Serve only the pairing RPCs to an app that isn't in the registry yet —
+  everything else is refused. Returns True if pairing completed (the connection may then
+  serve normally)."""
+  cloudlog.info("sunnylinkd.pairing_session.started")
+  ws.settimeout(10)
+  deadline = time.monotonic() + timeout_s
+  try:
+    while time.monotonic() < deadline and pairing_requested():
+      try:
+        raw = ws.recv()  # auto-pongs pings; blocks up to the socket timeout
+      except WebSocketTimeoutException:
+        continue
+      except Exception as e:
+        cloudlog.warning(f"sunnylinkd.pairing_session.{type(e).__name__}")
+        return is_locally_paired()
+      try:
+        msg = rpc_module.loads(raw)
+      except Exception:
+        continue
+      if not rpc_module.is_call(msg):
+        continue
+      if msg.get("method") not in ("pairLocalApp", "unpairLocalApp"):
+        continue  # refuse anything but pairing until paired
+      try:
+        ws.send(rpc_module.handle(msg, dispatcher))
+      except Exception as e:
+        cloudlog.warning(f"sunnylinkd.pairing_session.{type(e).__name__}")
+        return is_locally_paired()
+    return is_locally_paired()
+  finally:
+    ws.settimeout(SUNNYLINK_RECONNECT_TIMEOUT_S)
+
+
+def _pick_ws_uri(discovery: LocalDiscovery, backoffs: dict[str, float]) -> tuple[str, str]:
+  now = time.monotonic()
+  apps = get_local_apps()
+  app_ids = {app.app_id for app in apps}
+  if pairing_requested():
+    latest = discovery.latest_endpoint()
+    seen = discovery.last_seen_ago()
+    app_id = discovery.latest_app_id()
+    if latest is not None and seen is not None and seen <= LOCAL_BEACON_FRESH_S \
+       and app_id is not None and app_id not in app_ids \
+       and backoffs.get(latest, 0.0) <= now:
+      return latest, "pairing_offer"
+    return SUNNYLINK_ATHENA_HOST, "cloud"
+  fresh_endpoint = discovery.latest_paired_endpoint()
+  fresh_seen = discovery.latest_paired_seen_ago()
+  fresh_app_id = discovery.latest_paired_app_id()
+  fresh_ok = (fresh_endpoint is not None and fresh_seen is not None
+              and fresh_seen <= LOCAL_BEACON_FRESH_S and fresh_app_id is not None
+              and fresh_app_id in app_ids)
+  if fresh_ok and backoffs.get(fresh_endpoint, 0.0) <= now:
+    return fresh_endpoint, "paired_local"
+  for app in reversed(apps):
+    if fresh_ok and app.app_id == fresh_app_id:
+      continue
+    if backoffs.get(app.endpoint, 0.0) <= now:
+      return app.endpoint, "paired_local"
+  return SUNNYLINK_ATHENA_HOST, "cloud"
+
+
+def _probe_local_apps(active_ws: WebSocket, discovery: LocalDiscovery,
+                      backoffs: dict[str, float], stop_event: threading.Event) -> None:
+  while not stop_event.wait(LOCAL_PROBE_INTERVAL_S):
+    if pairing_requested():
+      # The pairing watchdog owns an armed window; don't migrate mid-window.
+      continue
+    now = time.monotonic()
+    candidate: str | None = None
+    for app in reversed(get_local_apps()):
+      if backoffs.get(app.endpoint, 0.0) <= now:
+        candidate = app.endpoint
+        break
+    if candidate is None:
+      continue
+    try:
+      probe = create_connection(candidate, header=_auth_header(is_local=True), timeout=10)
+      probe.close()
+    except Exception:
+      backoffs[candidate] = now + LOCAL_ENDPOINT_BACKOFF_S
+      continue
+    cloudlog.event("sunnylinkd.local_probe.reachable", endpoint=candidate)
+    try:
+      active_ws.close()
+    except Exception:
+      pass
+    break
+
+
+def _handle_paired_refresh(backoffs: dict[str, float], force_attempts: dict[str, float],
+                           beacon: AppBeacon) -> None:
+  if not any(app.app_id == beacon.app_id for app in get_local_apps()):
+    return
+  for app in get_local_apps():
+    if app.app_id == beacon.app_id:
+      backoffs.pop(app.endpoint, None)
+  backoffs.pop(beacon.endpoint, None)
+  if _pairing_in_progress.is_set():
+    return
+  if _active_local_endpoint == beacon.endpoint:
+    return
+  if _active_local_endpoint is not None:
+    return
+  now = time.monotonic()
+  if force_attempts.get(beacon.endpoint, 0.0) + LOCAL_BEACON_FRESH_S > now:
+    return
+  force_attempts[beacon.endpoint] = now
+  ws = _active_ws
+  if ws is not None:
+    cloudlog.event("sunnylinkd.paired_refresh.reconnect",
+                   app_id=beacon.app_id, endpoint=beacon.endpoint)
+    try:
+      ws.close()
+    except Exception:
+      pass
+
+
+def _pairing_watchdog(active_ws: WebSocket, backoffs: dict[str, float],
+                      stop_event: threading.Event,
+                      interval_s: float = PAIRING_WATCHDOG_INTERVAL_S) -> None:
+  """Watch for the pairing window being armed mid-session and force a
+  re-selection to the newly-discovered app."""
+  while not stop_event.wait(interval_s):
+    if not pairing_requested():
+      continue
+    cloudlog.event("sunnylinkd.pairing_watchdog.arm_detected")
+    for key in list(backoffs):
+      backoffs.pop(key, None)
+    try:
+      active_ws.close()
+    except Exception:
+      pass
+    break
+
+
 def main(exit_event: threading.Event | None = None):
   try:
     set_core_affinity([0, 1, 2, 3])
   except Exception:
     cloudlog.exception("failed to set core affinity")
 
-  while sunnylink_need_register(params):
-    cloudlog.info("Waiting for sunnylink registration to complete")
-    time.sleep(10)
+  discovery = LocalDiscovery()
+  code_rotator = PairingCodeRotator()
+  discovery.start()
+  code_rotator.start()
+
+  try:
+    _connection_loop(exit_event, discovery)
+  finally:
+    discovery.stop()
+    code_rotator.stop_event.set()
+
+
+def _serviceable(params: Params) -> bool:
+  """sunnylinkd should run when sunnylink is enabled and not on a temporary
+  fault. This deliberately includes the unregistered/unpaired state so a
+  never-registered device can still be discovered and paired over the LAN (the
+  actual session gates — registration/local pairing — are handled per
+  connection inside the loop)."""
+  return params.get_bool("SunnylinkEnabled") and not params.get_bool("SunnylinkTempFault")
+
+
+def _connection_loop(exit_event: threading.Event | None, discovery: LocalDiscovery) -> None:
+  """Local-first, cloud-fallback connection loop: a paired local endpoint
+  first, cloud when unreachable, and a pairing session to a freshly-discovered
+  app when a window is armed."""
+  global _active_local_endpoint, _active_ws
 
-  sunnylink_dongle_id = params.get("SunnylinkDongleId")
-  sunnylink_api = SunnylinkApi(sunnylink_dongle_id)
   UploadQueueCache.initialize(upload_queue)
-
   update_car_list_param()
 
-  ws_uri = f"{SUNNYLINK_ATHENA_HOST}"
   conn_start = None
   conn_retries = 0
-  while (exit_event is None or not exit_event.is_set()) and sunnylink_ready(params):
-    try:
-      if conn_start is None:
-        conn_start = time.monotonic()
+  backoffs: dict[str, float] = {}
+  force_attempts: dict[str, float] = {}
+  discovery.paired_refresh_cb = partial(_handle_paired_refresh, backoffs, force_attempts)
 
-      cloudlog.event("sunnylinkd.main.connecting_ws", ws_uri=ws_uri, retries=conn_retries)
+  while (exit_event is None or not exit_event.is_set()) and _serviceable(params):
+    ws_uri, kind = _pick_ws_uri(discovery, backoffs)
+
+    if kind == "cloud" and pairing_requested():
+      cloudlog.debug("sunnylinkd.main.pairing_waiting_for_beacon")
+      time.sleep(3)
+      continue
+
+    if kind == "cloud" and sunnylink_need_register(params):
+      cloudlog.info("Waiting for sunnylink registration or local pairing to complete")
+      time.sleep(10)
+      continue
+
+    if conn_start is None:
+      conn_start = time.monotonic()
+
+    cloudlog.event("sunnylinkd.main.connecting_ws", ws_uri=ws_uri, kind=kind, retries=conn_retries)
+    try:
       ws = create_connection(
         ws_uri,
-        header={"Authorization": f"Bearer {sunnylink_api.get_token()}"},
+        header=_auth_header(is_local=kind != "cloud"),
         enable_multithread=True,
         sslopt={"cert_reqs": ssl.CERT_NONE if "localhost" in ws_uri else ssl.CERT_REQUIRED},
         timeout=SUNNYLINK_RECONNECT_TIMEOUT_S,
       )
-      cloudlog.event("sunnylinkd.main.connected_ws", ws_uri=ws_uri, retries=conn_retries,
-                     duration=time.monotonic() - conn_start)
-      conn_start = None
+    except Exception as e:
+      if kind != "cloud":
+        backoffs[ws_uri] = time.monotonic() + LOCAL_ENDPOINT_BACKOFF_S
+      conn_retries += 1
+      params.remove("LastSunnylinkPingTime")
+      _log_connection_error(e)
+      time.sleep(backoff(conn_retries))
+      continue
 
-      conn_retries = 0
-      cur_upload_items.clear()
+    cloudlog.event("sunnylinkd.main.connected_ws", ws_uri=ws_uri, kind=kind, retries=conn_retries,
+                   duration=time.monotonic() - conn_start)
+    conn_start = None
+    conn_retries = 0
+    cur_upload_items.clear()
+    _active_ws = ws
+
+    probe_stop: threading.Event | None = None
+    watch_stop: threading.Event | None = None
+    session_endpoint: str | None = ws_uri if kind != "cloud" else None
+    try:
+      if kind == "pairing_offer":
+        _active_local_endpoint = ws_uri
+        _pairing_in_progress.set()
+        try:
+          paired_ok = _pairing_session(ws)
+        finally:
+          _pairing_in_progress.clear()
+        if not paired_ok:
+          backoffs[ws_uri] = time.monotonic() + LOCAL_ENDPOINT_BACKOFF_S
+          conn_retries += 1
+          params.remove("LastSunnylinkPingTime")
+          try:
+            ws.close()
+          except Exception:
+            pass
+          time.sleep(backoff(conn_retries))
+          continue
+        # Paired during the session — this connection may now serve normally.
+        kind = "paired_local"
+
+      if kind == "paired_local":
+        _active_local_endpoint = ws_uri
+      else:
+        _active_local_endpoint = None
+        # While on the cloud link, watch for the local app and migrate back.
+        probe_stop = threading.Event()
+        threading.Thread(target=_probe_local_apps,
+                         args=(ws, discovery, backoffs, probe_stop),
+                         name="sunnylinkd_local_probe", daemon=True).start()
+
+      # Started after any pairing session on this connection, so it can never
+      # close the connection the code is typed over.
+      watch_stop = threading.Event()
+      threading.Thread(target=_pairing_watchdog, args=(ws, backoffs, watch_stop),
+                       name="sunnylinkd_pairing_watchdog", daemon=True).start()
 
       handle_long_poll(ws, exit_event)
     except (KeyboardInterrupt, SystemExit):
@@ -311,23 +594,37 @@ def main(exit_event: threading.Event | None = None):
     except Exception as e:
       conn_retries += 1
       params.remove("LastSunnylinkPingTime")
-
-      if isinstance(e, (ConnectionError, TimeoutError, WebSocketException)):
-        cloudlog.warning(f"sunnylinkd.main.{type(e).__name__}")
-      elif isinstance(e, OSError):
-        name = errno.errorcode.get(e.errno or -1, "UNKNOWN")
-        msg = f"sunnylinkd.main.OSError.{name} ({e.errno})"
-        is_expected_error = e.errno in (errno.ENETDOWN, errno.ENETRESET, errno.ENETUNREACH)
-        cloudlog.warning(msg) if is_expected_error else cloudlog.exception(msg)
-      else:
-        cloudlog.exception("sunnylinkd.main.exception")
+      _log_connection_error(e)
+    finally:
+      if probe_stop is not None:
+        probe_stop.set()
+      if watch_stop is not None:
+        watch_stop.set()
+      if session_endpoint is not None and kind == "paired_local":
+        backoffs.pop(session_endpoint, None)
+      if _active_local_endpoint == session_endpoint:
+        _active_local_endpoint = None
+      if _active_ws is ws:
+        _active_ws = None
 
     time.sleep(backoff(conn_retries))
 
-  if not sunnylink_ready(params):
-    cloudlog.debug("Reached end of sunnylinkd.main while sunnylink is not ready. Waiting 60s before retrying")
+  if not _serviceable(params):
+    cloudlog.debug("Reached end of sunnylinkd.main while sunnylink is not serviceable. Waiting 60s before retrying")
     time.sleep(60)
 
 
+def _log_connection_error(e: Exception) -> None:
+  if isinstance(e, (ConnectionError, TimeoutError, WebSocketException)):
+    cloudlog.warning(f"sunnylinkd.main.{type(e).__name__}")
+  elif isinstance(e, OSError):
+    name = errno.errorcode.get(e.errno or -1, "UNKNOWN")
+    msg = f"sunnylinkd.main.OSError.{name} ({e.errno})"
+    is_expected_error = e.errno in (errno.ENETDOWN, errno.ENETRESET, errno.ENETUNREACH)
+    cloudlog.warning(msg) if is_expected_error else cloudlog.exception(msg)
+  else:
+    cloudlog.exception("sunnylinkd.main.exception")
+
+
 if __name__ == "__main__":
   main()

openpilot/sunnypilot/sunnylink/utils.py

@@ -2,6 +2,7 @@ import base64
 import gzip
 import json
 from openpilot.sunnypilot.sunnylink.api import SunnylinkApi, UNREGISTERED_SUNNYLINK_DONGLE_ID
+from openpilot.sunnypilot.sunnylink.athena.local_pairing import is_locally_paired
 from openpilot.common.params import Params, ParamKeyType
 from openpilot.common.version import is_prebuilt
 
@@ -16,10 +17,11 @@ def get_sunnylink_status(params=None) -> tuple[bool, bool, bool]:
 
 
 def sunnylink_ready(params=None) -> bool:
-  """Check if the device is ready to communicate with Sunnylink. That means it is enabled and registered."""
+  """Enabled and (cloud-registered or locally paired), and not on a temporary
+  fault. Local pairing makes never-registered devices usable over the LAN."""
   params = params or Params()
   is_sunnylink_enabled, is_registered, is_on_temporary_fault = get_sunnylink_status(params)
-  return is_sunnylink_enabled and is_registered and not is_on_temporary_fault
+  return is_sunnylink_enabled and (is_registered or is_locally_paired(params)) and not is_on_temporary_fault
 
 
 def use_sunnylink_uploader(params) -> bool:
@@ -28,10 +30,11 @@ def use_sunnylink_uploader(params) -> bool:
 
 
 def sunnylink_need_register(params=None) -> bool:
-  """Check if the device needs to be registered with Sunnylink."""
+  """Enabled, unregistered, and not locally paired — a locally paired device
+  works without cloud registration and must not be blocked."""
   params = params or Params()
   is_sunnylink_enabled, is_registered, is_on_temporary_fault = get_sunnylink_status(params)
-  return is_sunnylink_enabled and not is_registered and not is_on_temporary_fault
+  return is_sunnylink_enabled and not is_registered and not is_locally_paired(params) and not is_on_temporary_fault
 
 
 def register_sunnylink():