MCP server at POST /mcp (official SDK, stateless Streamable HTTP) (#11 )

Publish on 'test' channel (index 3) by default (#10 )
Send to by node name or broadcast sentinel (GET-free resolution via node DB) (#9 )
2026-09-24 20:39:45 +02:00 · 2026-09-24 19:44:11 +02:00 · 2026-09-24 16:47:51 +02:00 · 2026-09-24 16:19:32 +02:00 · 2026-09-24 15:37:03 +02:00
14 changed files with 1588 additions and 71 deletions
@@ -17,7 +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 | "!b" | "broadcast"> }`, returns `{ id }`), and `GET /api/channels` (the device's Meshtastic channels as `{ index, name, uplinkEnabled, downlinkEnabled }[]`; psk/keys redacted). 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 2 (`testowy`) on purpose — never the primary channel; override via `MESH_SEND_CHANNEL` (default `2`).
+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.).

 ## Other

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

+## 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.
+- New dependency: `@modelcontextprotocol/sdk` (^1.30.1; zod comes with it). Note: the SDK's root entry is broken in all published 1.x tarballs (upstream issue #2273 — the exports map points to a dist index that was never shipped), so imports use the documented subpaths (`@modelcontextprotocol/sdk/server/mcp.js`, `.../server/streamableHttp.js`, `.../inMemory.js`, `.../client/index.js`).
+- Test helpers shared by both specs extracted from `mesh.service.spec.ts` into `src/mesh/fake-bridge.ts` (fake bridge, waitFor, nodeInfoFrame, KAMIL fixtures); new `mcp.controller.spec.ts` drives the MCP server over an in-memory transport pair — all six tools listed with descriptions/schemas, and mesh_status / send_message (broadcast + name resolution + error messages) / get_node / list_channels / list_nodes / get_messages return correct shapes.
+- README gains an MCP section; AGENTS.md endpoint list updated for `/mcp`.
+
+## v0.5.0 — 2026-09-24 17:37
+
+- Publishing channel moved from `testowy` (index 2) to the new `test` channel (index 3); `MESH_SEND_CHANNEL` default is now `3`. All docs/comments referencing the old pinning updated accordingly.
+
+## v0.4.0 — 2026-09-24 14:39
+
+- `POST /api/send` now accepts node names and explicit broadcast sentinels in `to`: omitted/"" or `"!b"`/`"broadcast"` (case-insensitive, trimmed) → broadcast address `0xffffffff`; numbers pass through as-is (must be an integer in 1..0xffffffff); numeric strings are parsed the same way; anything else is looked up by name via the existing node DB lookup (exact long/short name, then unique substring). Unknown or ambiguous targets are a 400 with `no node matching '<to>'`. New service method `MeshService.resolveDest(to?)` does the resolution — `sendText()` keeps its resolved-number signature.
+- Swagger: `SendTextDto.to` documented as `number | string` with the full resolution order and the DM-vs-broadcast caveat (DMs are unicast wantAck-tracked via `GET /api/messages`; broadcasts stay pending because firmware strips want_ack); `@ApiOperation` notes all sends still ride channel index 2 (`testowy`) regardless of DM or broadcast.
+- README + AGENTS.md endpoint lists updated for the new `to` semantics.
+- Unit tests: `resolveDest` coverage on the fake bridge — omitted/""/"!b"/"BROADCAST" → broadcast, number passthrough, numeric string, exact longName match → num (node DB seeded via framed FromRadio nodeInfo), unknown name → `no node matching`, and invalid numbers (0, negative, non-integer, > 0xffffffff) rejected.
+
+## v0.3.0 — 2026-09-24 14:08
+
+- Message history with delivery tracking, exposed as `GET /api/messages` (newest first): inbound TEXT_MESSAGE_APP packets (`dir:'rx'`, with `from`) and our sends (`dir:'tx'`, with `to` + `status`). tx records start `pending` and move to `delivered`/`failed` when the routing ACK/NACK arrives — ROUTING_APP packets carry a serialized `meshtastic.Routing` in `Data.payload` whose oneof variant is `errorReason` (`Routing_Error`: 0 NONE = delivered, anything else failed with a human-readable `ackError`, e.g. NO_ROUTE/GOT_NAK/TIMEOUT, fallback `reason <n>`), matched to our sends via `Data.requestId`. Broadcasts stay `pending` because firmware strips want_ack pre-TX (documented behavior, no timer). History is a bounded in-memory buffer of the last 100 records (newest kept) and resets on every bridge reconnect alongside channels/nodes.
+- Codec: new `PORT_ROUTING_APP = 5` constant (verified against the installed `@meshtastic/protobufs` PortNum enum), `decodeRouting()` for ROUTING_APP payloads, and `describeRoutingError()` which maps a Routing.Error code to its name from the installed package's `Mesh.Routing_Error` enum.
+- Swagger: `GET /api/messages` documented with the pending→delivered/failed lifecycle, the broadcast caveat, and an example matching the record shape; README + AGENTS.md endpoint lists updated.
+
+## v0.2.0 — 2026-09-24 13:08
+
+- Node database collected during the initial sync (`FromRadio.nodeInfo` frames, upserted by node number) and kept fresh by live `POSITION_APP` packets (the Position is serialized in `Data.payload`; unknown senders get a stub entry). The map resets on every bridge reconnect alongside channels.
+- New endpoints: `GET /api/nodes` — lean summaries sorted by node number as `{ num, longName?, shortName?, hwModel?, batteryLevel?, lastHeard (epoch secs | null), position? { lat, lon, alt? } }[]`; names/hwModel/battery appear only when the device reported them, `hwModel` is the enum's string name (UNSET omitted), and `position` only when both coordinates are known. `GET /api/nodes/:id` — lookup by exact node number (numbers/numeric strings), then case-insensitive exact long/short name, else unique case-insensitive substring; 404 with a clear message when nothing or more than one node matches.
+- Codec: new `PORT_POSITION_APP = 3` constant (verified against the installed `@meshtastic/protobufs` PortNum enum), `decodePosition()` for POSITION_APP payloads, and `loadHwModelNames()` reverse lookup of the HardwareModel enum.
+- Swagger docs made genuinely useful: `Mesh` tag on the controller (description via `DocumentBuilder.addTag` — v12's `ApiTagOptions` has no description field) plus `@ApiOperation` summary/description and `@ApiResponse` examples on all endpoints, existing and new.
+- Unit tests build real framed FromRadio bytes for nodeInfo/POSITION_APP: sync collection + summary shape (lat/lon = value × 1e-7, battery), stub entry from an unknown POSITION_APP sender, lookup ladder (exact num / numeric string / exact name / unique substring) with ambiguous and missing → null, and reconnect reset.
+
 ## v0.1.4 — 2026-09-23 20:33

 - Send a `ToRadio` with `want_config_id` (random non-zero uint32 nonce) on every bridge connect, so the firmware streams its initial sync data (`myInfo`, channels, `config_complete_id`) — previously nothing was written on connect, which is why `/api/channels` stayed empty and `myNodeNum` stayed null in production. New codec helper `buildWantConfigToRadio`; unit test captures the outbound frame on the fake bridge, asserts the `wantConfigId` oneof case with a non-zero value, then feeds back `myInfo` + `configCompleteId` frames and checks service state.
@@ -26,8 +26,11 @@ Exposed via Traefik only (no published ports) at `http://bot.dev.kkhost.pl`.
 All API endpoints live under the `/api` prefix:

 - `GET /api/status` — `{ connected, myNodeNum, host, port }`
- `POST /api/send` — body `{ "text": "...", "to"?: <node number | "!b" | "broadcast"> }`, returns `{ id }`
+- `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/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/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
 `/docs-json`.
@@ -37,19 +40,52 @@ 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/messages
+curl http://localhost:3000/api/nodes
+curl http://localhost:3000/api/nodes/kamil
 ```

-`to` omitted, `"!b"`, or `"broadcast"` sends to the broadcast address `0xffffffff`.
+`to` omitted, `"!b"`, or `"broadcast"` (case-insensitive) sends to the
+broadcast address `0xffffffff`; anything else is a node number or name.
+DMs are unicast and wantAck-tracked via `GET /api/messages`; broadcasts stay
+pending because firmware strips want_ack before TX.

-All sends always target channel index 2 (`testowy`) — never the primary
+All sends always target channel index 3 (`test`) — never the primary
 channel. Override with `MESH_SEND_CHANNEL`.

+## MCP server
+
+The bot also exposes an MCP (Model Context Protocol) endpoint at
+`POST /mcp` (outside the `/api` prefix), served in-process over the SDK's
+Streamable HTTP transport in stateless mode. It maps 1:1 to the REST
+endpoints — no new logic, same channel pinning:
+
+- `mesh_status` — bridge connection state (`{ connected, myNodeNum, host, port }`)
+- `send_message(text, to?)` — send a text message; `to` resolves like `POST /api/send` (omitted/""/"!b"/"broadcast" → broadcast, number or numeric string → node number, else name lookup); returns `{ id }`; unknown/ambiguous targets are tool errors
+- `list_channels` — device channels (keys redacted)
+- `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)
+
+Point any MCP client at it (Streamable HTTP URL):
+
+```json
+{ "mcpServers": { "mesh-bot": { "url": "http://bot.dev.kkhost.pl/mcp" } } }
+```
+
+```sh
+curl -X POST http://localhost:3000/mcp \
+  -H 'content-type: application/json' \
+  -H 'accept: application/json, text/event-stream' \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
+```
+
 ## Env vars

 - `MESH_HOST` (default `192.168.1.4`) — bridge host
 - `MESH_PORT` (default `4403`) — bridge port
 - `MESH_RECONNECT_MS` (default `5000`) — reconnect interval in ms
- `MESH_SEND_CHANNEL` (default `2`) — channel index all sends target (`testowy`; never the primary channel)
+- `MESH_SEND_CHANNEL` (default `3`) — channel index all sends target (`test`; never the primary channel)
 - `PORT` (default `3000`) — HTTP listen port

 Note: the serial bridge accepts only ONE client at a time — if another app is
@@ -1,16 +1,17 @@
 {
  "name": "mesh-bot",
-  "version": "0.0.1",
+  "version": "0.5.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "mesh-bot",
-      "version": "0.0.1",
+      "version": "0.5.0",
      "license": "UNLICENSED",
      "dependencies": {
        "@bufbuild/protobuf": "^2.15.0",
        "@meshtastic/protobufs": "^2.8.0",
+        "@modelcontextprotocol/sdk": "^1.30.1",
        "@nestjs/common": "^12.0.1",
        "@nestjs/core": "^12.0.1",
        "@nestjs/platform-express": "^12.0.1",
@@ -221,6 +222,18 @@
        "node": ">=0.1.90"
      }
    },
+    "node_modules/@hono/node-server": {
+      "version": "2.1.1",
+      "resolved": "https://registry.npmjs.org/@hono/node-server/-/node-server-2.1.1.tgz",
+      "integrity": "sha512-ELuehkj5VCBdgEw9zs+ivkKwyzzUCSQuE96YmiPvn1ECBoZCczbFXJLeEGMTYjphP6gydh4pHMqEYPVMYUVgQg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=20"
+      },
+      "peerDependencies": {
+        "hono": "^4"
+      }
+    },
    "node_modules/@inquirer/ansi": {
      "version": "2.0.8",
      "resolved": "https://registry.npmjs.org/@inquirer/ansi/-/ansi-2.0.8.tgz",
@@ -617,6 +630,46 @@
      "integrity": "sha512-p68VexhnH7ojf3U27RdryUDqnKJgKaWUbCL96vJR7N0mqDuhKG5OIECk3sCPPdynxjk+yoVhRkScqtv5KQjzsw==",
      "license": "MIT"
    },
+    "node_modules/@modelcontextprotocol/sdk": {
+      "version": "1.30.1",
+      "resolved": "https://registry.npmjs.org/@modelcontextprotocol/sdk/-/sdk-1.30.1.tgz",
+      "integrity": "sha512-H2HxLvC3HDNybePJaLdSrU1hhUK5iQw+WvV1b01myFyI7sdVGe1u/IPTE5D9fGCiJDVtgMV/lmFkQXLmQyIFYA==",
+      "license": "MIT",
+      "dependencies": {
+        "@hono/node-server": "^1.19.9 || ^2.0.5",
+        "ajv": "^8.17.1",
+        "ajv-formats": "^3.0.1",
+        "content-type": "^1.0.5",
+        "cors": "^2.8.5",
+        "cross-spawn": "^7.0.5",
+        "eventsource": "^3.0.2",
+        "eventsource-parser": "^3.0.0",
+        "express": "^5.2.1",
+        "express-rate-limit": "^8.2.1",
+        "hono": "^4.11.4",
+        "jose": "^6.1.3",
+        "json-schema-typed": "^8.0.2",
+        "pkce-challenge": "^5.0.0",
+        "raw-body": "^3.0.0",
+        "zod": "^3.25 || ^4.0",
+        "zod-to-json-schema": "^3.25.1"
+      },
+      "engines": {
+        "node": ">=18"
+      },
+      "peerDependencies": {
+        "@cfworker/json-schema": "^4.1.1",
+        "zod": "^3.25 || ^4.0"
+      },
+      "peerDependenciesMeta": {
+        "@cfworker/json-schema": {
+          "optional": true
+        },
+        "zod": {
+          "optional": false
+        }
+      }
+    },
    "node_modules/@nestjs/cli": {
      "version": "12.0.5",
      "resolved": "https://registry.npmjs.org/@nestjs/cli/-/cli-12.0.5.tgz",
@@ -2179,7 +2232,6 @@
      "version": "8.20.0",
      "resolved": "https://registry.npmjs.org/ajv/-/ajv-8.20.0.tgz",
      "integrity": "sha512-Thbli+OlOj+iMPYFBVBfJ3OmCAnaSyNn4M1vz9T6Gka5Jt9ba/HIR56joy65tY6kx/FCF5VXNB819Y7/GUrBGA==",
-      "dev": true,
      "license": "MIT",
      "dependencies": {
        "fast-deep-equal": "^3.1.3",
@@ -2196,7 +2248,6 @@
      "version": "3.0.1",
      "resolved": "https://registry.npmjs.org/ajv-formats/-/ajv-formats-3.0.1.tgz",
      "integrity": "sha512-8iUql50EUR+uUcdRQ3HDqa6EVyo3docL8g5WJ3FNcWmu62IbkGUue/pEyLBW8VGKKucTPgqeks4fIU1DA4yowQ==",
-      "dev": true,
      "license": "MIT",
      "dependencies": {
        "ajv": "^8.0.0"
@@ -2764,6 +2815,20 @@
        "url": "https://opencollective.com/express"
      }
    },
+    "node_modules/cross-spawn": {
+      "version": "7.0.6",
+      "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
+      "integrity": "sha512-uV2QOWP2nWzsy2aMp8aRibhi9dlzF5Hgh5SHaB9OiTGEyDTiJJyx0uy51QXdyWbtAHNua4XJzUKca3OzKUd3vA==",
+      "license": "MIT",
+      "dependencies": {
+        "path-key": "^3.1.0",
+        "shebang-command": "^2.0.0",
+        "which": "^2.0.1"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
    "node_modules/debug": {
      "version": "4.4.3",
      "resolved": "https://registry.npmjs.org/debug/-/debug-4.4.3.tgz",
@@ -2991,6 +3056,27 @@
        "node": ">= 0.6"
      }
    },
+    "node_modules/eventsource": {
+      "version": "3.0.7",
+      "resolved": "https://registry.npmjs.org/eventsource/-/eventsource-3.0.7.tgz",
+      "integrity": "sha512-CRT1WTyuQoD771GW56XEZFQ/ZoSfWid1alKGDYMmkt2yl8UXrVR4pspqWNEcqKvVIzg6PAltWjxcSSPrboA4iA==",
+      "license": "MIT",
+      "dependencies": {
+        "eventsource-parser": "^3.0.1"
+      },
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
+    "node_modules/eventsource-parser": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/eventsource-parser/-/eventsource-parser-3.1.1.tgz",
+      "integrity": "sha512-EKN1vKAMcZ8MlYMpaNuxN6R9yakzH6uajHcHVTqWJzvu5pWw9DyhbP35HH8MVBQ+dZjAfDxk+A8NiR9KWaXiyQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=18.0.0"
+      }
+    },
    "node_modules/expect-type": {
      "version": "1.4.0",
      "resolved": "https://registry.npmjs.org/expect-type/-/expect-type-1.4.0.tgz",
@@ -3044,6 +3130,25 @@
        "url": "https://opencollective.com/express"
      }
    },
+    "node_modules/express-rate-limit": {
+      "version": "8.7.0",
+      "resolved": "https://registry.npmjs.org/express-rate-limit/-/express-rate-limit-8.7.0.tgz",
+      "integrity": "sha512-hOwV7WOxXfjRpAM1DSJWZDXx3GhplwD8IfwuwvogD8i1Qnkgosw/H45s4ZnFAUHDAhPjlY9hLBvJhKmGMyY26g==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "^4.4.3",
+        "ip-address": "^10.2.0"
+      },
+      "engines": {
+        "node": ">= 16"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/express-rate-limit"
+      },
+      "peerDependencies": {
+        "express": ">= 4.11"
+      }
+    },
    "node_modules/external-editor": {
      "version": "3.1.0",
      "resolved": "https://registry.npmjs.org/external-editor/-/external-editor-3.1.0.tgz",
@@ -3083,7 +3188,6 @@
      "version": "3.1.3",
      "resolved": "https://registry.npmjs.org/fast-deep-equal/-/fast-deep-equal-3.1.3.tgz",
      "integrity": "sha512-f3qQ9oQy9j2AhBe/H9VC91wLmKBCCU/gDOnKNAYG5hswO7BLKj09Hc5HYNz9cGI++xlpDCIgDaitVs03ATR84Q==",
-      "dev": true,
      "license": "MIT"
    },
    "node_modules/fast-safe-stringify": {
@@ -3113,7 +3217,6 @@
      "version": "3.1.8",
      "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.8.tgz",
      "integrity": "sha512-GZMtZUTNRpOVIECoXwLNZS5xUGE+mVNbTB8h/7Rwh2TFWcBQiPzTgyZi05BF9UMZKkLJv8XBRJTlU7zg8+ZfMg==",
-      "dev": true,
      "funding": [
        {
          "type": "github",
@@ -3428,6 +3531,15 @@
        "node": ">= 0.4"
      }
    },
+    "node_modules/hono": {
+      "version": "4.13.9",
+      "resolved": "https://registry.npmjs.org/hono/-/hono-4.13.9.tgz",
+      "integrity": "sha512-7dMkQmZoC4E6F7AtaQSPhlWAdnBti+j7rreMZl8QB4jFiEhP9TWbGWUMi8WYzBCgmgulxuvLQupKqo+Co6Omyg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.9.0"
+      }
+    },
    "node_modules/html-escaper": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/html-escaper/-/html-escaper-2.0.2.tgz",
@@ -3618,6 +3730,15 @@
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
+    "node_modules/ip-address": {
+      "version": "10.7.2",
+      "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.7.2.tgz",
+      "integrity": "sha512-7H/2gFSIitxc0hG3nOI1glS8QLo/EHBFFLk8vEUjXY/xu0AdL8jZ9U1IzO2PUm0d2D/ofQcAifb0g6OBkt8U7w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 12"
+      }
+    },
    "node_modules/ipaddr.js": {
      "version": "1.9.1",
      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
@@ -3669,6 +3790,12 @@
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
+    "node_modules/isexe": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
+      "integrity": "sha512-RHxMLp9lnKHGHRng9QFhRCMbYAcVpn69smSGcq3f36xjgVVWThj4qqLbTLlq7Ssj8B+fIQ1EuCEGI2lKsyQeIw==",
+      "license": "ISC"
+    },
    "node_modules/istanbul-lib-coverage": {
      "version": "3.2.2",
      "resolved": "https://registry.npmjs.org/istanbul-lib-coverage/-/istanbul-lib-coverage-3.2.2.tgz",
@@ -3717,6 +3844,15 @@
        "node": ">=6"
      }
    },
+    "node_modules/jose": {
+      "version": "6.2.12",
+      "resolved": "https://registry.npmjs.org/jose/-/jose-6.2.12.tgz",
+      "integrity": "sha512-9NiFmJEex0sy2Dk58j2UGBSHgUs2ypF9eZSu4L6vjOX3Dp96Sw1F3uL+H+D1sx02jZZdzUT0HgvCy59CuvXcWw==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/panva"
+      }
+    },
    "node_modules/js-tokens": {
      "version": "10.0.0",
      "resolved": "https://registry.npmjs.org/js-tokens/-/js-tokens-10.0.0.tgz",
@@ -3750,9 +3886,14 @@
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/json-schema-traverse/-/json-schema-traverse-1.0.0.tgz",
      "integrity": "sha512-NM8/P9n3XjXhIZn1lLhkFaACTOURQXjWhV4BA/RnOv8xvgqtqpAX9IO4mRQxSx1Rlo4tqzeqb0sOlruaOy3dug==",
-      "dev": true,
      "license": "MIT"
    },
+    "node_modules/json-schema-typed": {
+      "version": "8.0.2",
+      "resolved": "https://registry.npmjs.org/json-schema-typed/-/json-schema-typed-8.0.2.tgz",
+      "integrity": "sha512-fQhoXdcvc3V28x7C7BMs4P5+kNlgUURe2jmUT1T//oBRMDrqy1QPelJimwZGo7Hg9VPV3EQV5Bnq4hbFy2vetA==",
+      "license": "BSD-2-Clause"
+    },
    "node_modules/json5": {
      "version": "2.2.3",
      "resolved": "https://registry.npmjs.org/json5/-/json5-2.2.3.tgz",
@@ -4658,6 +4799,15 @@
        "node": ">= 0.8"
      }
    },
+    "node_modules/path-key": {
+      "version": "3.1.1",
+      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
+      "integrity": "sha512-ojmeN0qd+y0jszEtoY48r0Peq5dwMEkIlCOu6Q5f41lfkswXuKtYrhgoTpLnyIcHm24Uhqx+5Tqm2InSwLhE6Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
    "node_modules/path-to-regexp": {
      "version": "8.4.2",
      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-8.4.2.tgz",
@@ -4695,6 +4845,15 @@
        "url": "https://github.com/sponsors/jonschlinkert"
      }
    },
+    "node_modules/pkce-challenge": {
+      "version": "5.0.1",
+      "resolved": "https://registry.npmjs.org/pkce-challenge/-/pkce-challenge-5.0.1.tgz",
+      "integrity": "sha512-wQ0b/W4Fr01qtpHlqSqspcj3EhBvimsdh0KlHhH8HRZnMsEa0ea2fTULOXOS9ccQr3om+GcGRk4e+isrZWV8qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=16.20.0"
+      }
+    },
    "node_modules/pluralize": {
      "version": "8.0.0",
      "resolved": "https://registry.npmjs.org/pluralize/-/pluralize-8.0.0.tgz",
@@ -4850,7 +5009,6 @@
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/require-from-string/-/require-from-string-2.0.2.tgz",
      "integrity": "sha512-Xf0nWe6RseziFMu+Ap9biiUbmplq6S9/p+7w7YXP/JBHhrUDDUhwa+vANyubuqfZWTveU//DYVGsDG7RKL/vEw==",
-      "dev": true,
      "license": "MIT",
      "engines": {
        "node": ">=0.10.0"
@@ -5037,6 +5195,27 @@
      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
      "license": "ISC"
    },
+    "node_modules/shebang-command": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-command/-/shebang-command-2.0.0.tgz",
+      "integrity": "sha512-kHxr2zZpYtdmrN1qDjrrX/Z1rR1kG8Dx+gkpK1G4eXmvXswmcE1hTWBWYUzlraYw1/yZp6YuDY77YtvbN0dmDA==",
+      "license": "MIT",
+      "dependencies": {
+        "shebang-regex": "^3.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
+    "node_modules/shebang-regex": {
+      "version": "3.0.0",
+      "resolved": "https://registry.npmjs.org/shebang-regex/-/shebang-regex-3.0.0.tgz",
+      "integrity": "sha512-7++dFhtcx3353uBaq8DDR4NuxBetBzC7ZQOhmTQInHEd6bSrXdiEyzCvG07Z44UYdLShWUyXt5M/yhz8ekcb1A==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
+      }
+    },
    "node_modules/side-channel": {
      "version": "1.1.1",
      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.1.tgz",
@@ -5866,6 +6045,21 @@
        "defaults": "^1.0.3"
      }
    },
+    "node_modules/which": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/which/-/which-2.0.2.tgz",
+      "integrity": "sha512-BLI3Tl1TW3Pvl70l3yq3Y64i+awpwXqsGBYWkkqMtnbXgrMD+yj7rhW0kuEDxzJaYXGjEW5ogapKNMEKNMjibA==",
+      "license": "ISC",
+      "dependencies": {
+        "isexe": "^2.0.0"
+      },
+      "bin": {
+        "node-which": "bin/node-which"
+      },
+      "engines": {
+        "node": ">= 8"
+      }
+    },
    "node_modules/why-is-node-running": {
      "version": "2.3.0",
      "resolved": "https://registry.npmjs.org/why-is-node-running/-/why-is-node-running-2.3.0.tgz",
@@ -5925,6 +6119,15 @@
      "funding": {
        "url": "https://github.com/sponsors/colinhacks"
      }
+    },
+    "node_modules/zod-to-json-schema": {
+      "version": "3.25.2",
+      "resolved": "https://registry.npmjs.org/zod-to-json-schema/-/zod-to-json-schema-3.25.2.tgz",
+      "integrity": "sha512-O/PgfnpT1xKSDeQYSCfRI5Gy3hPf91mKVDuYLUHZJMiDFptvP41MSnWofm8dnCm0256ZNfZIM7DSzuSMAFnjHA==",
+      "license": "ISC",
+      "peerDependencies": {
+        "zod": "^3.25.28 || ^4"
+      }
    }
  }
 }
@@ -1,6 +1,6 @@
 {
  "name": "mesh-bot",
-  "version": "0.1.4",
+  "version": "0.6.0",
  "description": "",
  "author": "",
  "private": true,
@@ -23,6 +23,7 @@
  "dependencies": {
    "@bufbuild/protobuf": "^2.15.0",
    "@meshtastic/protobufs": "^2.8.0",
+    "@modelcontextprotocol/sdk": "^1.30.1",
    "@nestjs/common": "^12.0.1",
    "@nestjs/core": "^12.0.1",
    "@nestjs/platform-express": "^12.0.1",
@@ -9,14 +9,16 @@ import { AppModule } from './app.module.js';
 async function bootstrap() {
  const app = await NestFactory.create<NestExpressApplication>(AppModule);
  app.enableShutdownHooks();
-  app.setGlobalPrefix('api');
+  // 'mcp' is excluded so the MCP endpoint lives at /mcp, not /api/mcp (like Scalar at /)
+  app.setGlobalPrefix('api', { exclude: ['mcp'] });

  // Scalar API docs at / (OpenAPI JSON at /docs-json), outside the api prefix.
  const docConfig = new DocumentBuilder()
    .setTitle('MeshBot API')
    .setDescription(
-      'Meshtastic bridge bot: status, send text messages, list device channels.',
+      'Meshtastic bridge bot: status, send text messages, list device channels and known nodes.',
    )
+    .addTag('Mesh', 'Meshtastic bridge control and telemetry')
    .setVersion(pkg.version)
    .build();
  const document = SwaggerModule.createDocument(app, docConfig);
@@ -10,6 +10,10 @@ async function loadProto(): Promise<typeof import('@meshtastic/protobufs')> {
 export const BROADCAST_ADDR = 0xffffffff;
 // official portnums.proto: TEXT_MESSAGE_APP=1 (task spec draft said 3 — the enum value wins)
 export const PORT_TEXT_MESSAGE_APP = 1;
+// verified against installed @meshtastic/protobufs Portnums.PortNum.POSITION_APP
+export const PORT_POSITION_APP = 3;
+// verified against installed @meshtastic/protobufs Portnums.PortNum.ROUTING_APP
+export const PORT_ROUTING_APP = 5;

 const START1 = 0x94;
 const START2 = 0xc3;
@@ -61,6 +65,46 @@ export async function decodeFromRadio(
  return fromBinary(P.Mesh.FromRadioSchema, bytes);
 }

+/** POSITION_APP packets carry a serialized meshtastic.Position in Data.payload. */
+export async function decodePosition(
+  bytes: Uint8Array,
+): Promise<import('@meshtastic/protobufs').Mesh.Position> {
+  const P = await loadProto();
+  return fromBinary(P.Mesh.PositionSchema, bytes);
+}
+
+/** ROUTING_APP packets carry a serialized meshtastic.Routing in Data.payload (ACK/NACK for want_ack sends). */
+export async function decodeRouting(
+  bytes: Uint8Array,
+): Promise<import('@meshtastic/protobufs').Mesh.Routing> {
+  const P = await loadProto();
+  return fromBinary(P.Mesh.RoutingSchema, 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();
+  const hit = Object.entries(P.Mesh.Routing_Error).find(
+    ([, v]) => typeof v === 'number' && v === code,
+  );
+  return hit ? String(hit[0]) : `reason ${code}`;
+}
+
+let hwModelNames: Map<number, string> | null = null;
+/** Reverse lookup of meshtastic.HardwareModel (enum value -> name), loaded once. */
+export async function loadHwModelNames(): Promise<Map<number, string>> {
+  if (!hwModelNames) {
+    const P = await loadProto();
+    hwModelNames = new Map(
+      Object.entries(P.Mesh.HardwareModel).map(([k, v]) => [
+        Number(k),
+        String(v),
+      ]),
+    );
+  }
+  return hwModelNames;
+}
+
 export async function buildTextToRadio(
  to: number,
  text: string,
@@ -0,0 +1,80 @@
+import { create, toBinary } from '@bufbuild/protobuf';
+import * as P from '@meshtastic/protobufs';
+import * as net from 'node:net';
+import type { AddressInfo } from 'node:net';
+import { frame } from './codec.js';
+
+/** In-process TCP stand-in for the meshtastic-serial-bridge; hands out accepted sockets. */
+export function startBridge(
+  onSocket?: (s: net.Socket) => void,
+): Promise<{ port: number; sockets: net.Socket[]; close: () => void }> {
+  const sockets: net.Socket[] = [];
+  const server = net.createServer((socket) => {
+    onSocket?.(socket); // attached at accept time, before any data can arrive
+    sockets.push(socket);
+  });
+  return new Promise((resolve) => {
+    server.listen(0, '127.0.0.1', () => {
+      resolve({
+        port: (server.address() as AddressInfo).port,
+        sockets,
+        close: () => server.close(),
+      });
+    });
+  });
+}
+
+export async function waitFor(
+  cond: () => boolean | Promise<boolean>,
+  timeoutMs = 5000,
+): Promise<void> {
+  const t0 = Date.now();
+  while (!(await cond())) {
+    if (Date.now() - t0 > timeoutMs) throw new Error('timed out waiting');
+    await new Promise((r) => setTimeout(r, 10));
+  }
+}
+
+/** Plain-object NodeInfo fields (init shape, not the runtime message type) accepted by nodeInfoFrame. */
+export interface NodeInfoFields {
+  user?: {
+    id?: string;
+    longName?: string;
+    shortName?: string;
+    hwModel?: number;
+  };
+  position?: { latitudeI?: number; longitudeI?: number; altitude?: number };
+  lastHeard?: number;
+  deviceMetrics?: { batteryLevel?: number };
+}
+
+export function nodeInfoFrame(
+  num: number,
+  fields?: NodeInfoFields,
+): Uint8Array {
+  const ni = create(P.Mesh.NodeInfoSchema, { num, ...fields });
+  return frame(
+    toBinary(
+      P.Mesh.FromRadioSchema,
+      create(P.Mesh.FromRadioSchema, {
+        payloadVariant: { case: 'nodeInfo', value: ni },
+      }),
+    ),
+  );
+}
+
+export const KAMIL_NUM = 123456789;
+
+export function kamilNodeInfo(): NodeInfoFields {
+  return {
+    user: {
+      id: '!kamil',
+      longName: 'Kamil SP8MK/P',
+      shortName: 'KK',
+      hwModel: P.Mesh.HardwareModel.TBEAM,
+    },
+    position: { latitudeI: 521049637, longitudeI: 209833152, altitude: 123 },
+    lastHeard: 1758000000,
+    deviceMetrics: { batteryLevel: 87 },
+  };
+}
@@ -0,0 +1,263 @@
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { InMemoryTransport } from '@modelcontextprotocol/sdk/inMemory.js';
+import type * as net from 'node:net';
+import { describe, expect, it } from 'vitest';
+import { BROADCAST_ADDR } from './codec.js';
+import {
+  KAMIL_NUM,
+  kamilNodeInfo,
+  nodeInfoFrame,
+  startBridge,
+  waitFor,
+} from './fake-bridge.js';
+import { createMeshMcpServer } from './mcp.controller.js';
+import { MeshService } from './mesh.service.js';
+
+// callTool returns CallToolResult | a legacy compatibility shape; we only ever get the former
+type ToolOutcome = { content: { type: string; text?: string }[] };
+
+function toolText(r: Awaited<ReturnType<Client['callTool']>>): string {
+  const c = (r as ToolOutcome).content[0];
+  if (!c || c.type !== 'text') throw new Error('expected a text content block');
+  return c.text ?? '';
+}
+
+async function connectedService(): Promise<{
+  svc: MeshService;
+  sockets: net.Socket[];
+  close: () => void;
+}> {
+  const bridge = await startBridge();
+  process.env.MESH_HOST = '127.0.0.1';
+  process.env.MESH_PORT = String(bridge.port);
+  const svc = new MeshService();
+  svc.onModuleInit();
+  await waitFor(() => bridge.sockets.length === 1 && svc.status().connected);
+  return {
+    svc,
+    sockets: bridge.sockets,
+    close: () => {
+      svc.onModuleDestroy();
+      bridge.close();
+    },
+  };
+}
+
+// Drive the MCP server over an in-memory transport pair (no HTTP involved)
+async function connectMcp(svc: MeshService): Promise<{
+  client: Client;
+  close: () => Promise<void>;
+}> {
+  const [clientTransport, serverTransport] =
+    InMemoryTransport.createLinkedPair();
+  const server = createMeshMcpServer(svc);
+  await server.connect(serverTransport);
+  const client = new Client({ name: 'mesh-bot-test', version: '0.0.0' });
+  await client.connect(clientTransport);
+  return {
+    client,
+    close: async () => {
+      await client.close();
+      await server.close();
+    },
+  };
+}
+
+describe('MCP server tools', () => {
+  it('lists all six 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([
+          'get_messages',
+          'get_node',
+          'list_channels',
+          'list_nodes',
+          'mesh_status',
+          'send_message',
+        ]);
+        for (const t of tools) expect(t.description?.length).toBeGreaterThan(0);
+
+        const send = tools.find((t) => t.name === 'send_message')!;
+        expect(send.inputSchema.required).toEqual(['text']);
+        expect(Object.keys(send.inputSchema.properties ?? {})).toEqual([
+          'text',
+          'to',
+        ]);
+      } finally {
+        await mcp.close();
+      }
+    } finally {
+      env.close();
+    }
+  });
+
+  it('mesh_status returns the bridge connection state', async () => {
+    const env = await connectedService();
+    try {
+      const mcp = await connectMcp(env.svc);
+      try {
+        const r = await mcp.client.callTool({
+          name: 'mesh_status',
+          arguments: {},
+        });
+        expect(r.isError).not.toBe(true);
+        expect(JSON.parse(toolText(r))).toEqual({
+          connected: true,
+          myNodeNum: null,
+          host: '127.0.0.1',
+          port: Number(process.env.MESH_PORT),
+        });
+      } finally {
+        await mcp.close();
+      }
+    } finally {
+      env.close();
+    }
+  });
+
+  it('send_message broadcasts by default and resolves names to node numbers', async () => {
+    const env = await connectedService();
+    try {
+      env.sockets[0].write(nodeInfoFrame(KAMIL_NUM, kamilNodeInfo()));
+      await waitFor(async () => (await env.svc.nodes()).length === 1);
+
+      const mcp = await connectMcp(env.svc);
+      try {
+        const r1 = await mcp.client.callTool({
+          name: 'send_message',
+          arguments: { text: 'hello' },
+        });
+        expect(r1.isError).not.toBe(true);
+        const bcast = JSON.parse(toolText(r1)) as { id: number };
+        expect(bcast.id).toBeGreaterThan(0);
+        expect(env.svc.messages()[0]).toMatchObject({
+          dir: 'tx',
+          to: BROADCAST_ADDR,
+        });
+
+        // name lookup via the node DB (unique substring)
+        const r2 = await mcp.client.callTool({
+          name: 'send_message',
+          arguments: { text: 'dm', to: 'kamil' },
+        });
+        expect(r2.isError).not.toBe(true);
+        expect(env.svc.messages()[0]).toMatchObject({
+          dir: 'tx',
+          to: KAMIL_NUM,
+        });
+      } finally {
+        await mcp.close();
+      }
+    } finally {
+      env.close();
+    }
+  });
+
+  it('send_message surfaces resolution errors as tool errors with the REST messages', async () => {
+    const env = await connectedService();
+    try {
+      const mcp = await connectMcp(env.svc);
+      try {
+        const r1 = await mcp.client.callTool({
+          name: 'send_message',
+          arguments: { text: 'x', to: 'zzz-nope' },
+        });
+        expect(r1.isError).toBe(true);
+        expect(toolText(r1)).toContain("no node matching 'zzz-nope'");
+
+        const r2 = await mcp.client.callTool({
+          name: 'send_message',
+          arguments: { text: 'x', to: '0' },
+        });
+        expect(r2.isError).toBe(true);
+        expect(toolText(r2)).toContain('invalid node number');
+      } finally {
+        await mcp.close();
+      }
+    } finally {
+      env.close();
+    }
+  });
+
+  it('get_node resolves by name and errors when missing', async () => {
+    const env = await connectedService();
+    try {
+      env.sockets[0].write(nodeInfoFrame(KAMIL_NUM, kamilNodeInfo()));
+      await waitFor(async () => (await env.svc.nodes()).length === 1);
+
+      const mcp = await connectMcp(env.svc);
+      try {
+        const r1 = await mcp.client.callTool({
+          name: 'get_node',
+          arguments: { id: 'kamil' },
+        });
+        expect(r1.isError).not.toBe(true);
+        expect(JSON.parse(toolText(r1))).toMatchObject({
+          num: KAMIL_NUM,
+          longName: 'Kamil SP8MK/P',
+          shortName: 'KK',
+        });
+
+        const r2 = await mcp.client.callTool({
+          name: 'get_node',
+          arguments: { id: 'zzz' },
+        });
+        expect(r2.isError).toBe(true);
+        expect(toolText(r2)).toContain("no node matching 'zzz'");
+      } finally {
+        await mcp.close();
+      }
+    } finally {
+      env.close();
+    }
+  });
+
+  it('list_channels, list_nodes and get_messages return the service data', async () => {
+    const env = await connectedService();
+    try {
+      env.sockets[0].write(nodeInfoFrame(KAMIL_NUM, kamilNodeInfo()));
+      await waitFor(async () => (await env.svc.nodes()).length === 1);
+
+      const mcp = await connectMcp(env.svc);
+      try {
+        expect(
+          JSON.parse(
+            toolText(
+              await mcp.client.callTool({
+                name: 'list_channels',
+                arguments: {},
+              }),
+            ),
+          ),
+        ).toEqual([]); // no channel frames fed yet
+
+        const nodes = JSON.parse(
+          toolText(
+            await mcp.client.callTool({ name: 'list_nodes', arguments: {} }),
+          ),
+        ) as { num: number; longName?: string }[];
+        expect(nodes).toHaveLength(1);
+        expect(nodes[0].num).toBe(KAMIL_NUM);
+        expect(nodes[0].longName).toBe('Kamil SP8MK/P');
+
+        await mcp.client.callTool({
+          name: 'send_message',
+          arguments: { text: 'hi' },
+        });
+        const msgs = JSON.parse(
+          toolText(
+            await mcp.client.callTool({ name: 'get_messages', arguments: {} }),
+          ),
+        ) as { dir: string; to?: number }[];
+        expect(msgs[0]).toMatchObject({ dir: 'tx', to: BROADCAST_ADDR }); // newest first
+      } finally {
+        await mcp.close();
+      }
+    } finally {
+      env.close();
+    }
+  });
+});
@@ -0,0 +1,116 @@
+import { Controller, Post, Req, Res } from '@nestjs/common';
+import type { Request } from 'express';
+import type { ServerResponse } from 'node:http';
+import { ApiExcludeEndpoint } from '@nestjs/swagger';
+import { z } from 'zod';
+// The SDK's root entry is broken in all published 1.x tarballs (upstream #2273: the exports map points to a dist index that was never shipped) — use the documented subpath imports instead.
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import * as pkg from '../../package.json';
+import { MeshService } from './mesh.service.js';
+
+const CHANNEL_NOTE =
+  ' All sends ride the pinned "test" channel (index 3) — never the primary channel.';
+
+function jsonResult(value: unknown): {
+  content: { type: 'text'; text: string }[];
+} {
+  return { content: [{ type: 'text', text: JSON.stringify(value) }] };
+}
+
+/** Build an MCP server exposing the MeshService as tools (1:1 with the REST endpoints). */
+export function createMeshMcpServer(mesh: MeshService): McpServer {
+  const server = new McpServer({ name: 'mesh-bot', version: pkg.version });
+
+  server.registerTool(
+    'mesh_status',
+    {
+      description: `Bridge connection state: whether the bot is connected to the meshtastic bridge, this device's node number, and the bridge host/port.${CHANNEL_NOTE}`,
+    },
+    async () => jsonResult(mesh.status()),
+  );
+
+  server.registerTool(
+    'send_message',
+    {
+      description: `Send a text message over the mesh; returns { id } — the Meshtastic packet id. to: omitted/"" or "!b"/"broadcast" (case-insensitive) → broadcast; number or numeric string → that node number (integer in 1..0xffffffff); anything else is looked up by name (exact long/short name, then unique substring). Unknown or ambiguous targets are an error.${CHANNEL_NOTE}`,
+      inputSchema: { text: z.string(), to: z.string().optional() },
+    },
+    async ({ text, to }) =>
+      jsonResult({ id: await mesh.sendText(await mesh.resolveDest(to), text) }),
+  );
+
+  server.registerTool(
+    'list_channels',
+    {
+      description: `The device's Meshtastic channels as { index, name, uplinkEnabled, downlinkEnabled }[] sorted by index (psk/keys redacted); empty until the initial sync completes.${CHANNEL_NOTE}`,
+    },
+    async () => jsonResult(mesh.channels()),
+  );
+
+  server.registerTool(
+    'list_nodes',
+    {
+      description: `Known mesh nodes as lean summaries sorted by node number; names/hwModel/batteryLevel appear only when the device reported them, lastHeard is epoch seconds (null = never heard), position only when both coordinates are known.${CHANNEL_NOTE}`,
+    },
+    async () => jsonResult(await mesh.nodes()),
+  );
+
+  server.registerTool(
+    'get_node',
+    {
+      description: `Look up one node by exact node number (number or numeric string), then case-insensitive exact long/short name, else the unique case-insensitive substring match. Errors when nothing or more than one node matches.${CHANNEL_NOTE}`,
+      inputSchema: { id: z.string() },
+    },
+    async ({ id }) => {
+      const n = await mesh.node(id);
+      if (!n) throw new Error(`no node matching '${id}'`);
+      return jsonResult(n);
+    },
+  );
+
+  server.registerTool(
+    'get_messages',
+    {
+      description: `Message history, newest first (last 100): inbound text (dir "rx", with from) and our sends (dir "tx", with to + status pending→delivered/failed; broadcasts stay pending because firmware strips want_ack). In-memory only, reset on every bridge reconnect.${CHANNEL_NOTE}`,
+    },
+    async () => jsonResult(mesh.messages()),
+  );
+
+  return server;
+}
+
+@Controller()
+export class McpController {
+  constructor(private readonly mesh: MeshService) {}
+
+  // MCP Streamable HTTP endpoint (stateless mode): a fresh server + transport per request, outside the /api prefix.
+  @Post('mcp')
+  @ApiExcludeEndpoint()
+  async mcp(@Req() req: Request, @Res() res: ServerResponse): Promise<void> {
+    const server = createMeshMcpServer(this.mesh);
+    try {
+      const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: undefined,
+      });
+      await server.connect(transport);
+      await transport.handleRequest(req, res, req.body);
+      res.on('close', () => {
+        void transport.close();
+        void server.close();
+      });
+    } catch (error) {
+      if (!res.headersSent) {
+        res.statusCode = 500;
+        res.setHeader('content-type', 'application/json');
+        res.end(
+          JSON.stringify({
+            jsonrpc: '2.0',
+            error: { code: -32603, message: String(error) },
+            id: null,
+          }),
+        );
+      }
+    }
+  }
+}
@@ -3,10 +3,16 @@ import {
  Body,
  Controller,
  Get,
+  NotFoundException,
+  Param,
  Post,
 } from '@nestjs/common';
-import { ApiOperation, ApiProperty } from '@nestjs/swagger';
-import { BROADCAST_ADDR } from './codec.js';
+import {
+  ApiOperation,
+  ApiProperty,
+  ApiResponse,
+  ApiTags,
+} from '@nestjs/swagger';
 import { MeshService } from './mesh.service.js';

 export class SendTextDto {
@@ -15,37 +21,62 @@ export class SendTextDto {
  @ApiProperty({
    required: false,
    description:
-      'Decimal node number, "!b", or "broadcast" (defaults to broadcast)',
+      'Send target. Resolution order: omitted or "" → broadcast (0xffffffff); number → used as-is (integer in 1..0xffffffff); numeric string → that node number; "!b" or "broadcast" (case-insensitive) → broadcast; anything else is looked up by name — exact long/short name, then unique substring. DMs are unicast and wantAck-tracked via GET /api/messages (pending→delivered/failed); broadcasts stay pending because firmware strips want_ack.',
    example: '!b',
  })
  to?: string | number;
 }

+// tag description is set via DocumentBuilder.addTag in main.ts (v12 ApiTagOptions has no description)
+@ApiTags('Mesh')
@Controller()
 export class MeshController {
  constructor(private readonly mesh: MeshService) {}

  @Get('status')
-  @ApiOperation({ summary: 'Bridge connection status' })
+  @ApiOperation({
+    summary: 'Bridge connection status',
+    description:
+      'Whether the bot is connected to the meshtastic-serial-bridge and which node number this device has.',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Connection status',
+    example: {
+      connected: true,
+      myNodeNum: 123456789,
+      host: '192.168.1.4',
+      port: 4403,
+    },
+  })
  status() {
    return this.mesh.status();
  }

  @Post('send')
-  @ApiOperation({ summary: 'Send a text message over the mesh' })
+  @ApiOperation({
+    summary: 'Send a text message over the mesh',
+    description:
+      'Queues a TEXT_MESSAGE_APP packet to the resolved target (node number, node name, or broadcast). DMs are unicast and wantAck-tracked via GET /api/messages; broadcasts stay pending because firmware strips want_ack. All sends ride the pinned test channel (index 3, "test" — never the primary channel) regardless of DM or broadcast, since modern firmware PKI handles unicast encryption/channel anyway. Returns the Meshtastic packet id.',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Packet queued',
+    example: { id: 123456789 },
+  })
+  @ApiResponse({ status: 400, description: 'Invalid text or target' })
+  @ApiResponse({ status: 503, description: 'Bridge not connected' })
  async send(@Body() body: SendTextDto) {
    if (typeof body?.text !== 'string' || body.text.length === 0) {
      throw new BadRequestException('text must be a non-empty string');
    }
-    let to = BROADCAST_ADDR;
-    const t = body.to;
-    if (t !== undefined && t !== '!b' && t !== 'broadcast') {
-      const n = typeof t === 'number' ? t : Number(String(t));
-      if (!Number.isFinite(n))
-        throw new BadRequestException(
-          'to must be a decimal node number, "!b", or "broadcast"',
-        );
-      to = n;
+    let to: number;
+    try {
+      to = await this.mesh.resolveDest(body.to);
+    } catch (err) {
+      throw new BadRequestException(
+        err instanceof Error ? err.message : String(err),
+      );
    }
    return { id: await this.mesh.sendText(to, body.text) };
  }
@@ -53,8 +84,107 @@ export class MeshController {
  @Get('channels')
  @ApiOperation({
    summary: "The device's Meshtastic channels (keys redacted)",
+    description:
+      'Channel table streamed during the initial sync; empty until it completes. psk/keys are never exposed.',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Channels sorted by index',
+    example: [
+      { index: 0, name: 'Default', uplinkEnabled: true, downlinkEnabled: true },
+      {
+        index: 3,
+        name: 'test',
+        uplinkEnabled: false,
+        downlinkEnabled: false,
+      },
+    ],
  })
  channels() {
    return this.mesh.channels();
  }
+
+  @Get('messages')
+  @ApiOperation({
+    summary: 'Message history (last 100)',
+    description:
+      'Inbound text messages and our sends, newest first. tx records start "pending" and move to "delivered"/"failed" when the routing ACK/NACK arrives; broadcasts stay "pending" because firmware strips want_ack before TX. History is in-memory only (last 100) and resets on every bridge reconnect.',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Messages newest first',
+    example: [
+      {
+        id: 456789,
+        dir: 'tx',
+        to: 42,
+        text: 'hello test',
+        channel: 3,
+        at: 1758000123456,
+        status: 'delivered',
+      },
+      {
+        id: 123456,
+        dir: 'rx',
+        from: 987654321,
+        text: 'ping',
+        channel: 2,
+        at: 1758000000000,
+      },
+    ],
+  })
+  messages() {
+    return this.mesh.messages();
+  }
+
+  @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.',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'Nodes sorted by node number',
+    example: [
+      {
+        num: 123456789,
+        longName: 'Kamil SP8MK/P',
+        shortName: 'KK',
+        hwModel: 'TBEAM',
+        batteryLevel: 87,
+        lastHeard: 1758000000,
+        position: { lat: 52.1049637, lon: 20.9833152, alt: 123 },
+      },
+    ],
+  })
+  async nodes() {
+    return this.mesh.nodes();
+  }
+
+  @Get('nodes/:id')
+  @ApiOperation({
+    summary: 'Look up one node by number or name',
+    description:
+      'Exact node number first (numbers and numeric strings), then case-insensitive exact long/short name, else the unique case-insensitive substring match across names. 404 when nothing or more than one node matches.',
+  })
+  @ApiResponse({
+    status: 200,
+    description: 'The matching node',
+    example: {
+      num: 123456789,
+      longName: 'Kamil SP8MK/P',
+      shortName: 'KK',
+      lastHeard: null,
+    },
+  })
+  @ApiResponse({
+    status: 404,
+    description: 'No node (or more than one) matching the given id or name',
+  })
+  async node(@Param('id') id: string) {
+    const n = await this.mesh.node(id);
+    if (!n) throw new NotFoundException(`no node matching '${id}'`);
+    return n;
+  }
 }
@@ -1,9 +1,10 @@
 import { Module } from '@nestjs/common';
+import { McpController } from './mcp.controller.js';
 import { MeshController } from './mesh.controller.js';
 import { MeshService } from './mesh.service.js';

@Module({
-  controllers: [MeshController],
+  controllers: [MeshController, McpController],
  providers: [MeshService],
 })
 export class MeshModule {}
@@ -1,38 +1,99 @@
 import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
 import * as P from '@meshtastic/protobufs';
-import * as net from 'node:net';
-import type { AddressInfo } from 'node:net';
 import { describe, expect, it } from 'vitest';
-import { extractFrames, frame } from './codec.js';
+import { BROADCAST_ADDR, extractFrames, frame } from './codec.js';
+import {
+  KAMIL_NUM,
+  kamilNodeInfo,
+  nodeInfoFrame,
+  startBridge,
+  waitFor,
+} from './fake-bridge.js';
 import { MeshService } from './mesh.service.js';

-function startBridge(onSocket?: (s: net.Socket) => void): Promise<{
-  port: number;
-  sockets: net.Socket[];
-  close: () => void;
-}> {
-  const sockets: net.Socket[] = [];
-  const server = net.createServer((socket) => {
-    onSocket?.(socket); // attached at accept time, before any data can arrive
-    sockets.push(socket);
+// live position update: POSITION_APP packet with a serialized Position in Data.payload
+function positionPacketFrame(
+  from: number,
+  pos: { latitudeI?: number; longitudeI?: number },
+): Uint8Array {
+  const data = create(P.Mesh.DataSchema, {
+    portnum: P.Portnums.PortNum.POSITION_APP,
+    payload: toBinary(
+      P.Mesh.PositionSchema,
+      create(P.Mesh.PositionSchema, pos),
+    ),
  });
-  return new Promise((resolve) => {
-    server.listen(0, '127.0.0.1', () => {
-      resolve({
-        port: (server.address() as AddressInfo).port,
-        sockets,
-        close: () => server.close(),
-      });
-    });
+  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 },
+      }),
+    ),
+  );
 }

-async function waitFor(cond: () => boolean, timeoutMs = 5000): Promise<void> {
-  const t0 = Date.now();
-  while (!cond()) {
-    if (Date.now() - t0 > timeoutMs) throw new Error('timed out waiting');
-    await new Promise((r) => setTimeout(r, 10));
-  }
+// inbound text message: TEXT_MESSAGE_APP packet with UTF-8 in Data.payload
+function textPacketFrame(
+  from: number,
+  to: number,
+  text: string,
+  channel = 0,
+): Uint8Array {
+  const data = create(P.Mesh.DataSchema, {
+    portnum: P.Portnums.PortNum.TEXT_MESSAGE_APP,
+    payload: new TextEncoder().encode(text),
+  });
+  const pkt = create(P.Mesh.MeshPacketSchema, {
+    from,
+    to,
+    id: 1,
+    channel,
+    payloadVariant: { case: 'decoded', value: data },
+  });
+  return frame(
+    toBinary(
+      P.Mesh.FromRadioSchema,
+      create(P.Mesh.FromRadioSchema, {
+        payloadVariant: { case: 'packet', value: pkt },
+      }),
+    ),
+  );
+}
+
+// ACK/NACK for our sends: ROUTING_APP packet with Data.requestId = original id and a serialized Routing in the payload
+function routingFrame(
+  requestId: number,
+  errorReason: P.Mesh.Routing_Error,
+): Uint8Array {
+  const data = create(P.Mesh.DataSchema, {
+    portnum: P.Portnums.PortNum.ROUTING_APP,
+    requestId,
+    payload: toBinary(
+      P.Mesh.RoutingSchema,
+      create(P.Mesh.RoutingSchema, {
+        variant: { case: 'errorReason', value: errorReason },
+      }),
+    ),
+  });
+  const pkt = create(P.Mesh.MeshPacketSchema, {
+    from: 1,
+    id: 2,
+    payloadVariant: { case: 'decoded', value: data },
+  });
+  return frame(
+    toBinary(
+      P.Mesh.FromRadioSchema,
+      create(P.Mesh.FromRadioSchema, {
+        payloadVariant: { case: 'packet', value: pkt },
+      }),
+    ),
+  );
 }

 function channelFrame(
@@ -178,11 +239,11 @@ describe('MeshService connect', () => {
 });

 describe('MeshService send', () => {
-  it('sends on the test channel (index 2) by default, never primary', async () => {
+  it('sends on the test channel (index 3) by default, never primary', async () => {
    const bridge = await startBridge();
    process.env.MESH_HOST = '127.0.0.1';
    process.env.MESH_PORT = String(bridge.port);
-    delete process.env.MESH_SEND_CHANNEL; // default path: "testowy" (index 2)
+    delete process.env.MESH_SEND_CHANNEL; // default path: "test" (index 3)
    const svc = new MeshService();
    try {
      svc.onModuleInit();
@@ -192,7 +253,7 @@ describe('MeshService send', () => {

      const out: Uint8Array[] = [];
      bridge.sockets[0].on('data', (c) => out.push(c));
-      const id = await svc.sendText(42, 'hello testowy');
+      const id = await svc.sendText(42, 'hello test');
      expect(id).toBeGreaterThan(0);

      const readOutbound = (): P.Mesh.MeshPacket | undefined => {
@@ -214,7 +275,7 @@ describe('MeshService send', () => {

      await waitFor(() => readOutbound() !== undefined);
      const pkt = readOutbound()!;
-      expect(pkt.channel).toBe(2); // "testowy" — never the primary channel (0)
+      expect(pkt.channel).toBe(3); // "test" — never the primary channel (0)
      expect(pkt.to).toBe(42);
      const decoded =
        pkt.payloadVariant?.case === 'decoded'
@@ -222,7 +283,7 @@ describe('MeshService send', () => {
          : undefined;
      expect(
        new TextDecoder().decode(decoded?.payload ?? new Uint8Array()),
-      ).toBe('hello testowy');
+      ).toBe('hello test');
    } finally {
      delete process.env.MESH_SEND_CHANNEL;
      svc.onModuleDestroy();
@@ -230,3 +291,326 @@ describe('MeshService send', () => {
    }
  });
 });
+
+describe('MeshService node database', () => {
+  it('collects NodeInfo during sync and summarizes nodes', 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(987654321)); // bare entry: no user/position/metrics yet
+
+      await waitFor(async () => (await svc.nodes()).length === 2);
+      expect(await svc.nodes()).toEqual([
+        {
+          num: KAMIL_NUM,
+          longName: 'Kamil SP8MK/P',
+          shortName: 'KK',
+          hwModel: 'TBEAM',
+          batteryLevel: 87,
+          lastHeard: 1758000000,
+          position: { lat: 521049637 * 1e-7, lon: 209833152 * 1e-7, alt: 123 },
+        },
+        { num: 987654321, lastHeard: null }, // names/hwModel/battery/position omitted when absent
+      ]);
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('creates a stub entry for POSITION_APP packets from unknown nodes', 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(
+        positionPacketFrame(555, {
+          latitudeI: 10000000,
+          longitudeI: -20000000,
+        }),
+      );
+
+      await waitFor(async () => (await svc.nodes()).length === 1);
+      expect(await svc.nodes()).toEqual([
+        { num: 555, lastHeard: null, position: { lat: 1, lon: -2 } }, // no alt sent -> omitted
+      ]);
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('looks up nodes by exact num, numeric string, exact name and unique substring', 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', shortName: 'OT' },
+        }),
+      );
+      await waitFor(async () => (await svc.nodes()).length === 2);
+
+      expect((await svc.node(KAMIL_NUM))?.longName).toBe('Kamil SP8MK/P'); // exact num
+      expect((await svc.node(String(KAMIL_NUM)))?.num).toBe(KAMIL_NUM); // numeric string
+      expect((await svc.node('kamil sp8mk/p'))?.shortName).toBe('KK'); // case-insensitive exact name
+      expect((await svc.node('kamil'))?.num).toBe(KAMIL_NUM); // unique substring
+      expect(await svc.node('zzz-nope')).toBeNull(); // no match
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('returns null for ambiguous name matches', 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,
+      );
+
+      // two nodes whose names both contain "kamil" and share the short name "KK"
+      bridge.sockets[0].write(nodeInfoFrame(KAMIL_NUM, kamilNodeInfo()));
+      bridge.sockets[0].write(
+        nodeInfoFrame(777, {
+          user: { id: '!kj', longName: 'Kamil Jr.', shortName: 'KK' },
+        }),
+      );
+      await waitFor(async () => (await svc.nodes()).length === 2);
+
+      expect(await svc.node('kamil')).toBeNull(); // substring matches two nodes
+      expect(await svc.node('kk')).toBeNull(); // exact name matches two nodes
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('resets the node database 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(nodeInfoFrame(KAMIL_NUM, kamilNodeInfo()));
+      await waitFor(async () => (await svc.nodes()).length === 1);
+
+      // drop the connection; bot reconnects and must start with an empty node DB
+      bridge.sockets[0].destroy();
+      await waitFor(() => bridge.sockets.length >= 2 && svc.status().connected);
+      await waitFor(async () => (await svc.nodes()).length === 0);
+    } finally {
+      delete process.env.MESH_RECONNECT_MS;
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+});
+
+describe('MeshService message history', () => {
+  it('captures inbound text as rx records', 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(textPacketFrame(KAMIL_NUM, 42, 'ping', 2));
+
+      await waitFor(() => svc.messages().length === 1);
+      expect(svc.messages()).toEqual([
+        {
+          id: 1,
+          dir: 'rx',
+          from: KAMIL_NUM,
+          text: 'ping',
+          channel: 2,
+          at: expect.any(Number),
+        },
+      ]);
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('tracks a tx send pending -> delivered on the routing ACK', 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 id = await svc.sendText(42, 'hello test');
+      expect(svc.messages()[0]).toMatchObject({
+        id,
+        dir: 'tx',
+        to: 42,
+        text: 'hello test',
+        channel: 3,
+        status: 'pending',
+      });
+
+      bridge.sockets[0].write(routingFrame(id, P.Mesh.Routing_Error.NONE));
+
+      await waitFor(() => svc.messages()[0]?.status === 'delivered');
+      expect(svc.messages()[0]).toMatchObject({
+        id,
+        dir: 'tx',
+        status: 'delivered',
+      });
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('marks a tx failed with the routing error reason on NACK', 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 id = await svc.sendText(42, 'will fail');
+      expect(svc.messages()[0]?.status).toBe('pending');
+
+      bridge.sockets[0].write(routingFrame(id, P.Mesh.Routing_Error.TIMEOUT));
+
+      await waitFor(() => svc.messages()[0]?.status === 'failed');
+      expect(svc.messages()[0]).toMatchObject({
+        id,
+        status: 'failed',
+        ackError: 'TIMEOUT', // human-readable Routing.Error name
+      });
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('caps history 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(textPacketFrame(42, KAMIL_NUM, `m-${i}`));
+
+      await waitFor(() => svc.messages().length === 100, 10000);
+      expect(svc.messages()[0]?.text).toBe('m-104'); // newest first
+      expect(svc.messages()[99]?.text).toBe('m-5'); // m-0..m-4 dropped
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+});
+
+describe('MeshService resolveDest', () => {
+  it('resolves broadcast sentinels, numbers and names to node numbers', 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()));
+      await waitFor(async () => (await svc.nodes()).length === 1);
+
+      expect(await svc.resolveDest(undefined)).toBe(BROADCAST_ADDR); // omitted → broadcast
+      expect(await svc.resolveDest('')).toBe(BROADCAST_ADDR); // empty → broadcast
+      expect(await svc.resolveDest('!b')).toBe(BROADCAST_ADDR);
+      expect(await svc.resolveDest('BROADCAST')).toBe(BROADCAST_ADDR); // case-insensitive
+      expect(await svc.resolveDest(42)).toBe(42); // number passthrough
+      expect(await svc.resolveDest(String(KAMIL_NUM))).toBe(KAMIL_NUM); // numeric string
+      expect(await svc.resolveDest('Kamil SP8MK/P')).toBe(KAMIL_NUM); // exact longName
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+
+  it('throws for unknown names and invalid node numbers', 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()));
+      await waitFor(async () => (await svc.nodes()).length === 1);
+
+      await expect(svc.resolveDest('zzz-nope')).rejects.toThrow(
+        "no node matching 'zzz-nope'",
+      );
+      for (const bad of [0, -1, 42.5, BROADCAST_ADDR + 1]) {
+        await expect(svc.resolveDest(bad)).rejects.toThrow(
+          /invalid node number/,
+        );
+      }
+      await expect(svc.resolveDest('0')).rejects.toThrow(/invalid node number/);
+    } finally {
+      svc.onModuleDestroy();
+      bridge.close();
+    }
+  });
+});
@@ -6,15 +6,61 @@ import {
  ServiceUnavailableException,
 } from '@nestjs/common';
 import * as net from 'node:net';
+import type * as Proto from '@meshtastic/protobufs';
 import {
+  BROADCAST_ADDR,
+  PORT_POSITION_APP,
+  PORT_ROUTING_APP,
  PORT_TEXT_MESSAGE_APP,
  buildTextToRadio,
  buildWantConfigToRadio,
  decodeFromRadio,
+  decodePosition,
+  decodeRouting,
+  describeRoutingError,
  extractFrames,
  frame,
+  loadHwModelNames,
 } from './codec.js';

+/** One entry in the message history: an inbound text (dir 'rx') or one of our sends (dir 'tx'). */
+export interface MessageRecord {
+  id: number;
+  dir: 'rx' | 'tx';
+  /** sender node num — rx only */
+  from?: number;
+  /** destination node num (broadcast addr for broadcasts) — tx only */
+  to?: number;
+  text: string;
+  channel: number;
+  /** epoch ms */
+  at: number;
+  /** tx only: pending until the routing ACK/NACK arrives; broadcasts stay pending (firmware strips want_ack pre-TX) */
+  status?: 'pending' | 'delivered' | 'failed';
+  /** tx only, when failed: human-readable Routing.Error reason */
+  ackError?: string;
+}
+
+// bounded history: keep the newest N records, in-memory only
+const HISTORY_LIMIT = 100;
+
+/** What we know about a node so far: full NodeInfo after sync, possibly just {num}+position for live-only nodes. */
+type NodeEntry = Pick<Proto.Mesh.NodeInfo, 'num'> &
+  Partial<Omit<Proto.Mesh.NodeInfo, 'num'>>;
+
+export interface NodeSummary {
+  num: number;
+  longName?: string;
+  shortName?: string;
+  /** meshtastic.HardwareModel enum name (e.g. "TBEAM"); omitted when unknown or UNSET */
+  hwModel?: string;
+  /** 0-100 = battery percent, >100 = mains powered (device convention) */
+  batteryLevel?: number;
+  /** epoch seconds of the last heard packet; null when never heard */
+  lastHeard: number | null;
+  position?: { lat: number; lon: number; alt?: number };
+}
+
@Injectable()
 export class MeshService implements OnModuleInit, OnModuleDestroy {
  private readonly logger = new Logger(MeshService.name);
@@ -25,9 +71,9 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
    process.env.MESH_RECONNECT_MS ?? '5000',
    10,
  );
-  // sends are pinned to the test channel ("testowy", index 2) on purpose — never the primary channel
+  // sends are pinned to the test channel ("test", index 3) on purpose — never the primary channel
  private readonly sendChannel = parseInt(
-    process.env.MESH_SEND_CHANNEL ?? '2',
+    process.env.MESH_SEND_CHANNEL ?? '3',
    10,
  );

@@ -40,6 +86,11 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
    number,
    import('@meshtastic/protobufs').Channel.Channel
  >();
+  // node database: NodeInfo frames from the initial sync + live POSITION_APP updates
+  private nodeMap = new Map<number, NodeEntry>();
+  // 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>();
  private reconnectTimer: NodeJS.Timeout | null = null;
  private shuttingDown = false;

@@ -53,6 +104,7 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
    this.socket?.destroy();
  }

+  /** Bridge connection state: `{ connected, myNodeNum, host, port }`. */
  status() {
    return {
      connected: this.connected,
@@ -63,6 +115,7 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
  }

  // psk/keys are deliberately not included — never expose them over HTTP
+  /** Device channels as `{ index, name, uplinkEnabled, downlinkEnabled }[]` sorted by index; empty until the initial sync completes. */
  channels(): {
    index: number;
    name: string;
@@ -79,22 +132,144 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
      }));
  }

+  /**
+   * Lean summaries of all known nodes, sorted by node number.
+   * Names/hwModel/batteryLevel 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[]> {
+    const names = await loadHwModelNames();
+    return [...this.nodeMap.values()]
+      .sort((a, b) => a.num - b.num)
+      .map((n) => this.summarize(n, names));
+  }
+
+  /**
+   * Look up one node: exact node number first (numbers and numeric strings),
+   * then case-insensitive EXACT long/short name, else the unique case-insensitive
+   * SUBSTRING match across long/short names. Returns null when nothing or more
+   * than one node matches. Reused by send-by-name lookups.
+   */
+  async node(idOrName: string | number): Promise<NodeSummary | null> {
+    const q = String(idOrName).trim().toLowerCase();
+    if (!q) return null;
+    const names = await loadHwModelNames();
+    if (/^\d+$/.test(q)) {
+      const hit = this.nodeMap.get(Number(q));
+      if (hit) return this.summarize(hit, names);
+    }
+    const all = [...this.nodeMap.values()];
+    // exact name match wins over substring; a string always contains itself, so an ambiguous exact set can never become unique below
+    const exact = all.filter(
+      (n) =>
+        n.user &&
+        (n.user.longName.toLowerCase() === q ||
+          n.user.shortName.toLowerCase() === q),
+    );
+    if (exact.length === 1) return this.summarize(exact[0], names);
+    const sub = all.filter(
+      (n) =>
+        n.user &&
+        (n.user.longName.toLowerCase().includes(q) ||
+          n.user.shortName.toLowerCase().includes(q)),
+    );
+    if (sub.length === 1) return this.summarize(sub[0], names);
+    return null;
+  }
+
+  /**
+   * Resolve a send target to a node number for sendText().
+   * undefined/"" and "!b"/"broadcast" (case-insensitive, trimmed) → BROADCAST_ADDR;
+   * numbers pass through as-is (must be an integer in 1..0xffffffff); numeric strings are parsed the same way;
+   * anything else is looked up via node() — throws `no node matching '<to>'` when nothing or more than one matches.
+   */
+  async resolveDest(to?: number | string): Promise<number> {
+    if (typeof to === 'number') {
+      this.assertNodeNum(to);
+      return to;
+    }
+    const s = String(to ?? '').trim();
+    if (!s) return BROADCAST_ADDR; // omitted or empty → broadcast
+    if (s === '!b' || s.toLowerCase() === 'broadcast') return BROADCAST_ADDR;
+    if (/^\d+$/.test(s)) {
+      this.assertNodeNum(Number(s));
+      return Number(s);
+    }
+    const hit = await this.node(s);
+    if (!hit) throw new Error(`no node matching '${to}'`);
+    return hit.num;
+  }
+
+  private assertNodeNum(n: number): void {
+    if (!Number.isInteger(n) || n < 1 || n > BROADCAST_ADDR)
+      throw new Error(`invalid node number '${n}'`);
+  }
+
+  /**
+   * Message history, newest first: inbound TEXT_MESSAGE_APP packets (dir 'rx') and our sends (dir 'tx').
+   * tx records start 'pending' and move to 'delivered'/'failed' when the routing ACK/NACK arrives;
+   * broadcasts stay 'pending' because firmware strips want_ack before TX. In-memory only, last 100, reset on reconnect.
+   */
+  messages(): MessageRecord[] {
+    return [...this.history].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)
      throw new ServiceUnavailableException('bridge not connected');
    const { bytes, id } = await buildTextToRadio(to, text, this.sendChannel);
+    const rec: MessageRecord = {
+      id,
+      dir: 'tx',
+      to,
+      text,
+      channel: this.sendChannel,
+      at: Date.now(),
+      status: 'pending',
+    };
+    this.pushHistory(rec);
+    this.pendingTx.set(id, rec);
    this.socket.write(bytes);
    return id;
  }

+  private pushHistory(rec: MessageRecord): void {
+    this.history.push(rec);
+    // ponytail: shift on a ≤100 array is fine; true ring buffer only if this ever gets hot
+    if (this.history.length > HISTORY_LIMIT) this.history.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;
+    if (n.user?.shortName) s.shortName = n.user.shortName;
+    // 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
+    const battery = n.deviceMetrics?.batteryLevel;
+    if (battery !== undefined) s.batteryLevel = battery;
+    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
+      s.position = { lat: p.latitudeI * 1e-7, lon: p.longitudeI * 1e-7 };
+      if (p.altitude !== undefined) s.position.alt = p.altitude;
+    }
+    return s;
+  }
+
  private connect(): void {
    if (this.shuttingDown) return;
    const socket = net.createConnection({ host: this.host, port: this.port });
    this.socket = socket;
    socket.on('connect', () => {
      this.connected = true;
-      // fresh sync on every (re)connect — drop stale channels from the old session
+      // fresh sync on every (re)connect — drop stale channels/nodes/history from the old session
      this.channelMap = new Map();
+      this.nodeMap = new Map();
+      this.history = [];
+      this.pendingTx.clear();
      this.logger.log(`bridge connected ${this.host}:${this.port}`);
      const nonce = Math.floor(Math.random() * 0xffffffff) || 1;
      buildWantConfigToRadio(nonce)
@@ -136,9 +311,9 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
    this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectMs);
  }

-  private handleFromRadio(
+  private async handleFromRadio(
    fr: import('@meshtastic/protobufs').Mesh.FromRadio,
-  ): void {
+  ): Promise<void> {
    const v = fr.payloadVariant;
    switch (v?.case) {
      case 'myInfo':
@@ -149,9 +324,13 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
        // device streams one Channel per table slot during initial sync
        this.channelMap.set(v.value.index, v.value);
        break;
+      case 'nodeInfo':
+        // device streams the whole node DB during initial sync
+        this.nodeMap.set(v.value.num, v.value);
+        break;
      case 'configCompleteId':
        this.logger.log(
-          `bridge ready (config complete), ${this.channelMap.size} channels`,
+          `bridge ready (config complete), ${this.channelMap.size} channels, ${this.nodeMap.size} nodes`,
        );
        break;
      case 'packet': {
@@ -161,9 +340,54 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
            ? pkt.payloadVariant.value
            : undefined;
        if (decoded && decoded.portnum === PORT_TEXT_MESSAGE_APP) {
-          this.logger.log(
-            `[mesh] ${pkt.from} -> ${pkt.to}: "${new TextDecoder().decode(decoded.payload)}"`,
-          );
+          const text = new TextDecoder().decode(decoded.payload);
+          this.logger.log(`[mesh] ${pkt.from} -> ${pkt.to}: "${text}"`);
+          this.pushHistory({
+            id: pkt.id,
+            dir: 'rx',
+            from: pkt.from,
+            text,
+            channel: pkt.channel ?? 0,
+            at: Date.now(),
+          });
+        } else if (decoded && decoded.portnum === PORT_POSITION_APP) {
+          // live position update: the Position is serialized in Data.payload
+          let pos: Proto.Mesh.Position | undefined;
+          try {
+            pos = await decodePosition(decoded.payload);
+          } catch {
+            pos = undefined; // malformed payload — skip, keep whatever we had
+          }
+          if (pos?.latitudeI !== undefined && pos.longitudeI !== undefined) {
+            const num = pkt.from;
+            this.nodeMap.set(num, {
+              ...this.nodeMap.get(num),
+              num,
+              position: pos,
+            });
+          }
+        } else if (decoded && decoded.portnum === PORT_ROUTING_APP) {
+          // ACK/NACK for our want_ack sends: Routing serialized in Data.payload,
+          // Data.requestId = the original packet id we sent
+          let routing: Proto.Mesh.Routing | undefined;
+          try {
+            routing = await decodeRouting(decoded.payload);
+          } catch {
+            routing = undefined; // malformed payload — skip
+          }
+          if (routing?.variant.case === 'errorReason' && decoded.requestId) {
+            const rec = this.pendingTx.get(decoded.requestId);
+            if (rec) {
+              const reason = routing.variant.value;
+              if (reason === 0)
+                rec.status = 'delivered'; // Routing_Error.NONE
+              else {
+                rec.status = 'failed';
+                rec.ackError = await describeRoutingError(reason);
+              }
+              this.pendingTx.delete(decoded.requestId);
+            }
+          }
        }
        break;
      }
Author	SHA1	Message	Date
kamilkrzywda	b31fb35464	MCP server at POST /mcp (official SDK, stateless Streamable HTTP) (#11 ) CI / build + unit (push) Successful in 1m6s Details	2026-09-24 20:39:45 +02:00
kamilkrzywda	108aa400d3	Publish on 'test' channel (index 3) by default (#10 ) CI / build + unit (push) Successful in 34s Details	2026-09-24 19:44:11 +02:00
kamilkrzywda	f640f6658c	Send to by node name or broadcast sentinel (GET-free resolution via node DB) (#9 ) CI / build + unit (push) Successful in 33s Details	2026-09-24 16:47:51 +02:00
kamilkrzywda	57ad27d66f	Message history with delivery tracking (GET /api/messages) (#8 ) CI / build + unit (push) Successful in 32s Details	2026-09-24 16:19:32 +02:00
kamilkrzywda	5292303786	Node database: collect nodes during sync, expose GET /api/nodes (#7 ) CI / build + unit (push) Successful in 39s Details	2026-09-24 15:37:03 +02:00