rigplane 2.1.2__tar.gz → 2.2.0__tar.gz

rigplane-2.2.0/.github/pull_request_template.md

@@ -0,0 +1,22 @@
+## Scope
+
+- Linked issue / task:
+- Compatibility impact: API / CLI / config / wire behavior / docs / none
+
+## Verification
+
+- [ ] Relevant local tests or checks run
+- [ ] Public/open-core boundary checked
+- [ ] Release or migration impact documented if applicable
+
+## Agent Review
+
+- [ ] Independent agent review comment posted before merge
+- Reviewer:
+- Result: `Agent Review: PASS` / `Agent Review: BLOCKED`
+- If BLOCKED: include concrete problems, file/line references, risks, required
+  fixes, and checks to rerun.
+
+## Notes
+
+- Out of scope / follow-ups:

rigplane-2.2.0/.github/workflows/agent-review-gate.yml

@@ -0,0 +1,85 @@
+name: Agent Review Gate
+
+on:
+  pull_request:
+    types: [opened, reopened, synchronize, ready_for_review]
+  issue_comment:
+    types: [created, edited, deleted]
+
+permissions:
+  contents: read
+  issues: read
+  pull-requests: read
+  statuses: write
+
+concurrency:
+  group: agent-review-gate-${{ github.event.issue.pull_request && github.event.issue.number || github.event.pull_request.number }}
+  cancel-in-progress: true
+
+jobs:
+  agent-review:
+    name: Update Agent Review Gate status
+    if: github.event_name == 'pull_request' || github.event.issue.pull_request
+    runs-on: ubuntu-latest
+    timeout-minutes: 2
+
+    steps:
+      - name: Resolve pull request number
+        id: pr
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const number = context.payload.pull_request?.number ?? context.payload.issue?.number;
+            const {owner, repo} = context.repo;
+            const {data: pull} = await github.rest.pulls.get({
+              owner,
+              repo,
+              pull_number: number,
+            });
+            const {data: commit} = await github.rest.repos.getCommit({
+              owner,
+              repo,
+              ref: pull.head.sha,
+            });
+            const committedAt =
+              commit.commit.committer?.date ??
+              commit.commit.author?.date ??
+              pull.updated_at;
+            core.setOutput('number', String(number));
+            core.setOutput('head_sha', pull.head.sha);
+            core.setOutput('committed_at', committedAt);
+
+      - name: Update required Agent Review Gate status
+        uses: actions/github-script@v7
+        with:
+          script: |
+            const pull_number = Number('${{ steps.pr.outputs.number }}');
+            const head_sha = '${{ steps.pr.outputs.head_sha }}';
+            const committed_at = new Date('${{ steps.pr.outputs.committed_at }}');
+            const {owner, repo} = context.repo;
+            const comments = await github.paginate(github.rest.issues.listComments, {
+              owner,
+              repo,
+              issue_number: pull_number,
+              per_page: 100,
+            });
+            const pass = comments.some((comment) =>
+              !comment.minimized &&
+              typeof comment.body === 'string' &&
+              comment.body.includes('Agent Review: PASS') &&
+              new Date(comment.updated_at ?? comment.created_at) >= committed_at
+            );
+            await github.rest.repos.createCommitStatus({
+              owner,
+              repo,
+              sha: head_sha,
+              state: pass ? 'success' : 'failure',
+              context: 'Agent Review Gate',
+              description: pass
+                ? 'Agent Review PASS comment found for the current PR head.'
+                : 'Missing Agent Review PASS comment for the current PR head.',
+              target_url: `${context.serverUrl}/${owner}/${repo}/actions/runs/${context.runId}`,
+            });
+            if (!pass) {
+              core.notice('Missing required PR comment containing "Agent Review: PASS" posted or edited after the current PR head commit.');
+            }

{rigplane-2.1.2 → rigplane-2.2.0}/AGENTS.md

@@ -61,6 +61,55 @@ Default rule for agents:
 See `docs/internals/github-project-workflow.md` for the exact CLI and UI
 workflow.
 
+## Multi-agent Git hygiene
+
+This repo is developed from multiple machines and by multiple agents. Before
+editing:
+
+- run `git fetch --all --tags --prune`;
+- inspect `git status --short --branch`;
+- do not work directly on `main`;
+- use `codex/<issue-or-task>` branches for agent work;
+- use `git pull --ff-only --tags` only on clean branches with a normal upstream;
+- do not reset, clean, delete, or rebase uncertain work without explicit user
+  approval.
+
+Use the global `repo-hygiene` skill for cross-repo inventory and cleanup.
+
+## Protected main and review gate
+
+`main` is protected. Changes should land through PRs.
+
+RigPlane's standard automation gate is `.github/workflows/agent-review-gate.yml`.
+It updates the required commit status `Agent Review Gate` on the current PR
+head SHA and passes only after a normal PR comment contains `Agent Review:
+PASS` for that head. Use this status instead of GitHub required approving
+reviews; same-user approval restrictions break automated agent flow.
+
+Every non-trivial PR requires independent agent review before merge. The
+implementation agent may not be the review agent.
+
+- `Agent Review: PASS` means the PR may merge once required checks are green,
+  the PASS comment is fresh for the current head, and the PR is not draft.
+- `Agent Review: BLOCKED` must include concrete problems, file/line references
+  where applicable, risk, required fixes, and checks to run.
+- The implementation agent must address BLOCKED feedback, push updates, and
+  rerun or wait for checks before merge.
+- A failed `Agent Review Gate` without BLOCKED feedback usually means no fresh
+  PASS comment exists for the current head; perform or refresh the review
+  instead of skipping the PR.
+- Cancelled checks must be rerun with `gh run rerun <run-id>` or a new push,
+  then watched to completion.
+- Draft PRs must not merge. Determine why the PR is draft, finish the missing
+  work, run `gh pr ready`, then complete checks and review.
+
+## Release branches
+
+Use release branches only when a public/core release needs stabilization while
+`main` continues moving. Tags remain the source of truth for published
+artifacts. Hotfixes made on a release branch must be merged or cherry-picked
+back to `main`.
+
 ## Engineering rules
 
 - Follow `CLAUDE.md` for commands, architecture, testing, and workflow gates.

{rigplane-2.1.2 → rigplane-2.2.0}/CLAUDE.md

@@ -100,6 +100,52 @@ User-facing → **Russian**. Code/commits/docs/PR → **English**.
 Commits: `feat(#N):` / `fix(#N):` / `refactor:` / `test:` / `docs:` / `chore:`
 One change per commit. Full test suite before push.
 
+### Multi-machine Git hygiene
+
+Development runs across a local laptop and a dev Mac mini, often with several
+agents. Before editing:
+
+```bash
+git fetch --all --tags --prune
+git status --short --branch
+python3 ~/.codex/skills/repo-hygiene/scripts/repo_inventory.py --roots /Users/moroz/Projects --summary
+```
+
+Rules:
+
+- never work directly on `main`;
+- use `codex/<issue-or-task>` for agent work;
+- use `git pull --ff-only --tags` only on a clean branch with a normal upstream;
+- do not reset, clean, delete, or rebase uncertain work without explicit user
+  approval;
+- report or snapshot dirty trees before sync.
+
+`main` is protected. RigPlane uses `.github/workflows/agent-review-gate.yml`
+as the standard PR automation gate. The workflow passes only after a normal PR
+comment contains `Agent Review: PASS` for the current PR head; use the required
+commit status `Agent Review Gate` instead of GitHub required approving reviews,
+because same-user approval restrictions break automated agent flow.
+
+Non-trivial PRs require independent agent review before merge. The
+implementation agent cannot self-review. `Agent Review: PASS` means the PR may
+merge once required checks are green, the PASS comment is fresh for the current
+head, and the PR is not draft. `Agent Review: BLOCKED` must include concrete
+problems, file/line references where applicable, risk, required fixes, and
+checks to run. The implementation agent must fix
+BLOCKED feedback, push updates, and rerun or wait for checks before merge.
+
+A failed `Agent Review Gate` without BLOCKED feedback usually means no fresh
+PASS comment exists for the current head; perform or refresh the review instead
+of skipping the PR. Cancelled checks must be rerun with `gh run rerun <run-id>`
+or a new push, then watched to completion. Draft PRs must not merge: determine
+why the PR is draft, finish the missing work, run `gh pr ready`, then complete
+checks and review.
+
+Release branches are exceptional: use `release/<major.minor>` only when a
+public release needs stabilization while `main` moves ahead. Tags remain the
+published artifact source of truth, and release-branch hotfixes must return to
+`main`.
+
 ---
 
 ## Completion criteria

{rigplane-2.1.2 → rigplane-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: rigplane
-Version: 2.1.2
+Version: 2.2.0
 Summary: Python library for controlling Icom transceivers over LAN (UDP) — no wfview/hamlib required
 Project-URL: Homepage, https://rigplane.dev/
 Project-URL: Documentation, https://rigplane.dev/

{rigplane-2.1.2 → rigplane-2.2.0}/docs/CHANGELOG.md

@@ -7,6 +7,21 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [2.2.0] — 2026-05-11
+
+### Added
+- Added a friendly station-server discovery and status contract for desktop
+  supervisors: UDP discovery now advertises the station-server schema, endpoint
+  URLs, readiness, auth-required, backend, display name, and radio metadata
+  while preserving legacy discovery fields (#1498).
+- Added `GET /api/v1/station` and exposed station readiness in
+  `GET /api/v1/runtime`, giving setup tools a stable machine-readable and
+  human-readable status payload for LAN station-server discovery (#1498).
+
+### Docs
+- Documented the new station-server discovery/status payloads and readiness
+  states for supervisors and setup tools (#1498).
+
 ## [2.1.2] — 2026-05-09
 
 ### Added
@@ -1279,7 +1294,8 @@ These deprecation closures were announced in v0.19 and dropped on schedule.
 - Transport layer, authentication, CI-V commands, meters, PTT, keep-alive.
 - Clean-room Icom LAN UDP protocol implementation.
 
-[Unreleased]: https://github.com/rigplane/rigplane-core/compare/v2.1.2...HEAD
+[Unreleased]: https://github.com/rigplane/rigplane-core/compare/v2.2.0...HEAD
+[2.2.0]: https://github.com/rigplane/rigplane-core/compare/v2.1.2...v2.2.0
 [2.1.2]: https://github.com/rigplane/rigplane-core/compare/v2.1.1...v2.1.2
 [2.1.1]: https://github.com/rigplane/rigplane-core/compare/v2.1.0...v2.1.1
 [2.1.0]: https://github.com/rigplane/rigplane-core/compare/v2.0.3...v2.1.0

{rigplane-2.1.2 → rigplane-2.2.0}/docs/api/web.md

@@ -46,6 +46,7 @@ These routes are part of the Pro/supervisor compatibility surface:
 | `GET` | `/healthz` | Process/API liveness, no API token required |
 | `GET` | `/readyz` | Station readiness, returns `503` until radio is ready |
 | `GET` | `/api/v1/runtime` | Process, bind, radio, rigctld, bridge, and diagnostic runtime status |
+| `GET` | `/api/v1/station` | Friendly station-server identity, readiness, and next-action status |
 | `GET` | `/api/v1/info` | Runtime model/capability summary |
 | `GET` | `/api/v1/state` | Canonical current state snapshot |
 | `GET` | `/api/v1/capabilities` | Full profile-backed capabilities |
@@ -147,6 +148,13 @@ When auth is configured, this endpoint requires the same bearer token as other
     "controlConnected": true,
     "radioReady": true
   },
+  "station": {
+    "readiness": "ready_with_radio",
+    "radioAvailable": true,
+    "backend": "rigplane",
+    "authRequired": true,
+    "message": "Station server is ready with an attached radio."
+  },
   "rigctld": {
     "enabled": true,
     "address": "127.0.0.1:4532"
@@ -159,6 +167,49 @@ When auth is configured, this endpoint requires the same bearer token as other
 }
 ```
 
+## `GET /api/v1/station`
+
+Friendly station-server status for desktop supervisors and setup tools. When
+auth is configured, this endpoint requires the same bearer token as other
+`/api/*` routes.
+
+```json
+{
+  "schema": "rigplane.station.status.v1",
+  "service": "rigplane",
+  "kind": "station_server",
+  "version": "2.0.3",
+  "displayName": "IC-7610",
+  "instanceId": null,
+  "baseUrl": "http://127.0.0.1:58421",
+  "healthUrl": "http://127.0.0.1:58421/healthz",
+  "readinessUrl": "http://127.0.0.1:58421/readyz",
+  "runtimeUrl": "http://127.0.0.1:58421/api/v1/runtime",
+  "stationUrl": "http://127.0.0.1:58421/api/v1/station",
+  "station": {
+    "readiness": "ready_with_radio",
+    "radioAvailable": true,
+    "backend": "rigplane",
+    "authRequired": true,
+    "message": "Station server is ready with an attached radio."
+  },
+  "radio": {
+    "model": "IC-7610",
+    "connected": true,
+    "controlConnected": true,
+    "radioReady": true
+  }
+}
+```
+
+Current readiness values are:
+
+- `ready_with_radio`
+- `radio_powered_off_or_unreachable`
+- `no_usb_radio_connected`
+- `lan_radio_unsupported_or_not_found`
+- `requires_configuration_or_auth`
+
 Managed runtimes also emit a single machine-readable startup event to stdout
 after the web listener has bound successfully. Supervisors should use this JSON
 line as the startup contract instead of parsing the human-readable banner:

{rigplane-2.1.2 → rigplane-2.2.0}/docs/guide/cli.md

@@ -669,6 +669,14 @@ After the web listener binds, `station` writes one JSON startup event to stdout:
 Use this event for supervisor discovery when `--port 0` asks the OS to allocate
 the actual port.
 
+When UDP discovery is enabled, `rigplane station` and `rigplane web` answer
+`RIGPLANE_DISCOVER\n` broadcasts with a `rigplane.station.discovery.v1` JSON
+payload. The payload includes the base URL, `/healthz`, `/readyz`,
+`/api/v1/runtime`, `/api/v1/station`, version, display name, radio model,
+backend, auth-required flag, and a readiness value such as
+`ready_with_radio`, `no_usb_radio_connected`, or
+`radio_powered_off_or_unreachable`.
+
 ### `audio bridge`
 
 Route radio audio to/from a virtual audio device (BlackHole, Loopback, VB-Audio).

{rigplane-2.1.2 → rigplane-2.2.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "rigplane"
-version = "2.1.2"
+version = "2.2.0"
 description = "Python library for controlling Icom transceivers over LAN (UDP) — no wfview/hamlib required"
 readme = "README.md"
 license = "MIT"

{rigplane-2.1.2 → rigplane-2.2.0}/src/rigplane/web/api_contract.py

@@ -44,6 +44,12 @@ STABLE_HTTP_ENDPOINTS: Final[tuple[HttpEndpoint, ...]] = (
         "purpose": "managed runtime status",
         "auth": "bearer",
     },
+    {
+        "method": "GET",
+        "path": "/api/v1/station",
+        "purpose": "friendly station-server status",
+        "auth": "bearer",
+    },
     {
         "method": "GET",
         "path": "/api/v1/info",
@@ -128,11 +134,27 @@ RESPONSE_FIELD_CONTRACTS: Final[dict[str, ResponseFieldContract]] = {
             "authRequired",
             "backend",
             "radio",
+            "station",
             "rigctld",
             "bridge",
             "lastError",
         )
     },
+    "/api/v1/station": {
+        "required": (
+            "schema",
+            "service",
+            "kind",
+            "version",
+            "displayName",
+            "baseUrl",
+            "healthUrl",
+            "readinessUrl",
+            "runtimeUrl",
+            "station",
+            "radio",
+        )
+    },
     "/api/v1/info": {
         "required": (
             "server",

{rigplane-2.1.2 → rigplane-2.2.0}/src/rigplane/web/discovery.py

@@ -35,6 +35,12 @@ class RadioInfo:
 
     model: str
     connected: bool
+    control_connected: bool = False
+    radio_ready: bool = False
+    backend: str | None = None
+    readiness: str | None = None
+    message: str | None = None
+    auth_required: bool = False
 
 
 class _DiscoveryProtocol(asyncio.DatagramProtocol):
@@ -153,12 +159,46 @@ class DiscoveryResponder:
             name = "RigPlane"
 
         payload: dict[str, object] = {
+            "schema": "rigplane.station.discovery.v1",
             "service": "rigplane",
+            "kind": "station_server",
             "version": __version__,
             "url": f"{scheme}://{local_ip}:{self._web_port}",
+            "urls": {
+                "base": f"{scheme}://{local_ip}:{self._web_port}",
+                "health": f"{scheme}://{local_ip}:{self._web_port}/healthz",
+                "readiness": f"{scheme}://{local_ip}:{self._web_port}/readyz",
+                "runtime": (f"{scheme}://{local_ip}:{self._web_port}/api/v1/runtime"),
+                "station": (f"{scheme}://{local_ip}:{self._web_port}/api/v1/station"),
+            },
             "name": name,
+            "displayName": name,
+            "instanceId": None,
+            "station": {
+                "readiness": (
+                    radio_info.readiness
+                    if radio_info and radio_info.readiness
+                    else (
+                        "ready_with_radio"
+                        if radio_info
+                        and (radio_info.radio_ready or radio_info.connected)
+                        else "requires_configuration_or_auth"
+                    )
+                ),
+                "radioAvailable": bool(
+                    radio_info and (radio_info.radio_ready or radio_info.connected)
+                ),
+                "backend": radio_info.backend if radio_info else None,
+                "authRequired": bool(radio_info.auth_required) if radio_info else False,
+                "message": radio_info.message if radio_info else None,
+            },
             "radio": (
-                {"model": radio_info.model, "connected": radio_info.connected}
+                {
+                    "model": radio_info.model,
+                    "connected": radio_info.connected,
+                    "controlConnected": radio_info.control_connected,
+                    "radioReady": radio_info.radio_ready,
+                }
                 if radio_info
                 else None
             ),

{rigplane-2.1.2 → rigplane-2.2.0}/src/rigplane/web/server.py

@@ -1386,6 +1386,85 @@ class WebServer:
         scheme = "https" if self._config.tls else "http"
         return f"{scheme}://{bind['host']}:{bind['port']}"
 
+    def _radio_runtime_payload(self) -> dict[str, Any]:
+        radio = self._radio
+        raw_connected = (
+            getattr(radio, "connected", False) if radio is not None else False
+        )
+        connected = raw_connected if isinstance(raw_connected, bool) else False
+        raw_control_connected = (
+            getattr(radio, "control_connected", False) if radio is not None else False
+        )
+        control_connected = (
+            raw_control_connected if isinstance(raw_control_connected, bool) else False
+        )
+        return {
+            "model": getattr(radio, "model", self._config.radio_model)
+            if radio is not None
+            else self._config.radio_model,
+            "connected": connected,
+            "controlConnected": control_connected,
+            "radioReady": self._radio_ready(),
+        }
+
+    def _station_readiness_payload(self) -> dict[str, Any]:
+        radio = self._radio
+        backend = getattr(radio, "backend_id", None) if radio is not None else None
+        radio_payload = self._radio_runtime_payload()
+        health = self._build_radio_health()
+        if radio_payload["radioReady"]:
+            readiness = "ready_with_radio"
+            message = "Station server is ready with an attached radio."
+        elif radio is None:
+            readiness = "requires_configuration_or_auth"
+            message = "Start the station server with a configured radio target."
+        elif backend in {"icom_serial", "yaesu_cat"}:
+            readiness = "no_usb_radio_connected"
+            message = "Connect the radio by USB and confirm serial permissions."
+        elif backend == "rigplane":
+            likely = health.get("likelyCause")
+            readiness = (
+                "radio_powered_off_or_unreachable"
+                if likely in {"radio_powered_off_likely", "radio_not_responding"}
+                else "lan_radio_unsupported_or_not_found"
+            )
+            message = "Power on the radio and confirm it is reachable on the LAN."
+        else:
+            readiness = "requires_configuration_or_auth"
+            message = "Configure a supported radio target before using this station."
+        return {
+            "readiness": readiness,
+            "radioAvailable": bool(radio_payload["radioReady"]),
+            "backend": backend,
+            "health": health,
+            "authRequired": bool(self._config.auth_token),
+            "message": message,
+        }
+
+    def _station_status_payload(self) -> dict[str, Any]:
+        base_url = self._runtime_base_url()
+        radio_payload = self._radio_runtime_payload()
+        display_name = (
+            radio_payload["model"]
+            if radio_payload["model"]
+            else self._config.radio_model
+        )
+        return {
+            "schema": "rigplane.station.status.v1",
+            "service": "rigplane",
+            "kind": "station_server",
+            "version": __version__,
+            "displayName": display_name,
+            "instanceId": None,
+            "baseUrl": base_url,
+            "healthUrl": f"{base_url}/healthz",
+            "readinessUrl": f"{base_url}/readyz",
+            "runtimeUrl": f"{base_url}/api/v1/runtime",
+            "stationUrl": f"{base_url}/api/v1/station",
+            "station": self._station_readiness_payload(),
+            "radio": radio_payload,
+        }
+
     def startup_event_payload(self) -> dict[str, Any]:
         base_url = self._runtime_base_url()
         return {
@@ -1424,16 +1503,6 @@ class WebServer:
         self, writer: asyncio.StreamWriter, headers: dict[str, str] | None = None
     ) -> None:
         radio = self._radio
-        raw_connected = (
-            getattr(radio, "connected", False) if radio is not None else False
-        )
-        connected = raw_connected if isinstance(raw_connected, bool) else False
-        raw_control_connected = (
-            getattr(radio, "control_connected", False) if radio is not None else False
-        )
-        control_connected = (
-            raw_control_connected if isinstance(raw_control_connected, bool) else False
-        )
         body = json.dumps(
             {
                 "pid": os.getpid(),
@@ -1445,14 +1514,8 @@ class WebServer:
                 "backend": getattr(radio, "backend_id", None)
                 if radio is not None
                 else None,
-                "radio": {
-                    "model": getattr(radio, "model", self._config.radio_model)
-                    if radio is not None
-                    else self._config.radio_model,
-                    "connected": connected,
-                    "controlConnected": control_connected,
-                    "radioReady": self._radio_ready(),
-                },
+                "radio": self._radio_runtime_payload(),
+                "station": self._station_readiness_payload(),
                 "rigctld": {
                     "enabled": self._runtime_rigctld_addr is not None,
                     "address": self._runtime_rigctld_addr,
@@ -1464,6 +1527,15 @@ class WebServer:
         ).encode()
         await _send_json(writer, body, headers)
 
+    async def _serve_station_status(
+        self, writer: asyncio.StreamWriter, headers: dict[str, str] | None = None
+    ) -> None:
+        body = json.dumps(
+            self._station_status_payload(),
+            separators=(",", ":"),
+        ).encode()
+        await _send_json(writer, body, headers)
+
     async def _serve_state(
         self, writer: asyncio.StreamWriter, headers: dict[str, str] | None = None
     ) -> None:

{rigplane-2.1.2 → rigplane-2.2.0}/src/rigplane/web/web_routing.py

@@ -238,6 +238,8 @@ async def dispatch_http_request(
 
     if path == "/api/v1/info":
         await server._serve_info(writer, headers)
+    elif path == "/api/v1/station":
+        await server._serve_station_status(writer, headers)
     elif path == "/api/v1/runtime":
         await server._serve_runtime(writer, headers)
     elif path == "/api/v1/state":

{rigplane-2.1.2 → rigplane-2.2.0}/src/rigplane/web/web_startup.py

@@ -143,13 +143,23 @@ async def start_web_server(server: WebServer) -> None:
         def _radio_provider() -> RadioInfo | None:
             if radio is None:
                 return None
+            radio_payload = server._radio_runtime_payload()
+            station_payload = server._station_readiness_payload()
             return RadioInfo(
-                model=getattr(radio, "model", None) or server._config.radio_model,
-                connected=bool(getattr(radio, "connected", False)),
+                model=str(radio_payload["model"]),
+                connected=bool(radio_payload["connected"]),
+                control_connected=bool(radio_payload["controlConnected"]),
+                radio_ready=bool(radio_payload["radioReady"]),
+                backend=station_payload["backend"]
+                if isinstance(station_payload["backend"], str)
+                else None,
+                readiness=str(station_payload["readiness"]),
+                message=str(station_payload["message"]),
+                auth_required=bool(station_payload["authRequired"]),
             )
 
         server._discovery = DiscoveryResponder(
-            web_port=server._config.port,
+            web_port=server._runtime_bind_payload()["port"],
             tls=server._config.tls,
             radio_provider=_radio_provider,
             discovery_port=server._config.discovery_port,