Telemetry stream: GET /api/telemetry + MCP get_telemetry (#16 )

Fix BigInt serialization in GET /api/device (500 on real hardware) (#14 )
Device info endpoint + richer node summaries (GET /api/device, MCP device_info) (#13 )
2026-09-24 23:56:11 +02:00 · 2026-09-24 23:14:32 +02:00 · 2026-09-24 22:46:40 +02:00
11 changed files with 695 additions and 10 deletions
@@ -17,8 +17,8 @@
 ## API

 1. **Live base URL** — `http://bot.dev.kkhost.pl` (Traefik → docker-compose stack on this host; container port 3000 via external network dev_net, no published ports).
-2. **Endpoints** — all under the `/api` global prefix: `GET /api/status` (`{ connected, myNodeNum, host, port }`), `POST /api/send` (body `{ "text": "...", "to"?: <node number | node name | "!b" | "broadcast"> }` — numbers pass through as-is (integer 1..0xffffffff), names resolve like `GET /api/nodes/:id`, omitted/""/"!b"/"broadcast" → broadcast; unknown or ambiguous targets are a 400. Returns `{ id }`), `GET /api/channels` (the device's Meshtastic channels as `{ index, name, uplinkEnabled, downlinkEnabled }[]`; psk/keys redacted), `GET /api/messages` (message history newest first: rx text with `from`, tx sends with `to` + `status` pending→delivered/failed via routing ACKs — broadcasts stay pending because firmware strips want_ack; last 100, in-memory, reset on reconnect), `GET /api/nodes` (known nodes sorted by num as `{ num, longName?, shortName?, hwModel?, batteryLevel?, lastHeard: number|null, position?: { lat, lon, alt? } }[]`, from the initial sync plus live POSITION_APP updates; reset on reconnect) and `GET /api/nodes/:id` (lookup by exact node number/numeric string, then case-insensitive exact long/short name, else unique substring; 404 when ambiguous or missing). Scalar API docs are served at `/` (OpenAPI JSON at `/docs-json`). Keep this list in sync with the controller. All `POST /api/send` traffic targets channel index 3 (`test`) on purpose — never the primary channel; override via `MESH_SEND_CHANNEL` (default `3`).
-3. **MCP endpoint** — `POST /mcp` (excluded from the `/api` prefix in main.ts, like Scalar at `/`): an in-process MCP server over the official SDK's Streamable HTTP transport in stateless mode (`sessionIdGenerator: undefined`, fresh `McpServer` + transport per request). Tools map 1:1 to MeshService methods: `mesh_status`, `send_message(text, to?)` (same resolution as `POST /api/send`; errors surface as tool errors with the same messages), `list_channels`, `list_nodes`, `get_node(id)` (tool error when missing/ambiguous), `get_messages`. Results are JSON in a text content block; sends ride channel index 3 like everything else. Note: the SDK's root entry is broken upstream (#2273) — import via subpaths (`@modelcontextprotocol/sdk/server/mcp.js` etc.).
+2. **Endpoints** — all under the `/api` global prefix: `GET /api/status` (`{ connected, myNodeNum, host, port }`), `POST /api/send` (body `{ "text": "...", "to"?: <node number | node name | "!b" | "broadcast"> }` — numbers pass through as-is (integer 1..0xffffffff), names resolve like `GET /api/nodes/:id`, omitted/""/"!b"/"broadcast" → broadcast; unknown or ambiguous targets are a 400. Returns `{ id }`), `GET /api/channels` (the device's Meshtastic channels as `{ index, name, uplinkEnabled, downlinkEnabled }[]`; psk/keys redacted), `GET /api/device` (device info captured during the initial sync: `{ myNodeNum, firmwareVersion?, metadata?, localConfig: {<section>: ...}, moduleConfig: {<module>: ...} }` — DeviceMetadata as-is plus per-section Config/ModuleConfig messages; security publicKey/privateKey/adminKey and network wifiPsk redacted to `"REDACTED"`; in-memory, reset on reconnect), `GET /api/messages` (message history newest first: rx text with `from`, tx sends with `to` + `status` pending→delivered/failed via routing ACKs — broadcasts stay pending because firmware strips want_ack; last 100, in-memory, reset on reconnect), `GET /api/telemetry` (telemetry history newest first as `{ from, at /* epoch ms */, kind, data }[]`: live TELEMETRY_APP packets — device metrics and environment sensor readings where nodes have them; kind is the meshtastic.Telemetry oneof case name (deviceMetrics/environmentMetrics/airQualityMetrics/powerMetrics/localStats/healthMetrics/hostMetrics/trafficManagementStats), data that variant's payload with proto uint64 fields as decimal strings; last 100, in-memory, reset on reconnect), `GET /api/nodes` (known nodes sorted by num as `{ num, longName?, shortName?, hwModel?, batteryLevel?, lastHeard: number|null, position?: { lat, lon, alt? }, snr?, hopsAway?, viaMqtt? }[]`, from the initial sync plus live POSITION_APP updates; reset on reconnect) and `GET /api/nodes/:id` (lookup by exact node number/numeric string, then case-insensitive exact long/short name, else unique substring; 404 when ambiguous or missing). Scalar API docs are served at `/` (OpenAPI JSON at `/docs-json`). Keep this list in sync with the controller. All `POST /api/send` traffic targets channel index 3 (`test`) on purpose — never the primary channel; override via `MESH_SEND_CHANNEL` (default `3`).
+3. **MCP endpoint** — `POST /mcp` (excluded from the `/api` prefix in main.ts, like Scalar at `/`): an in-process MCP server over the official SDK's Streamable HTTP transport in stateless mode (`sessionIdGenerator: undefined`, fresh `McpServer` + transport per request). Tools map 1:1 to MeshService methods: `mesh_status`, `send_message(text, to?)` (same resolution as `POST /api/send`; errors surface as tool errors with the same messages), `list_channels`, `list_nodes`, `get_node(id)` (tool error when missing/ambiguous), `get_messages`, `get_telemetry` (same bounded recent window as `GET /api/telemetry`), `device_info` (same redaction as `GET /api/device`). Results are JSON in a text content block; sends ride channel index 3 like everything else. Note: the SDK's root entry is broken upstream (#2273) — import via subpaths (`@modelcontextprotocol/sdk/server/mcp.js` etc.).

 ## Other

@@ -1,5 +1,28 @@
 # Changelog

+## v0.8.0 — 2026-09-24 21:40
+
+- New `GET /api/telemetry` endpoint (and matching MCP tool `get_telemetry`, now eight tools): the telemetry stream captured from live `TELEMETRY_APP` packets (portnum 67) — device metrics (uptime/battery/voltage/channel+air utilization) and environment sensor readings where nodes have them. Records are `{ from, at /* epoch ms */, kind, data }[]` newest first: `kind` is the `meshtastic.Telemetry` oneof case name (`deviceMetrics`, `environmentMetrics`, `airQualityMetrics`, `powerMetrics`, `localStats`, `healthMetrics`, `hostMetrics` or `trafficManagementStats`) and `data` is that variant's payload. In-memory only, last 100 (same bounded pattern as message history), reset on every bridge reconnect.
+- `MeshService.telemetry()` captures the new portnum in the existing packet handler: the `Data.payload` is decoded as a `meshtastic.Telemetry`, and packets without a variant payload are ignored. The variant payload goes through the same module-scope `jsonSafe` converter added in v0.7.1 — telemetry variants carry proto `uint64` fields (e.g. host-metrics byte counters) that decode to native bigint and would 500 Express' `res.json` otherwise, so they come back as decimal strings; unset optional fields are omitted from `data`.
+- Verified against the installed `@meshtastic/protobufs` 2.8.0: `PortNum.TELEMETRY_APP = 67`; `Telemetry` is a `fixed32 time` plus oneof variant with exactly those eight cases; `DeviceMetrics` fields are batteryLevel/voltage/channelUtilization/airUtilTx/uptimeSeconds and `EnvironmentMetrics` the full sensor set (temperature, relativeHumidity, barometricPressure, gasResistance, voltage, current, iaq, distance, lux variants, wind/rainfall/soil/lightning, adc channels).
+- Swagger: `GET /api/telemetry` documented with the kind values and an example carrying one record per kind. README + AGENTS.md endpoint/tool lists updated.
+- Tests: fake-bridge gains a shared `telemetryPacketFrame` builder; new telemetry specs (device-metrics + environment variants → correct from/kind/data, cap at 100 dropping the oldest, reset on reconnect); MCP spec updated to eight tools incl. a `get_telemetry` call check.
+
+## v0.7.1 — 2026-09-24 21:10
+
+- Fix `GET /api/device` and MCP `device_info` crashing with `TypeError: Do not know how to serialize a BigInt` on live hardware (fw 2.7.15): protobuf-es decodes proto `uint64` fields as native JS `bigint`, which Express' `res.json`/`JSON.stringify` reject, and `MeshService.deviceInfo()` passed raw decoded proto objects through unconverted. Known affected fields: `Config.PowerConfig.powermonEnables` (in `localConfig.power`) and host-metrics byte counters (`freememBytes`/`diskfree*`).
+- Fix at the single choke point: one small recursive converter (`jsonSafe`, bigint → decimal string, plain objects/arrays/primitives pass through) applied in `deviceInfo()` to everything that comes from raw decoded proto messages — DeviceMetadata plus every localConfig and moduleConfig section. No per-field patching; any uint64 field in those messages is covered generically. Values that were bigint now serialize as strings (e.g. `"powermonEnables": "123"`); no other endpoint/shape changes, redaction logic untouched.
+- Tests: new device-info spec feeds a power config section frame with `powermonEnables` set to a real bigint through the fake bridge and asserts the value comes back as its string form (`"123"`) and that `JSON.stringify(deviceInfo())` succeeds — the old fixtures never set a uint64 field, which is why this slipped past the suite.
+
+## v0.7.0 — 2026-09-24 20:21
+
+- New `GET /api/device` endpoint (and matching MCP tool `device_info`, now seven tools): device info captured during the initial sync — this device's node number, firmware version and metadata (`meshtastic.DeviceMetadata` as-is; it carries no key material), plus per-section config and module-config messages keyed by section name. In-memory only, reset on every bridge reconnect like channels/nodes.
+- `MeshService.deviceInfo()` captures the new FromRadio cases during sync: `metadata` (DeviceMetadata), `config` (one `meshtastic.Config` per section — oneof `payloadVariant` cases device/position/power/network/display/lora/bluetooth/security/sessionkey/deviceUi) and `moduleConfig` (one ModuleConfig per module). Verified against the installed `@meshtastic/protobufs` 2.8.0: FromRadio carries `meshtastic.Config`, not `LocalConfig` (that type lives in a separate localonly namespace and is not part of FromRadio).
+- **Mandatory redaction (trust boundary):** key material never leaves the process — security section `publicKey`/`privateKey`/`adminKey` and network section `wifiPsk` are replaced with `"REDACTED"` in all output.
+- Node summaries (`GET /api/nodes`, `GET /api/nodes/:id`, MCP `list_nodes`/`get_node`) gain optional fields from the NodeInfo: `snr` (dB), `hopsAway`, `viaMqtt` — present only when the device reported them. Note: `meshtastic.NodeInfo` in 2.8.0 has no firmware version field, so per-node firmwareVersion is not captured (device-level firmware version comes from DeviceMetadata via `/api/device`).
+- Swagger: `GET /api/device` documented with the redaction note and an example; nodes endpoint example/description extended for the new optional fields. README + AGENTS.md endpoint lists updated.
+- Tests: fake-bridge gains `metadataFrame`, `configSectionFrame`, `moduleConfigSectionFrame`; new device-info specs (metadata → firmwareVersion, config/module-config sections captured with security key material absent from the JSON output), NodeInfo snr/hopsAway/viaMqtt in summaries; MCP spec updated to seven tools incl. a `device_info` call check.
+
 ## v0.6.0 — 2026-09-24 18:28

 - New MCP (Model Context Protocol) server endpoint at `POST /mcp` (outside the `/api` prefix, like Scalar at `/`), served in-process via the official `@modelcontextprotocol/sdk` Streamable HTTP transport in stateless mode (`sessionIdGenerator: undefined`; a fresh `McpServer` + transport per request). Six tools map 1:1 to existing `MeshService` methods with no new logic: `mesh_status`, `send_message(text, to?)` (same target resolution as `POST /api/send` — omitted/""/"!b"/"broadcast" → broadcast, numbers pass through, names via the node DB; resolution errors surface as tool errors with the same messages), `list_channels`, `list_nodes`, `get_node(id)` (tool error when missing/ambiguous), and `get_messages`. Tool results are JSON in a text content block.
@@ -28,8 +28,10 @@ All API endpoints live under the `/api` prefix:
 - `GET /api/status` — `{ connected, myNodeNum, host, port }`
 - `POST /api/send` — body `{ "text": "...", "to"?: <node number | node name | "!b" | "broadcast"> }`, returns `{ id }`. Numbers pass through as-is (integer in 1..0xffffffff); names resolve like `GET /api/nodes/:id` (exact long/short name, then unique substring) — unknown or ambiguous targets are a 400
 - `GET /api/channels` — the device's Meshtastic channels as `{ index, name, uplinkEnabled, downlinkEnabled }[]` (psk/keys are redacted; empty until the initial sync completes)
+- `GET /api/device` — device info captured during the initial sync: `{ myNodeNum, firmwareVersion?, metadata?, localConfig: {<section>: ...}, moduleConfig: {<module>: ...} }`. Key material is never exposed (security publicKey/privateKey/adminKey and network wifiPsk are replaced with `"REDACTED"`); in-memory only, reset on every bridge reconnect
 - `GET /api/messages` — message history, newest first: inbound text (`dir:'rx'`, with `from`) and our sends (`dir:'tx'`, with `to` + `status`). tx records start `pending` and move to `delivered`/`failed` (with human-readable `ackError`) when the routing ACK/NACK arrives; broadcasts stay `pending` because firmware strips want_ack before TX. In-memory only, last 100, reset on every bridge reconnect
- `GET /api/nodes` — known mesh nodes as `{ num, longName?, shortName?, hwModel?, batteryLevel?, lastHeard: number|null, position?: { lat, lon, alt? } }[]`, sorted by node number. Collected during the initial sync plus live position updates; names/hwModel/battery appear only when reported, `lastHeard` is epoch seconds (null = never heard), and `position` only when both coordinates are known
+- `GET /api/telemetry` — telemetry history, newest first: live `TELEMETRY_APP` packets from any node as `{ from, at /* epoch ms */, kind, data }[]`. `kind` is the `meshtastic.Telemetry` oneof case name (`deviceMetrics`, `environmentMetrics`, `airQualityMetrics`, `powerMetrics`, `localStats`, `healthMetrics`, `hostMetrics` or `trafficManagementStats`) and `data` carries that variant's payload (proto uint64 fields as decimal strings; unset optional fields omitted). In-memory only, last 100, reset on every bridge reconnect
+- `GET /api/nodes` — known mesh nodes as `{ num, longName?, shortName?, hwModel?, batteryLevel?, lastHeard: number|null, position?: { lat, lon, alt? }, snr?, hopsAway?, viaMqtt? }[]`, sorted by node number. Collected during the initial sync plus live position updates; names/hwModel/battery appear only when reported, `lastHeard` is epoch seconds (null = never heard), `position` only when both coordinates are known, and snr/hopsAway/viaMqtt only when carried by the NodeInfo
 - `GET /api/nodes/:id` — one node looked up by exact node number (numbers or numeric strings), then case-insensitive exact long/short name, else the unique case-insensitive substring match; 404 when nothing or more than one node matches

 Interactive API docs (Scalar) are served at `/`, with the OpenAPI JSON at
@@ -40,7 +42,9 @@ curl http://localhost:3000/api/status
 curl -X POST http://localhost:3000/api/send -H 'content-type: application/json' -d '{"text":"hi"}'
 curl -X POST http://localhost:3000/api/send -H 'content-type: application/json' -d '{"to":123456789,"text":"hello"}'
 curl http://localhost:3000/api/channels
+curl http://localhost:3000/api/device
 curl http://localhost:3000/api/messages
+curl http://localhost:3000/api/telemetry
 curl http://localhost:3000/api/nodes
 curl http://localhost:3000/api/nodes/kamil
 ```
@@ -66,6 +70,8 @@ endpoints — no new logic, same channel pinning:
 - `list_nodes` — known nodes as lean summaries
 - `get_node(id)` — one node by number or name; tool error when missing/ambiguous
 - `get_messages` — message history, newest first (last 100, tx records carry delivery status)
+- `get_telemetry` — telemetry history, newest first (last 100): device metrics and environment sensor readings from any node; `kind` is the Telemetry oneof case name
+- `device_info` — device info from the initial sync: node number, firmware version, metadata and per-section config/module-config (key material redacted as `"REDACTED"`)

 Point any MCP client at it (Streamable HTTP URL):

@@ -1,6 +1,6 @@
 {
  "name": "mesh-bot",
-  "version": "0.6.0",
+  "version": "0.8.0",
  "description": "",
  "author": "",
  "private": true,
@@ -14,6 +14,8 @@ export const PORT_TEXT_MESSAGE_APP = 1;
 export const PORT_POSITION_APP = 3;
 // verified against installed @meshtastic/protobufs Portnums.PortNum.ROUTING_APP
 export const PORT_ROUTING_APP = 5;
+// verified against installed @meshtastic/protobufs Portnums.PortNum.TELEMETRY_APP
+export const PORT_TELEMETRY_APP = 67;

 const START1 = 0x94;
 const START2 = 0xc3;
@@ -81,6 +83,14 @@ export async function decodeRouting(
  return fromBinary(P.Mesh.RoutingSchema, bytes);
 }

+/** TELEMETRY_APP packets carry a serialized meshtastic.Telemetry in Data.payload. */
+export async function decodeTelemetry(
+  bytes: Uint8Array,
+): Promise<import('@meshtastic/protobufs').Telemetry.Telemetry> {
+  const P = await loadProto();
+  return fromBinary(P.Telemetry.TelemetrySchema, bytes);
+}
+
 /** Human-readable name for a Routing.Error code (from the installed @meshtastic/protobufs enum), `reason <n>` fallback. */
 export async function describeRoutingError(code: number): Promise<string> {
  const P = await loadProto();
@@ -46,6 +46,64 @@ export interface NodeInfoFields {
  position?: { latitudeI?: number; longitudeI?: number; altitude?: number };
  lastHeard?: number;
  deviceMetrics?: { batteryLevel?: number };
+  snr?: number;
+  viaMqtt?: boolean;
+  hopsAway?: number;
+}
+
+// init shape for create(): all fields optional (protobuf-es' MessageInit is not exported)
+type Init<T> = {
+  [P in keyof T as P extends '$unknown' | '$typeName' ? never : P]?: T[P];
+};
+
+/** DeviceMetadata frame as streamed once during the initial sync. */
+export function metadataFrame(md: Init<P.Mesh.DeviceMetadata>): Uint8Array {
+  const fr = create(P.Mesh.FromRadioSchema, {
+    payloadVariant: { case: 'metadata', value: md },
+  });
+  return frame(toBinary(P.Mesh.FromRadioSchema, fr));
+}
+
+// Config/ModuleConfig section frames as streamed one-per-section during the initial sync.
+// (meshtastic.Config / meshtastic.ModuleConfig live in their own root namespaces, not under Mesh)
+export function configSectionFrame(
+  sectionCase: P.Config.Config['payloadVariant']['case'],
+  value: unknown,
+): Uint8Array {
+  const cfg = create(P.Config.ConfigSchema, {
+    payloadVariant: {
+      case: sectionCase,
+      value,
+    } as P.Config.Config['payloadVariant'],
+  });
+  return frame(
+    toBinary(
+      P.Mesh.FromRadioSchema,
+      create(P.Mesh.FromRadioSchema, {
+        payloadVariant: { case: 'config', value: cfg },
+      }),
+    ),
+  );
+}
+
+export function moduleConfigSectionFrame(
+  sectionCase: P.ModuleConfig.ModuleConfig['payloadVariant']['case'],
+  value: unknown,
+): Uint8Array {
+  const mc = create(P.ModuleConfig.ModuleConfigSchema, {
+    payloadVariant: {
+      case: sectionCase,
+      value,
+    } as P.ModuleConfig.ModuleConfig['payloadVariant'],
+  });
+  return frame(
+    toBinary(
+      P.Mesh.FromRadioSchema,
+      create(P.Mesh.FromRadioSchema, {
+        payloadVariant: { case: 'moduleConfig', value: mc },
+      }),
+    ),
+  );
 }

 export function nodeInfoFrame(
@@ -63,6 +121,33 @@ export function nodeInfoFrame(
  );
 }

+/** TELEMETRY_APP packet frame with a serialized Telemetry in Data.payload (live telemetry from any node). */
+export function telemetryPacketFrame(
+  from: number,
+  variant: P.Telemetry.Telemetry['variant'],
+): Uint8Array {
+  const data = create(P.Mesh.DataSchema, {
+    portnum: P.Portnums.PortNum.TELEMETRY_APP,
+    payload: toBinary(
+      P.Telemetry.TelemetrySchema,
+      create(P.Telemetry.TelemetrySchema, { variant }),
+    ),
+  });
+  const pkt = create(P.Mesh.MeshPacketSchema, {
+    from,
+    id: 1,
+    payloadVariant: { case: 'decoded', value: data },
+  });
+  return frame(
+    toBinary(
+      P.Mesh.FromRadioSchema,
+      create(P.Mesh.FromRadioSchema, {
+        payloadVariant: { case: 'packet', value: pkt },
+      }),
+    ),
+  );
+}
+
 export const KAMIL_NUM = 123456789;

 export function kamilNodeInfo(): NodeInfoFields {
@@ -8,6 +8,7 @@ import {
  kamilNodeInfo,
  nodeInfoFrame,
  startBridge,
+  telemetryPacketFrame,
  waitFor,
 } from './fake-bridge.js';
 import { createMeshMcpServer } from './mcp.controller.js';
@@ -64,15 +65,17 @@ async function connectMcp(svc: MeshService): Promise<{
 }

 describe('MCP server tools', () => {
-  it('lists all six tools with descriptions and input schemas', async () => {
+  it('lists all eight tools with descriptions and input schemas', async () => {
    const env = await connectedService();
    try {
      const mcp = await connectMcp(env.svc);
      try {
        const { tools } = await mcp.client.listTools();
        expect(tools.map((t) => t.name).sort()).toEqual([
+          'device_info',
          'get_messages',
          'get_node',
+          'get_telemetry',
          'list_channels',
          'list_nodes',
          'mesh_status',
@@ -215,7 +218,7 @@ describe('MCP server tools', () => {
    }
  });

-  it('list_channels, list_nodes and get_messages return the service data', async () => {
+  it('list_channels, list_nodes, get_messages and device_info return the service data', async () => {
    const env = await connectedService();
    try {
      env.sockets[0].write(nodeInfoFrame(KAMIL_NUM, kamilNodeInfo()));
@@ -234,6 +237,15 @@ describe('MCP server tools', () => {
          ),
        ).toEqual([]); // no channel frames fed yet

+        // no metadata/config frames fed yet → empty sections, null node num
+        expect(
+          JSON.parse(
+            toolText(
+              await mcp.client.callTool({ name: 'device_info', arguments: {} }),
+            ),
+          ),
+        ).toEqual({ myNodeNum: null, localConfig: {}, moduleConfig: {} });
+
        const nodes = JSON.parse(
          toolText(
            await mcp.client.callTool({ name: 'list_nodes', arguments: {} }),
@@ -253,6 +265,25 @@ describe('MCP server tools', () => {
          ),
        ) as { dir: string; to?: number }[];
        expect(msgs[0]).toMatchObject({ dir: 'tx', to: BROADCAST_ADDR }); // newest first
+
+        env.sockets[0].write(
+          telemetryPacketFrame(KAMIL_NUM, {
+            case: 'deviceMetrics',
+            value: { batteryLevel: 87 },
+          }),
+        );
+        await waitFor(() => env.svc.telemetry().length === 1);
+        const tel = JSON.parse(
+          toolText(
+            await mcp.client.callTool({ name: 'get_telemetry', arguments: {} }),
+          ),
+        ) as { from: number; kind: string; data: object }[];
+        expect(tel).toHaveLength(1);
+        expect(tel[0]).toMatchObject({
+          from: KAMIL_NUM,
+          kind: 'deviceMetrics',
+        });
+        expect(tel[0].data).toEqual({ batteryLevel: 87 });
      } finally {
        await mcp.close();
      }
@@ -77,6 +77,22 @@ export function createMeshMcpServer(mesh: MeshService): McpServer {
    async () => jsonResult(mesh.messages()),
  );

+  server.registerTool(
+    'get_telemetry',
+    {
+      description: `Telemetry history, newest first (bounded recent window, last 100): TELEMETRY_APP packets from any node — device metrics (uptime/battery/voltage/channel+air utilization) and environment sensor readings where nodes have them. kind is the meshtastic.Telemetry oneof case name; data carries that variant's payload (proto uint64 fields as decimal strings). In-memory only, reset on every bridge reconnect.${CHANNEL_NOTE}`,
+    },
+    async () => jsonResult(mesh.telemetry()),
+  );
+
+  server.registerTool(
+    'device_info',
+    {
+      description: `Device info captured during the initial sync: this device's node number, firmware version and metadata, plus per-section config/module-config (security publicKey/privateKey/adminKey and network wifiPsk redacted as "REDACTED"). In-memory only, reset on every bridge reconnect.${CHANNEL_NOTE}`,
+    },
+    async () => jsonResult(mesh.deviceInfo()),
+  );
+
  return server;
 }

@@ -13,6 +13,7 @@ import {
  ApiResponse,
  ApiTags,
 } from '@nestjs/swagger';
+import type { DeviceInfo } from './mesh.service.js';
 import { MeshService } from './mesh.service.js';

 export class SendTextDto {
@@ -104,6 +105,51 @@ export class MeshController {
    return this.mesh.channels();
  }

+  @Get('device')
+  @ApiOperation({
+    summary: 'Device info (metadata + config, keys redacted)',
+    description:
+      'This device\'s node number, firmware version and metadata, plus per-section config and module-config messages captured during the initial sync; empty until it completes. Key material is never exposed: security publicKey/privateKey/adminKey and network wifiPsk are replaced with "REDACTED". In-memory only, reset on every bridge reconnect.',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Device info',
+    example: {
+      myNodeNum: 123456789,
+      firmwareVersion: '2.7.0.1',
+      metadata: {
+        firmwareVersion: '2.7.0.1',
+        deviceStateVersion: 1,
+        canShutdown: true,
+        hasWifi: false,
+        hasBluetooth: true,
+        hasEthernet: false,
+        role: 3,
+        positionFlags: 65,
+        hwModel: 42,
+        hasRemoteHardware: false,
+        hasPKC: true,
+        excludedModules: 0,
+      },
+      localConfig: {
+        device: { role: 3, buttonGpio: 13 },
+        security: {
+          publicKey: 'REDACTED',
+          privateKey: 'REDACTED',
+          adminKey: 'REDACTED',
+          isManaged: true,
+        },
+        network: { wifiEnabled: false, wifiSsid: '', wifiPsk: 'REDACTED' },
+      },
+      moduleConfig: {
+        telemetry: { environmentUpdateInterval: 900 },
+      },
+    },
+  })
+  device(): DeviceInfo {
+    return this.mesh.deviceInfo();
+  }
+
  @Get('messages')
  @ApiOperation({
    summary: 'Message history (last 100)',
@@ -137,11 +183,45 @@ export class MeshController {
    return this.mesh.messages();
  }

+  @Get('telemetry')
+  @ApiOperation({
+    summary: 'Telemetry history (last 100)',
+    description:
+      "TELEMETRY_APP packets from any node, newest first. Device metrics (uptime/battery/voltage/channel+air utilization) and environment sensor readings where nodes have them; kind is the meshtastic.Telemetry oneof case name — deviceMetrics, environmentMetrics, airQualityMetrics, powerMetrics, localStats, healthMetrics, hostMetrics or trafficManagementStats — and data carries that variant's payload (proto uint64 fields as decimal strings). In-memory only (last 100), reset on every bridge reconnect.",
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Telemetry records newest first',
+    example: [
+      {
+        from: 987654321,
+        at: 1758000123456,
+        kind: 'deviceMetrics',
+        data: {
+          batteryLevel: 87,
+          voltage: 4.1,
+          channelUtilization: 12.5,
+          airUtilTx: 3.2,
+          uptimeSeconds: 86400,
+        },
+      },
+      {
+        from: 123456789,
+        at: 1758000000000,
+        kind: 'environmentMetrics',
+        data: { temperature: 21.5, relativeHumidity: 48 },
+      },
+    ],
+  })
+  telemetry() {
+    return this.mesh.telemetry();
+  }
+
  @Get('nodes')
  @ApiOperation({
    summary: 'Known mesh nodes (lean summaries)',
    description:
-      'Node database collected during the initial sync plus live POSITION_APP updates; reset on every bridge reconnect. Names, hwModel and batteryLevel appear only when the device reported them.',
+      'Node database collected during the initial sync plus live POSITION_APP updates; reset on every bridge reconnect. Names, hwModel and batteryLevel appear only when the device reported them; snr/hopsAway/viaMqtt only when carried by the NodeInfo.',
  })
  @ApiResponse({
    status: 200,
@@ -155,6 +235,9 @@ export class MeshController {
        batteryLevel: 87,
        lastHeard: 1758000000,
        position: { lat: 52.1049637, lon: 20.9833152, alt: 123 },
+        snr: -2.5,
+        hopsAway: 1,
+        viaMqtt: true,
      },
    ],
  })
@@ -4,9 +4,13 @@ import { describe, expect, it } from 'vitest';
 import { BROADCAST_ADDR, extractFrames, frame } from './codec.js';
 import {
  KAMIL_NUM,
+  configSectionFrame,
  kamilNodeInfo,
+  metadataFrame,
+  moduleConfigSectionFrame,
  nodeInfoFrame,
  startBridge,
+  telemetryPacketFrame,
  waitFor,
 } from './fake-bridge.js';
 import { MeshService } from './mesh.service.js';
@@ -557,6 +561,121 @@ describe('MeshService message history', () => {
  });
 });

+describe('MeshService telemetry', () => {
+  it('captures device metrics and environment variants with from/kind/data', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      expect(svc.telemetry()).toEqual([]); // nothing before the first packet
+
+      bridge.sockets[0].write(
+        telemetryPacketFrame(KAMIL_NUM, {
+          case: 'deviceMetrics',
+          value: { batteryLevel: 87, voltage: 4.1, uptimeSeconds: 3600 },
+        }),
+      );
+      bridge.sockets[0].write(
+        telemetryPacketFrame(987654321, {
+          case: 'environmentMetrics',
+          value: { temperature: 21.5, relativeHumidity: 48 },
+        }),
+      );
+
+      await waitFor(() => svc.telemetry().length === 2);
+      expect(svc.telemetry()).toEqual([
+        {
+          from: 987654321, // newest first
+          at: expect.any(Number),
+          kind: 'environmentMetrics',
+          // the deprecated repeated one_wire_temperature field decodes as an empty list even when unset
+          data: {
+            temperature: 21.5,
+            relativeHumidity: 48,
+            oneWireTemperature: [],
+          },
+        },
+        {
+          from: KAMIL_NUM,
+          at: expect.any(Number),
+          kind: 'deviceMetrics',
+          // proto float is IEEE-754 single precision — 4.1 widens to this exact double
+          data: {
+            batteryLevel: 87,
+            voltage: 4.099999904632568,
+            uptimeSeconds: 3600,
+          },
+        },
+      ]);
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('caps telemetry at 100 records, dropping the oldest', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      for (let i = 0; i < 105; i++)
+        bridge.sockets[0].write(
+          telemetryPacketFrame(42, {
+            case: 'deviceMetrics',
+            value: { batteryLevel: i },
+          }),
+        );
+
+      await waitFor(() => svc.telemetry().length === 100, 10000);
+      expect(svc.telemetry()[0]?.data).toEqual({ batteryLevel: 104 }); // newest first
+      expect(svc.telemetry()[99]?.data).toEqual({ batteryLevel: 5 }); // i=0..4 dropped
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('resets telemetry on reconnect (no stale data)', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    process.env.MESH_RECONNECT_MS = '50';
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      bridge.sockets[0].write(
+        telemetryPacketFrame(KAMIL_NUM, { case: 'deviceMetrics', value: {} }),
+      );
+      await waitFor(() => svc.telemetry().length === 1);
+
+      // drop the connection; bot reconnects and must start with an empty history
+      bridge.sockets[0].destroy();
+      await waitFor(() => bridge.sockets.length >= 2 && svc.status().connected);
+      await waitFor(() => svc.telemetry().length === 0);
+    } finally {
+      delete process.env.MESH_RECONNECT_MS;
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+});
+
 describe('MeshService resolveDest', () => {
  it('resolves broadcast sentinels, numbers and names to node numbers', async () => {
    const bridge = await startBridge();
@@ -614,3 +733,169 @@ describe('MeshService resolveDest', () => {
    }
  });
 });
+
+describe('MeshService device info', () => {
+  it('captures DeviceMetadata and exposes firmwareVersion', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      // before the sync: only the node number (null until myInfo arrives)
+      expect(svc.deviceInfo()).toEqual({
+        myNodeNum: null,
+        localConfig: {},
+        moduleConfig: {},
+      });
+
+      bridge.sockets[0].write(
+        metadataFrame({ firmwareVersion: '2.7.0.1', hasWifi: false, role: 3 }),
+      );
+
+      await waitFor(() => svc.deviceInfo().firmwareVersion === '2.7.0.1');
+      const info = svc.deviceInfo();
+      expect(info.firmwareVersion).toBe('2.7.0.1');
+      expect(info.metadata?.firmwareVersion).toBe('2.7.0.1'); // metadata stored as-is
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('captures config/module-config sections and redacts key material', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      const secret = 'super-secret-wifi-psk';
+      bridge.sockets[0].write(
+        configSectionFrame('security', {
+          publicKey: new Uint8Array([1, 2, 3]),
+          privateKey: new Uint8Array([4, 5, 6]),
+          adminKey: [new Uint8Array([7])],
+          isManaged: true,
+        }),
+      );
+      bridge.sockets[0].write(
+        configSectionFrame('network', {
+          wifiEnabled: false,
+          wifiSsid: 'home',
+          wifiPsk: secret,
+        }),
+      );
+      bridge.sockets[0].write(configSectionFrame('device', { role: 3 }));
+      bridge.sockets[0].write(
+        moduleConfigSectionFrame('telemetry', {
+          environmentUpdateInterval: 900,
+          powerMeasurementEnabled: true,
+        }),
+      );
+
+      await waitFor(
+        () =>
+          Object.keys(svc.deviceInfo().localConfig).length === 3 &&
+          Object.keys(svc.deviceInfo().moduleConfig).length === 1,
+      );
+      const info = svc.deviceInfo();
+      expect(Object.keys(info.localConfig).sort()).toEqual([
+        'device',
+        'network',
+        'security',
+      ]);
+      expect(info.moduleConfig.telemetry).toMatchObject({
+        environmentUpdateInterval: 900,
+        powerMeasurementEnabled: true,
+      });
+
+      // key material is replaced with a marker — never exposed
+      expect(info.localConfig.security).toMatchObject({
+        publicKey: 'REDACTED',
+        privateKey: 'REDACTED',
+        adminKey: 'REDACTED',
+        isManaged: true, // non-secret fields pass through
+      });
+      expect(info.localConfig.network?.wifiPsk).toBe('REDACTED');
+      const json = JSON.stringify(info);
+      expect(json).not.toContain(secret);
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('serializes proto uint64 fields as strings (JSON-safe)', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      // powermonEnables is a proto uint64 — protobuf-es decodes it as native bigint
+      bridge.sockets[0].write(
+        configSectionFrame('power', { powermonEnables: 123n }),
+      );
+
+      await waitFor(() => svc.deviceInfo().localConfig.power !== undefined);
+      const info = svc.deviceInfo();
+      expect(info.localConfig.power?.powermonEnables).toBe('123'); // bigint -> decimal string
+      expect(() => JSON.stringify(info)).not.toThrow(); // no "Do not know how to serialize a BigInt"
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('summarizes NodeInfo snr/hopsAway/viaMqtt when present', async () => {
+    const bridge = await startBridge();
+    process.env.MESH_HOST = '127.0.0.1';
+    process.env.MESH_PORT = String(bridge.port);
+    const svc = new MeshService();
+    try {
+      svc.onModuleInit();
+      await waitFor(
+        () => bridge.sockets.length === 1 && svc.status().connected,
+      );
+
+      bridge.sockets[0].write(nodeInfoFrame(KAMIL_NUM, kamilNodeInfo()));
+      bridge.sockets[0].write(
+        nodeInfoFrame(42, {
+          user: { id: '!ot', longName: 'Other Node' },
+          snr: -2.5,
+          hopsAway: 1,
+          viaMqtt: true,
+        }),
+      );
+
+      await waitFor(async () => (await svc.nodes()).length === 2);
+      const nodes = await svc.nodes();
+      expect(nodes.find((n) => n.num === 42)).toEqual({
+        num: 42,
+        longName: 'Other Node',
+        lastHeard: null,
+        snr: -2.5,
+        hopsAway: 1,
+        viaMqtt: true,
+      });
+      // absent in the proto → omitted from the summary
+      expect(nodes.find((n) => n.num === KAMIL_NUM)).not.toHaveProperty('snr');
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+});
@@ -11,12 +11,14 @@ import {
  BROADCAST_ADDR,
  PORT_POSITION_APP,
  PORT_ROUTING_APP,
+  PORT_TELEMETRY_APP,
  PORT_TEXT_MESSAGE_APP,
  buildTextToRadio,
  buildWantConfigToRadio,
  decodeFromRadio,
  decodePosition,
  decodeRouting,
+  decodeTelemetry,
  describeRoutingError,
  extractFrames,
  frame,
@@ -41,6 +43,18 @@ export interface MessageRecord {
  ackError?: string;
 }

+/** One entry in the telemetry history: a TELEMETRY_APP packet from some node. */
+export interface TelemetryRecord {
+  /** sender node num */
+  from: number;
+  /** epoch ms */
+  at: number;
+  /** meshtastic.Telemetry oneof case name (e.g. "deviceMetrics", "environmentMetrics") */
+  kind: string;
+  /** the variant payload, JSON-safe (proto uint64 fields as decimal strings); unset optional fields omitted */
+  data: object;
+}
+
 // bounded history: keep the newest N records, in-memory only
 const HISTORY_LIMIT = 100;

@@ -59,6 +73,50 @@ export interface NodeSummary {
  /** epoch seconds of the last heard packet; null when never heard */
  lastHeard: number | null;
  position?: { lat: number; lon: number; alt?: number };
+  /** signal-to-noise ratio of the last received packet, dB (NodeInfo.snr) */
+  snr?: number;
+  /** hops from this node to the one that reported it (optional in proto) */
+  hopsAway?: number;
+  /** true when the node info arrived via MQTT rather than LoRa */
+  viaMqtt?: boolean;
+}
+
+/** Shape of deviceInfo() output: sync-captured device data, key material redacted. */
+export interface DeviceInfo {
+  myNodeNum: number | null;
+  firmwareVersion?: string;
+  metadata?: Proto.Mesh.DeviceMetadata;
+  localConfig: Record<string, Record<string, unknown>>;
+  moduleConfig: Record<string, Record<string, unknown>>;
+}
+
+// protobuf-es decodes proto uint64 fields as native bigint, which JSON.stringify rejects;
+// recursively convert so deviceInfo()/telemetry() output is always JSON-safe (bigint -> decimal string).
+// $-prefixed keys are protobuf-es internals ($typeName/$unknown), not device data — dropped.
+function jsonSafe<T>(value: T): T {
+  if (typeof value === 'bigint') return String(value) as T;
+  if (Array.isArray(value)) return value.map(jsonSafe) as T;
+  if (value !== null && typeof value === 'object') {
+    const out: Record<string, unknown> = {};
+    for (const [k, v] of Object.entries(value))
+      if (!k.startsWith('$')) out[k] = jsonSafe(v);
+    return out as T;
+  }
+  return value; // primitives + undefined pass through
+}
+
+// key material must never leave the process — replaced with a marker so callers can see the field exists
+const REDACTED = 'REDACTED';
+/** Config sections that carry secrets: security (PKI keys) and network (wifi psk). */
+function redactSection(
+  name: string,
+  value: Record<string, unknown>,
+): Record<string, unknown> {
+  if (name !== 'security' && name !== 'network') return value;
+  const out = { ...value };
+  for (const key of ['publicKey', 'privateKey', 'adminKey', 'wifiPsk'])
+    if (out[key] !== undefined) out[key] = REDACTED;
+  return out;
 }

@Injectable()
@@ -88,9 +146,15 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
  >();
  // node database: NodeInfo frames from the initial sync + live POSITION_APP updates
  private nodeMap = new Map<number, NodeEntry>();
+  // device metadata + per-section config/module-config streamed during the initial sync
+  private metadata: Proto.Mesh.DeviceMetadata | null = null;
+  private configSections = new Map<string, Record<string, unknown>>();
+  private moduleConfigSections = new Map<string, Record<string, unknown>>();
  // message history (newest kept, capped at HISTORY_LIMIT) + pending tx records awaiting their routing ACK/NACK
  private history: MessageRecord[] = [];
  private pendingTx = new Map<number, MessageRecord>();
+  // telemetry history (newest kept, capped at HISTORY_LIMIT)
+  private telemetryHistory: TelemetryRecord[] = [];
  private reconnectTimer: NodeJS.Timeout | null = null;
  private shuttingDown = false;

@@ -132,9 +196,34 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
      }));
  }

+  /**
+   * Device info captured during the initial sync: this device's node number, firmware version and
+   * metadata (DeviceMetadata as-is — it carries no key material), plus per-section config and
+   * module-config messages keyed by section name. In-memory only; empty until the sync completes,
+   * reset on every bridge reconnect. Key material is redacted: security publicKey/privateKey/adminKey
+   * and network wifiPsk are replaced with "REDACTED" — never exposed over HTTP. Proto uint64 fields
+   * (e.g. power.powermonEnables) come back as decimal strings so the output always JSON-serializes.
+   */
+  deviceInfo(): DeviceInfo {
+    const out: DeviceInfo = {
+      myNodeNum: this.myNodeNum,
+      localConfig: {},
+      moduleConfig: {},
+    };
+    if (this.metadata) {
+      out.firmwareVersion = this.metadata.firmwareVersion;
+      out.metadata = jsonSafe(this.metadata);
+    }
+    for (const [name, value] of this.configSections)
+      out.localConfig[name] = jsonSafe(redactSection(name, value));
+    for (const [name, value] of this.moduleConfigSections)
+      out.moduleConfig[name] = jsonSafe(value);
+    return out;
+  }
+
  /**
   * Lean summaries of all known nodes, sorted by node number.
-   * Names/hwModel/batteryLevel appear only when the device reported them;
+   * Names/hwModel/batteryLevel/snr/hopsAway/viaMqtt appear only when the device reported them;
   * `lastHeard` is epoch seconds (null = never heard); `position` only when both coordinates are known.
   */
  async nodes(): Promise<NodeSummary[]> {
@@ -214,6 +303,16 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
    return [...this.history].reverse();
  }

+  /**
+   * Telemetry records, newest first: TELEMETRY_APP packets from any node — device metrics
+   * (battery/voltage/uptime/channel+air utilization) and environment sensor readings where nodes have them.
+   * `kind` is the meshtastic.Telemetry oneof case name; `data` is that variant's payload with proto uint64
+   * fields as decimal strings, unset optional fields omitted. In-memory only, last 100, reset on reconnect.
+   */
+  telemetry(): TelemetryRecord[] {
+    return [...this.telemetryHistory].reverse();
+  }
+
  /** Send `text` to node `to` on the pinned test channel; returns the packet id. Throws ServiceUnavailable when the bridge is down. */
  async sendText(to: number, text: string): Promise<number> {
    if (!this.connected || !this.socket)
@@ -240,6 +339,13 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
    if (this.history.length > HISTORY_LIMIT) this.history.shift();
  }

+  private pushTelemetry(rec: TelemetryRecord): void {
+    this.telemetryHistory.push(rec);
+    // ponytail: shift on a ≤100 array is fine; true ring buffer only if this ever gets hot
+    if (this.telemetryHistory.length > HISTORY_LIMIT)
+      this.telemetryHistory.shift();
+  }
+
  private summarize(n: NodeEntry, names: Map<number, string>): NodeSummary {
    const s: NodeSummary = { num: n.num, lastHeard: n.lastHeard || null };
    if (n.user?.longName) s.longName = n.user.longName;
@@ -247,9 +353,13 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
    // omit UNSET (enum value 0) rather than report "UNSET"
    const hwName = n.user?.hwModel ? names.get(n.user.hwModel) : undefined;
    if (hwName && hwName !== 'UNSET') s.hwModel = hwName;
-    // optional proto field: undefined when the device never reported metrics
+    // optional proto fields: undefined when the device never reported them
    const battery = n.deviceMetrics?.batteryLevel;
    if (battery !== undefined) s.batteryLevel = battery;
+    // non-optional proto scalars decode with their defaults (snr=0, viaMqtt=false), so a default value means "not reported"
+    if (n.snr !== undefined && n.snr !== 0) s.snr = n.snr;
+    if (n.hopsAway !== undefined) s.hopsAway = n.hopsAway; // optional in proto → truly absent when not reported
+    if (n.viaMqtt === true) s.viaMqtt = true;
    const p = n.position;
    if (p?.latitudeI !== undefined && p.longitudeI !== undefined) {
      // alt included only when the device sent it — protobuf-es leaves absent optionals undefined, so an explicit 0 (sea level) is kept
@@ -265,10 +375,14 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
    this.socket = socket;
    socket.on('connect', () => {
      this.connected = true;
-      // fresh sync on every (re)connect — drop stale channels/nodes/history from the old session
+      // fresh sync on every (re)connect — drop stale channels/nodes/device info/history from the old session
      this.channelMap = new Map();
      this.nodeMap = new Map();
+      this.metadata = null;
+      this.configSections.clear();
+      this.moduleConfigSections.clear();
      this.history = [];
+      this.telemetryHistory = [];
      this.pendingTx.clear();
      this.logger.log(`bridge connected ${this.host}:${this.port}`);
      const nonce = Math.floor(Math.random() * 0xffffffff) || 1;
@@ -328,6 +442,21 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
        // device streams the whole node DB during initial sync
        this.nodeMap.set(v.value.num, v.value);
        break;
+      case 'metadata':
+        // DeviceMetadata streamed once during initial sync (no key material in it)
+        this.metadata = v.value;
+        break;
+      case 'config': {
+        // device streams one Config per section during initial sync
+        const sec = v.value.payloadVariant;
+        if (sec?.case) this.configSections.set(sec.case, sec.value);
+        break;
+      }
+      case 'moduleConfig': {
+        const mod = v.value.payloadVariant;
+        if (mod?.case) this.moduleConfigSections.set(mod.case, mod.value);
+        break;
+      }
      case 'configCompleteId':
        this.logger.log(
          `bridge ready (config complete), ${this.channelMap.size} channels, ${this.nodeMap.size} nodes`,
@@ -388,6 +517,23 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
              this.pendingTx.delete(decoded.requestId);
            }
          }
+        } else if (decoded && decoded.portnum === PORT_TELEMETRY_APP) {
+          // live telemetry: the Telemetry is serialized in Data.payload
+          let tel: Proto.Telemetry.Telemetry | undefined;
+          try {
+            tel = await decodeTelemetry(decoded.payload);
+          } catch {
+            tel = undefined; // malformed payload — skip
+          }
+          const variant = tel?.variant;
+          if (variant?.case) {
+            this.pushTelemetry({
+              from: pkt.from,
+              at: Date.now(),
+              kind: variant.case,
+              data: jsonSafe(variant.value),
+            });
+          }
        }
        break;
      }
Author	SHA1	Message	Date
kamilkrzywda	0571c7095e	Telemetry stream: GET /api/telemetry + MCP get_telemetry (#16 ) CI / build + unit (push) Successful in 21s Details	2026-09-24 23:56:11 +02:00
kamilkrzywda	ba5e60daf0	Fix BigInt serialization in GET /api/device (500 on real hardware) (#14 ) CI / build + unit (push) Successful in 18s Details	2026-09-24 23:14:32 +02:00
kamilkrzywda	4beaa377c4	Device info endpoint + richer node summaries (GET /api/device, MCP device_info) (#13 ) CI / build + unit (push) Successful in 36s Details	2026-09-24 22:46:40 +02:00