Add ham license requirement for amateur radio devices and related UI updates

Author: thebentern

components/DeviceDetail.vue

@@ -32,6 +32,13 @@
         class="h-6 m-1 pb-1"
         alt="Meshtastic UI"
       >
+      <img
+        v-if="requiresHamLicense(props.device)"
+        src="@/assets/img/hamvention.svg"
+        class="h-6 m-1 pb-1"
+        :title="$t('device.ham_license_required')"
+        :alt="$t('device.ham_license_required')"
+      >
     </div>
     <div
       v-if="props.device.images && isSupporterDevice(props.device)"
@@ -74,6 +81,7 @@
 <script lang="ts" setup>
 import type { DeviceHardware } from '~/types/api'
 import { supportedVendorDeviceTags } from '~/types/resources'
+import { requiresHamLicense } from '~/utils/deviceBadges'
 import { useFirmwareStore } from '../stores/firmwareStore'
 import { computed } from 'vue'
 

i18n/locales/en.json

@@ -32,7 +32,8 @@
     "subheading": "If your connected device already has Meshtastic installed, you can automatically detect it:",
     "auto_detect": "Auto-detect",
     "supported_devices": "Supported Devices",
-    "diy_devices": "Community Supported Devices"
+    "diy_devices": "Community Supported Devices",
+    "ham_license_required": "Amateur radio band — an amateur radio license is required to transmit"
   },
   "firmware": {
     "title": "Firmware",

stores/deviceStore.ts

@@ -1,8 +1,10 @@
 import { mande } from 'mande'
 import { defineStore } from 'pinia'
 import {
+  eventMode,
   vendorCobrandingTag,
 } from '~/types/resources'
+import { applyEventDeviceOverrides } from '~/utils/eventDevices'
 
 import { MeshDevice } from '@meshtastic/core'
 import { TransportWebSerial } from '@meshtastic/transport-web-serial'
@@ -37,7 +39,7 @@ export const useDeviceStore = defineStore('device', {
       selectedDevice: <DeviceHardware | undefined>undefined,
       selectedTarget: <DeviceHardware | undefined>undefined,
       tag: <string | undefined>undefined,
-      targets: <DeviceHardware[]>[],
+      apiTargets: <DeviceHardware[]>[],
       isConnecting: false,
       abortController: <AbortController | undefined>undefined,
       readerClosed: <Promise<any> | undefined>undefined,
@@ -46,6 +48,17 @@ export const useDeviceStore = defineStore('device', {
     }
   },
   getters: {
+    /**
+     * The API device list plus any devices only the active event's firmware
+     * build ships. Derived (not baked into state) so it stays correct however
+     * event mode and the device fetch interleave — plugins/eventMode.client.ts
+     * can still re-resolve the edition from the live API after mount.
+     */
+    targets(): DeviceHardware[] {
+      // Co-branded builds are pinned to one vendor's devices; never widen them.
+      if (vendorCobrandingTag.length > 0) return this.apiTargets
+      return applyEventDeviceOverrides(this.apiTargets, eventMode.enabled ? eventMode.eventTag : undefined)
+    },
     filteredDevices(): DeviceHardware[] {
       if (this.tag) {
         return this.targets.filter(t => t.tags?.includes(this.tag ?? '') || t.architecture === this.tag)
@@ -124,14 +137,14 @@ export const useDeviceStore = defineStore('device', {
     },
     setTargetsList(targets: DeviceHardware[]) {
       if (vendorCobrandingTag.length > 0) {
-        this.targets = targets.filter(
+        this.apiTargets = targets.filter(
           (t: DeviceHardware) => t.activelySupported
             && !t.architecture.toLowerCase().startsWith('portduino')
             && t.tags?.includes(vendorCobrandingTag),
         )
       }
       else {
-        this.targets = targets.filter(
+        this.apiTargets = targets.filter(
           (t: DeviceHardware) => t.activelySupported
             && !t.architecture.toLowerCase().startsWith('portduino'),
         )

utils/deviceBadges.ts

@@ -0,0 +1,16 @@
+import type { DeviceHardware } from '~/types/api'
+
+/**
+ * Devices that transmit in an amateur radio band rather than an ISM band — the
+ * T-Beam BPF is a 144–148 MHz (2 m) ~5 W board — so operating one legally needs
+ * an amateur radio licence. Matched on platformioTarget so the badge survives
+ * the device graduating from the event overlay (utils/eventDevices.ts) to the
+ * published API device list.
+ */
+const hamBandTargets = new Set([
+  't-beam-bpf',
+])
+
+export function requiresHamLicense(device: DeviceHardware): boolean {
+  return hamBandTargets.has(device.platformioTarget)
+}

utils/eventDevices.test.ts

@@ -0,0 +1,49 @@
+import { describe, it, expect } from 'vitest'
+import { applyEventDeviceOverrides, eventOnlyDevices } from './eventDevices'
+import type { DeviceHardware } from '~/types/api'
+
+const tbeam1w: DeviceHardware = {
+  hwModel: 122,
+  hwModelSlug: 'TBEAM_1_WATT',
+  platformioTarget: 't-beam-1w',
+  architecture: 'esp32-s3',
+  activelySupported: true,
+  displayName: 'LilyGo T-Beam 1W',
+  supportLevel: 1,
+  tags: ['LilyGo'],
+}
+
+const apiList: DeviceHardware[] = [tbeam1w]
+
+describe('applyEventDeviceOverrides', () => {
+  it('adds the T-Beam BPF in DEF CON mode', () => {
+    const targets = applyEventDeviceOverrides(apiList, 'DEFCON')
+    const bpf = targets.find(t => t.platformioTarget === 't-beam-bpf')
+    expect(bpf).toBeDefined()
+    expect(bpf?.activelySupported).toBe(true)
+    expect(bpf?.hwModel).toBe(124)
+    expect(bpf?.architecture).toBe('esp32-s3')
+    // 16MB drives the OTA/spiffs offsets of the legacy clean-install path.
+    expect(bpf?.partitionScheme).toBe('16MB')
+    expect(bpf?.images).toEqual(['tbeam-bpf.svg'])
+  })
+
+  it('leaves the list untouched off the DEF CON domain', () => {
+    expect(applyEventDeviceOverrides(apiList, undefined)).toBe(apiList)
+    expect(applyEventDeviceOverrides(apiList, 'Hamvention')).toBe(apiList)
+    expect(applyEventDeviceOverrides(apiList, 'Burning Man')).toBe(apiList)
+  })
+
+  it('does not duplicate a device the API already publishes', () => {
+    const published = [...apiList, ...eventOnlyDevices.DEFCON]
+    const targets = applyEventDeviceOverrides(published, 'DEFCON')
+    expect(targets).toBe(published)
+    expect(targets.filter(t => t.platformioTarget === 't-beam-bpf')).toHaveLength(1)
+  })
+
+  it('does not mutate the source list', () => {
+    const source = [...apiList]
+    applyEventDeviceOverrides(source, 'DEFCON')
+    expect(source).toEqual(apiList)
+  })
+})

utils/eventDevices.ts

@@ -0,0 +1,56 @@
+import type { DeviceHardware } from '~/types/api'
+
+/**
+ * Devices an event's custom firmware build ships but that
+ * api.meshtastic.org/resource/deviceHardware does not publish as actively
+ * supported yet. Keyed by the edition's event tag (EventModeConfig.eventTag),
+ * so an entry only ever reaches the device picker on that event's domain.
+ *
+ * Each entry mirrors the custom_meshtastic_* metadata in the firmware repo's
+ * variants/<arch>/<env>/platformio.ini — the same source the API generates from
+ * — so the UI doesn't shift once the API catches up. Entries are inert (not
+ * duplicated) after that happens, but delete them anyway to keep this honest.
+ */
+export const eventOnlyDevices: Record<string, DeviceHardware[]> = {
+  // DEF CON 34's build ships firmware-t-beam-bpf-*, but hwModel 124 is still
+  // absent from the API device list.
+  // https://github.com/meshtastic/firmware/blob/master/variants/esp32s3/t-beam-bpf/platformio.ini
+  DEFCON: [
+    {
+      hwModel: 124,
+      hwModelSlug: 'TBEAM_BPF',
+      platformioTarget: 't-beam-bpf',
+      // The API normalises the platformio `esp32s3` to a hyphenated arch, which
+      // is what the flash flow matches on (see components/targets/Esp32.vue).
+      architecture: 'esp32-s3',
+      activelySupported: true,
+      displayName: 'LilyGo T-Beam BPF',
+      supportLevel: 3,
+      tags: ['LilyGo'],
+      images: ['tbeam-bpf.svg'],
+      // board_build.partitions = default_16MB.csv
+      partitionScheme: '16MB',
+      hasMui: false,
+      hasInkHud: false,
+    },
+  ],
+}
+
+/**
+ * Overlay the active event's extra devices onto the API device list. A no-op
+ * when no event is active, the event has no extras, or the API already
+ * publishes the device — so this only ever adds entries on an event domain.
+ */
+export function applyEventDeviceOverrides(
+  targets: DeviceHardware[],
+  eventTag?: string,
+): DeviceHardware[] {
+  const extras = eventTag ? eventOnlyDevices[eventTag] : undefined
+  if (!extras?.length) return targets
+
+  const missing = extras.filter(
+    extra => !targets.some(t => t.platformioTarget === extra.platformioTarget),
+  )
+  if (!missing.length) return targets
+  return [...targets, ...missing]
+}