Skip to content
Back to search

qnx-agent-bridge

MCP server that exposes a live QNX 8.0 target to an AI agent, read-only

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/abhinavshukla152005-beep--qnx-agent-bridge/badge.svg)](/listings/abhinavshukla152005-beep--qnx-agent-bridge)

HTML

<a href="/listings/abhinavshukla152005-beep--qnx-agent-bridge"><img src="/api/listings/abhinavshukla152005-beep--qnx-agent-bridge/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 140 lines
  1. # QNX Agent Bridge
  2. An MCP server that gives an LLM agent read-only visibility into a running
  3. QNX 8.0 target: process table, per-thread state, process argv and the `slog2`
  4. system log.
  5. Built for the **QNX Global Hackathon 2026**, category *Developer Tooling &
  6. Host Tools*: a host-side tool that supports software targeting QNX 8.0.
  7. ## Why
  8. Debugging an embedded target is still a human reading terminal output. The
  9. bridge turns the same QNX utilities an engineer would run by hand (`pidin`,
  10. `slog2info`, `/proc/<pid>/cmdline`) into structured MCP tools, so an agent can
  11. answer "which thread missed its deadline" without a person copy-pasting
  12. `pidin` output.
  13. Everything the server can do is read-only. Each tool maps to one fixed utility
  14. invocation; there is no shell, no user-supplied command, and no write path to
  15. the target.
  16. ## Architecture
  17. ```
  18. agent --stdio JSON-RPC--> server.py --ssh--> QNX 8.0 guest (QEMU or board)
  19. pidin / slog2info / procfs
  20. ```
  21. ## Tools
  22. | Tool | Backing command |
  23. | --- | --- |
  24. | `qnx_list_processes` | `pidin -F "%a\|%N\|%J\|%T\|%p"` |
  25. | `qnx_process_detail` | `pidin -p <pid> -F "%a\|%b\|%N\|%J\|%B\|%p"`, `/proc/<pid>/cmdline` |
  26. | `qnx_system_log` | `slog2info` (buffered dump; severity filtered in the bridge) |
  27. | `qnx_system_info` | `uname -a`, process count from `pidin` |
  28. The `%p` field carries priority and scheduling policy together (`16r`), so the
  29. parser splits it into `priority: 16`, `policy: "RR"`.
  30. `slog2info` is run without `-w`: `-w` streams new messages and never exits, which
  31. would hang the tool call. Severity filtering happens in the bridge, because
  32. `slog2info -s` only prints the numeric level rather than filtering on it.
  33. ## Run
  34. Mock target (no QNX licence needed):
  35. ```sh
  36. python server.py --mock
  37. ```
  38. Live target over SSH:
  39. ```sh
  40. python server.py --host=127.0.0.1 --port=2222 --user=qnx
  41. ```
  42. Live target over its serial console (no sshd required):
  43. ```sh
  44. python server.py --serial="bash qemu/run-qnx.sh ~/qnx800/images/qemu/qemu"
  45. ```
  46. Smoke test (covers both the mock and a scripted serial console):
  47. ```sh
  48. python tests/smoke.py
  49. ```
  50. Demo client — drives the server like an agent and prints a readable summary:
  51. ```sh
  52. python tests/demo_client.py --mock
  53. ```
  54. ```
  55. target QNX qemu-target 8.0.0 2026/04/11-12:00:00EDT x86pc x86_64
  56. processes 5
  57. process table
  58. pid threads prio policy state name
  59. 1 1 0 FIFO READY procnto-smp-instr
  60. 8194 3 10 FIFO RECEIVE slogger2
  61. 12290 1 10 FIFO RECEIVE devc-pty
  62. 16387 2 21 FIFO RECEIVE io-pkt-v6-hc
  63. 24580 4 16 RR RUNNING qnx-agent-demo
  64. qnx-agent-demo (pid 24580)
  65. argv qnx-agent-demo --watch /sensors
  66. thread 1: RECEIVE blocked on MsgReceive prio 16 RR
  67. thread 2: READY prio 16 RR
  68. thread 3: NANOSLEEP blocked on nanosleep prio 10 FIFO
  69. thread 4: RUNNING prio 16 RR
  70. system log (2 at warning or worse)
  71. Jan 12 10:41:12 24580 WARNING agent-demo: thread 3 blocked on MsgReceive
  72. Jan 12 10:41:15 24580 ERROR agent-demo: watchdog deadline missed
  73. ```
  74. ## Booting the QNX target
  75. `qemu/install-sdp.sh` installs QNX Software Center and the 8.0 baseline
  76. headlessly on Windows. It prompts for the myQNX password (or reads
  77. `MYQNX_USER` / `MYQNX_PASSWORD`), then lists the packages that match `qnx800`
  78. and `qemu`; re-run with `--install` to add the baseline and the Quick Start
  79. image.
  80. The account needs the QNX Everywhere licence accepted and an SDP 8.0 key
  81. deployed to it before the toolchain is visible. Until then the CLI reports
  82. `Cannot read the array length because "allrepos" is null`, which the script
  83. turns into a pointer back at the License Manager. Its workspace and install
  84. directories default to `C:\qnxws` and `C:\qnx800` because the CLI rejects
  85. paths containing spaces, and `C:\Users\<name>` has one.
  86. The QNX Everywhere Quick Start Target Image ships as the
  87. `com.qnx.qnx800.quickstart.qemu` package in QNX Software Center. Its own launch
  88. path assumes a Linux host (KVM, bridged networking, `/dev/urandom`), so
  89. `qemu/run-qnx.sh` boots the same image on Windows with WHPX (falling back to
  90. TCG), user-mode networking and a builtin RNG:
  91. ```sh
  92. ./qemu/run-qnx.sh ~/qnx800/images/qemu/qemu
  93. ```
  94. It forwards guest port 22 to host port 2222, which is the address the bridge's
  95. `SSHTarget` expects. The VM is headless: the QNX serial console attaches to the
  96. terminal, and `Ctrl-A x` exits.
  97. The image's documented interface is the serial console, not SSH, so the bridge
  98. also ships a `SerialTarget`: it starts the console command, logs in, and runs
  99. each tool by appending an `echo` sentinel to the command line so output can be
  100. delimited without a prompt parser.
  101. ## Status
  102. The MCP layer and the QNX command mapping are implemented and covered by the
  103. smoke test against a mock target. Wiring to a live QNX 8.0 instance needs the
  104. QNX SDP 8.0 download from QNX Everywhere (free, non-commercial, requires a
  105. myQNX account) and the QEMU image package.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.