Skip to content
Back to search

dsh-rustxng

DeepSeek Harness plugin: answer the built-in web_search with your own RustXNG metasearch instance (Windows / macOS / Linux)

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/kgmkm--dsh-rustxng/badge.svg)](/listings/kgmkm--dsh-rustxng)

HTML

<a href="/listings/kgmkm--dsh-rustxng"><img src="/api/listings/kgmkm--dsh-rustxng/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

# registry install (recommended)
dsh plugin --profile web add dsh-rustxng

# or from a checkout of this repository
git clone https://github.com/<owner>/dsh-rustxng.git
# then: Plugin Manager → install bundle → the checkout directory

Installing from a checkout **links** the directory, so Node resolves the plugin's real path (`.../dsh-rustxng`). The plugin copes with that: if `@deepseek-ai/schemastery` is not resolvable from there, it loads the schema builder through the running Harness's own entry point instead of silently dropping the schema.

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 · 388 lines
  1. # dsh-rustxng
  2. Use a self-hosted [RustXNG](https://github.com/sahenjp/RustXNG) instance from
  3. [DeepSeek Harness](https://github.com/deepseek-ai/deepseek-harness) — and answer the
  4. built-in **`web_search`** with it.
  5. RustXNG is a SearXNG-compatible metasearch engine written in Rust: one query fans out to
  6. over a hundred search engines (119 enabled in 0.28's default `standard` profile),
  7. deduplicates the results and returns them without ads or tracking. This
  8. plugin connects DSH to a RustXNG you run yourself (Windows, macOS or Linux)
  9. and adds:
  10. | Contribution | What it gives you |
  11. | :--- | :--- |
  12. | **Search provider** | A `rustxng` provider on the web seam. Point `web.searchProvider` at it and the built-in `web_search` is answered by your instance — no DeepSeek search API key involved. |
  13. | **Settings card** | A card in **Plugins** with two live switches and the instance URL. No restart, no hand-edited YAML. |
  14. | **Tools** | `rustxng_search` (engine, category, language and time-range scoped) and `rustxng_status` (reachability, version, engine count, provider state). |
  15. | **Fetch provider** (optional) | A charset-aware `web_fetch`: resolves BOM → HTTP header → `<meta charset>` before decoding, so Shift_JIS pages that declare their encoding only in `<meta>` stop coming back as `�`. Does not use RustXNG. |
  16. | **Process supervision** (optional) | Start the binary when the instance does not answer, and stop it again after an idle timeout (default 60 min, editable in the card). Only a process this plugin started is stopped — this is also the only thing that cleans up after a Harness that was killed. |
  17. | **Binary fetcher** | `node scripts/install-binary.mjs` downloads and verifies the right release binary for your OS and CPU. |
  18. Nothing in DSH is patched: the plugin uses the documented `ctx.web.registerSearchProvider()`
  19. API and the ordinary `web.searchProvider` settings field, so it survives Harness upgrades.
  20. ## Do you need this plugin at all?
  21. **If you use rustdsh (`rdsh`), let rustdsh handle search.** Since v0.15.0 it checks whether
  22. rustxng / `SEARXNG_URL` actually answers at start-up and, only when it does, passes
  23. `DSH_WEB_SEARCH_PROVIDER=rdsh-rustxng` to the delegated DSH so the bundled
  24. `rdsh-web-search-searxng` provider takes `web_search` over (`web_search_bridge`, on by
  25. default).
  26. | Your situation | Use |
  27. | :--- | :--- |
  28. | You start **DSH through rdsh** (`rdsh tui`, `rdsh web`, …) and want `web_search` to hit a local engine | **rustdsh's own bridge.** Nothing to configure; stop it with `rdsh features off web_search_bridge` |
  29. | You start **`dsh` directly** (desktop app, systemd, …) and want `web_search` replaced | **This plugin.** rdsh only injects into the children it launches, so a plain `dsh` boot is untouched |
  30. | You need **`web_fetch` to stop garbling** pages whose charset is declared only in `<meta>` | **This plugin** (`webFetch.enabled`) — rustdsh's bridge is search only |
  31. | You want the agent to call RustXNG **as a tool** (`rustxng_search` / `rustxng_status`) | **This plugin.** |
  32. | You want the binary **downloaded, started and idle-stopped** for you | **This plugin** (`autoStart`); rustdsh never downloads anything on behalf of the bridge |
  33. | You use both and want **one instance for both** | Point rdsh at this plugin's instance: `RUSTXNG_URL=http://127.0.0.1:8888` |
  34. **Give search to exactly one of them.** With both, two providers are registered (`rustxng` and
  35. `rdsh-rustxng`) and two sidecars can end up running. Letting rustdsh own it means turning this
  36. plugin's `webSearch.enabled` off; letting this plugin own it means
  37. `rdsh features off web_search_bridge` (or `RDSH_WEB_SEARCH_BRIDGE=0`).
  38. **Delegating search to rustdsh does not change `web_fetch`.** Use this plugin's
  39. `webFetch.enabled` when you want the fetch side replaced too. See
  40. [If you also use rdsh](#if-you-also-use-rdsh) for sharing one instance and one binary.
  41. ---
  42. ## Requirements
  43. - DeepSeek Harness `>= 0.2.0-rc.2 < 0.3.0` (host `tools`, `web` and `settings` services).
  44. Verified on **0.2.0-rc.2** and **0.2.1-rc.2**; see [docs/PLATFORMS.md](docs/PLATFORMS.md#dsh-versions).
  45. - Node.js 20+ (the plugin uses the global `fetch`)
  46. - A running RustXNG instance — see below
  47. ## 1. Get RustXNG
  48. **Easiest:** let the plugin fetch a release binary.
  49. ```bash
  50. node scripts/install-binary.mjs # into $DSH_HOME/bin (or ~/.dsh/bin)
  51. node scripts/install-binary.mjs --dir ./bin --musl # Linux without glibc
  52. ```
  53. The script picks the asset for your platform, verifies the published SHA-256, and prints
  54. the start command.
  55. **Or** download it yourself from the
  56. [releases page](https://github.com/sahenjp/RustXNG/releases/latest):
  57. | Platform | Asset |
  58. | :--- | :--- |
  59. | Windows x64 | `rustxng-v<ver>-x86_64-pc-windows-msvc.exe` |
  60. | macOS arm64 | `rustxng-v<ver>-aarch64-apple-darwin` |
  61. | macOS x64 | `rustxng-v<ver>-x86_64-apple-darwin` |
  62. | Linux x64 (glibc) | `rustxng-v<ver>-x86_64-unknown-linux-gnu` |
  63. | Linux x64 (musl) | `rustxng-v<ver>-x86_64-unknown-linux-musl` |
  64. Start it:
  65. ```bash
  66. rustxng --port 8888 # listens on 127.0.0.1:8888 by default
  67. curl 'http://127.0.0.1:8888/healthz' # → OK
  68. ```
  69. RustXNG serves its own search UI at <http://127.0.0.1:8888/>; this plugin does not replace
  70. that page, it just consumes the same JSON API.
  71. ## 2. Install the plugin
  72. ```bash
  73. # registry install (recommended)
  74. dsh plugin --profile web add dsh-rustxng
  75. # or from a checkout of this repository
  76. git clone https://github.com/<owner>/dsh-rustxng.git
  77. # then: Plugin Manager → install bundle → the checkout directory
  78. ```
  79. Installing from a checkout **links** the directory, so Node resolves the plugin's real path
  80. (`.../dsh-rustxng`). The plugin copes with that: if `@deepseek-ai/schemastery` is not
  81. resolvable from there, it loads the schema builder through the running Harness's own entry
  82. point instead of silently dropping the schema.
  83. ## 3. Turn it on
  84. Open **Plugins → RustXNG** and switch on *Use RustXNG for web_search*. Or set it in your
  85. profile patch (`~/.dsh/profiles/<profile>/cordis.patch.yml`):
  86. ```yaml
  87. - id: dsh-rustxng
  88. config:
  89. baseUrl: http://127.0.0.1:8888
  90. webSearch:
  91. enabled: true
  92. autoSelect: true
  93. ```
  94. From then on `web_search` is answered by RustXNG. The `enabled` and `autoSelect` switches
  95. and the instance URL are *volatile*: the settings card changes them live, and turning the
  96. feature off hands `web.searchProvider` back to whatever it was before.
  97. ## Configuration
  98. | Key | Default | Meaning |
  99. | :--- | :--- | :--- |
  100. | `enabled` | `true` | Master switch; `false` unloads the tools and unregisters the provider. |
  101. | `baseUrl` | `http://127.0.0.1:8888` | Where RustXNG listens. Volatile (editable in the card). |
  102. | `timeoutMs` | `20000` | Timeout for one search. |
  103. | `defaultLimit` | `12` | Sources handed to `web_search` (1–50). |
  104. | `language` | `''` | Search language (`ja`, `en`, …); empty = instance default. |
  105. | `timeRange` | `''` | `day` / `week` / `month` / `year`; empty = no filter. |
  106. | `safeSearch` | `-1` | `-1` = instance default, else `0` / `1` / `2`. |
  107. | `categories` | `[]` | Category filters applied to every search (`general`, `it`, …). |
  108. | `exposeTools` | `true` | Register `rustxng_search` / `rustxng_status`. |
  109. | `webSearch.enabled` | `false` | Replace the built-in `web_search`. Volatile. |
  110. | `webSearch.autoSelect` | `true` | Write `web.searchProvider = 'rustxng'` for you. Volatile. |
  111. | `webFetch.enabled` | `false` | Replace `web_fetch` with the charset-aware fetcher. Volatile. |
  112. | `webFetch.autoSelect` | `true` | Write `web.fetchProvider = 'rustxng-http'` for you. Volatile. |
  113. | `autoStart.enabled` | `true` (shipped patch) | Start the binary when the instance does not answer. Volatile. Off in the schema; the bundle turns it on. |
  114. | `autoStart.binaryPath` | `''` | Explicit binary path; empty searches `$DSH_HOME/bin`, `~/.local/bin` and `PATH`. |
  115. | `autoStart.idleMinutes` | `60` | Stop the started process after this many minutes without a search (`0` = never). Volatile. |
  116. | `autoStart.download` | `true` | Fetch a release binary into `$DSH_HOME/bin` when none is found (SHA-256 verified). |
  117. | `autoStart.version` | `''` | Pin the download to one release (e.g. `0.20.1`). Empty follows the latest release. |
  118. | `debug` | `false` | Log each provider decision. |
  119. ## Optional: charset-aware fetch
  120. The built-in HTTP fetcher reads `charset` from the `Content-Type` header only. Many Japanese
  121. sites (JRA, municipal sites, older corporate sites) send `text/html` with the encoding
  122. declared *only* in `<meta charset="Shift_JIS">`, so the page arrives as replacement
  123. characters. Turning on `webFetch.enabled` registers a small provider that resolves
  124. **BOM → HTTP header → `<meta>`** and decodes with `TextDecoder` (Node ships the legacy
  125. encodings), with a size cap and the same html/text classification.
  126. ```yaml
  127. - id: dsh-rustxng
  128. config:
  129. webFetch:
  130. enabled: true
  131. autoSelect: true
  132. - id: web
  133. config:
  134. searchProvider: rustxng
  135. fetchProvider: rustxng-http # replaces the whole row, so list both fields
  136. ```
  137. It does not touch RustXNG: it is plain HTTP plus decoding. Leave it off if you prefer the
  138. built-in fetcher.
  139. > **On hosts that hide the `web` settings row** (DSH 0.2.0-rc.2 publishes only entries with a
  140. > volatile field), `autoSelect` cannot write the selection — it needs the same context rules
  141. > as the search side. Set both fields in the profile patch, exactly as above; the card's
  142. > switches then still control whether the plugin is active. `rustxng_status` says so:
  143. > `Fetch provider: enabled, but the selection was not written (…)`.
  144. ## First run: nothing is installed yet
  145. The plugin does not bundle the binary and ships with the replacement **off**, so a fresh
  146. install answers like this until one of the two paths below is taken:
  147. ```
  148. RustXNG could not be reached: fetch failed (connect ECONNREFUSED 127.0.0.1:8888)
  149. Start it (for example `rustxng --port 8888`), or point the `baseUrl` setting at your instance.
  150. ```
  151. **Easiest:** the shipped bundle already has *Start RustXNG automatically* on, so the first search fetches and starts the instance; nothing to click. On the next start it
  152. downloads the matching release (SHA-256 verified, ~22-27 MB) into `$DSH_HOME/bin`, starts it,
  153. and stops it again after the idle timeout. Nothing else to install.
  154. **Manual:** `npx dsh-rustxng-fetch` drops the binary in the same place; run it yourself, or
  155. wire it into launchd / systemd and leave auto-start off.
  156. The download never depends on GitHub's API: if the "latest release" lookup is rate-limited it
  157. falls back to a pinned version, and `autoStart.binaryPath` (or `--version`) needs no lookup at
  158. all.
  159. ## About the automatic selection
  160. `autoSelect` writes `web.searchProvider = 'rustxng'` for you, but a plugin cannot do that
  161. while it is mounting: the loader runs `apply()` inside its own transaction and rejects the
  162. settings write with *"HMR transactions cannot be nested"*. 0.3.0 therefore retries the write
  163. from a context that is allowed to write — a tool call (`rustxng_status` / `rustxng_search`) or
  164. a live settings change from the card — and reports the outcome in `rustxng_status`.
  165. If it still cannot be written (for example on a host that refuses plugin-initiated writes),
  166. set the field once by hand; it is remembered:
  167. ```yaml
  168. - id: web
  169. config:
  170. searchProvider: rustxng
  171. fetchProvider: http
  172. ```
  173. ## Optional: start and stop the instance
  174. If you would rather not run RustXNG as a service, let the plugin own the process:
  175. ```yaml
  176. - id: dsh-rustxng
  177. config:
  178. autoStart:
  179. enabled: true
  180. binaryPath: /home/you/.dsh/bin/rustxng # empty = $DSH_HOME/bin, ~/.local/bin, PATH
  181. idleMinutes: 60 # 0 = keep it until DSH unloads the plugin
  182. ```
  183. Behaviour:
  184. - It starts the binary only when the instance does not already answer, and waits for
  185. `/healthz` before using it. Concurrent callers share one attempt, so two starts cannot race
  186. for the port.
  187. - It **stops only a process it started** — a systemd unit or a manually started instance is
  188. never touched.
  189. - On plugin unload (a normal DSH shutdown) it stops the process immediately.
  190. - A Harness that is killed never runs that cleanup, so the **idle timeout** finishes the job:
  191. after `idleMinutes` without a search the process is stopped, and the next search starts it
  192. again. Reachability probes do not count as activity.
  193. - `rustxng_status` reports `Auto-start: on — managed (pid …), idle timeout 60 min (12 min idle)`
  194. and `Selection: web.searchProvider: rustxng (this plugin), web.fetchProvider: http`.
  195. - The `rustxng_search` tool starts the instance too, so a tool-only setup (no replacement of
  196. `web_search`) also works from the first call. `rustxng_status` never starts it — it only
  197. reports.
  198. - **Which version is downloaded:** always the latest release. The tag is resolved through
  199. GitHub's release API and, when that is rate-limited, through the `/releases/latest` redirect;
  200. `PINNED_VERSION` in `lib/install-binary.js` is only the offline fallback, and it holds the last
  201. release this plugin was verified against. Set `autoStart.version` for a reproducible version.
  202. - **The environment is inherited:** the child sees your environment, so `RUSTXNG_PROFILE`
  203. (`standard` / `full` / `clean`, 0.28+) and `SEARXNG_SETTINGS_PATH` also apply to a managed
  204. instance. This plugin passes no `--profile`, so the default stays `standard`.
  205. - **What leaves the machine:** with the defaults, RustXNG asks the engines directly from your
  206. host and needs no API key. 0.28 adds opt-in DeepSeek backends (a `deepseek` search engine and
  207. `[fetch] provider = "deepseek"`), both off by default and requiring `DEEPSEEK_API_KEY`; once
  208. enabled, queries (search) or page URLs (fetch) are sent to DeepSeek, so the "no tracking" line
  209. above describes the default configuration only.
  210. - **How it stops:** four paths, because none of them covers everything.
  211. 1. the plugin's disposer, when DSH unloads the plugin;
  212. 2. `process.on('exit')`, for a normal exit;
  213. 3. `SIGTERM` / `SIGINT` / `SIGHUP` handlers, because a signal ends Node **without** emitting
  214. `exit`. These stop the child and then re-raise the signal with the default disposition —
  215. only when nothing else is listening, so a Harness that shuts itself down keeps control;
  216. 4. the instance's own idle timer: the spawned process is given `RUSTXNG_IDLE_TIMEOUT`
  217. (the same number of minutes), so builds that support it exit by themselves.
  218. Path 4 is the only one that survives a `SIGKILL`ed host, which is why it is set whenever
  219. `idleMinutes` is above 0. It needs a build that understands the variable — verified with
  220. RustXNG 0.24.0; 0.4.x ignores it, and the plugin's own watchdog (path 3's timer, 30 s
  221. checks) covers those. With `idleMinutes: 0` nothing is scheduled at all, so a `SIGKILL`ed
  222. host leaves the instance running — the trade-off of asking for "never stop it". Under a
  223. desktop app or a
  224. systemd unit the child also shares the host's cgroup and may disappear with it first — same
  225. outcome, but do not rely on that in a plain shell.
  226. Set `idleMinutes: 0` when using a service manager instead; the two mechanisms are independent.
  227. ## Tools
  228. ```jsonc
  229. // rustxng_search
  230. { "query": "rust async runtime", "limit": 8, "engine": "arxiv", "time_range": "year" }
  231. { "query": "東京 天気", "category": "news", "language": "ja" }
  232. ```
  233. `rustxng_status` reports whether the instance answers, its version, how many engines are
  234. enabled, whether the provider is registered, and whether `web.searchProvider` points at it —
  235. run it first when a search fails.
  236. ## If you also use rdsh
  237. rustdsh touches RustXNG in two places, and they are not the same thing:
  238. - **`rdsh search-web --engine rustxng`** — a shell command for rdsh's own search
  239. (`SEARXNG_URL` → `RUSTXNG_URL` → a local `rustxng` → `127.0.0.1:8888`);
  240. `rdsh rustxng install` puts the binary in `~/.local/bin`.
  241. - **`web_search_bridge`** (v0.15.0+, on by default) — injects
  242. `DSH_WEB_SEARCH_PROVIDER=rdsh-rustxng` into a DSH that rdsh launches, so the bundled
  243. `rdsh-web-search-searxng` provider serves `web_search`. A plain `dsh` boot sees none of it.
  244. So search is already handled in a rustdsh-driven session: leave this plugin's
  245. `webSearch.enabled` off there. Turn it on — and stop the bridge with
  246. `rdsh features off web_search_bridge` — when you want the Harness-side replacement from a
  247. direct `dsh` start, the model-facing tools, or managed download/start/idle-stop.
  248. `web_fetch` is outside the bridge either way. If you run both, one instance can serve both:
  249. - point rdsh at the plugin's instance with `RUSTXNG_URL=http://127.0.0.1:8888`, or
  250. - let the plugin reuse rdsh's binary: the search order is `autoStart.binaryPath` →
  251. `$DSH_HOME/bin` → `~/.local/bin` → `PATH`, and `rustxng_status` prints which file is
  252. actually running (`Auto-start: on — managed (pid …) [rustxng]`).
  253. Set `autoStart.binaryPath` when you have several builds and want a specific one.
  254. ## Platform support
  255. | Platform | Status |
  256. | :--- | :--- |
  257. | Windows 10/11 x64 | Verified: release binary + this plugin (search, provider replacement, settings card) on DSH 0.2.1-rc.2 |
  258. | Linux x64 (glibc / musl) | Verified on a standalone Ubuntu 26.04 server (DSH 0.2.0-rc.2: replacement + card) and on WSL2 (both release builds 12/12) |
  259. | macOS arm64 / x64 | Verified on macOS 26.6.2 / M1 Max with DSH 0.2.1-rc.3 (Electron desktop app): 0.1.3 answered rustxng_search in ~3 s across 6-10 engines; 0.2.1 adds first-run download and auto-start |
  260. See [docs/PLATFORMS.md](docs/PLATFORMS.md) for how each platform is expected to be
  261. verified, binary placement, and the platform-specific notes (PATH, service managers, WSL,
  262. musl).
  263. ## Upstream versions
  264. This plugin talks only to RustXNG's SearXNG-compatible surface (`/healthz`, `/search?format=json`,
  265. `/config`, `--bind`/`--port`/`RUSTXNG_IDLE_TIMEOUT`) and does not check a version, so a new
  266. upstream release is normally a no-op here. The rules for when it is not — the two verification
  267. tiers, what `PINNED_VERSION` means, and the five upstream changes that trigger a smoke run — are
  268. in [docs/UPSTREAM.md](docs/UPSTREAM.md), together with a log of the changes already handled
  269. (the default port moving to 29483, and the Google engine removals).
  270. ## Troubleshooting
  271. | Symptom | Fix |
  272. | :--- | :--- |
  273. | `RustXNG is not answering at …` | Start the instance, or fix `baseUrl` in the card. `rustxng_status` shows the probe error. |
  274. | `web_search` still fails with a DeepSeek 401 | The provider is not selected: check the card's first switch, or `web.searchProvider` on the official *Web search* page. On DSH 0.2.0-rc.2 that field is not writable from a plugin — set it in the profile patch (see above) or with `DSH_WEB_SEARCH_PROVIDER=rustxng`. |
  275. | Card missing from Plugins | The plugin row is not active — check Plugin Manager, and that the DSH version matches `dsh.compatibility`. On a linked checkout the schema comes through the Harness installation: `rustxng_status` prints `Config schema: loaded via …` or the resolution error. 0.1.2 resolves symlinked launchers such as `<prefix>/bin/dsh`. |
  276. | `rustxng_status` says `Replace web_search: no (default)` although it is on | Fixed in 0.1.2 (live config values were compared as primitives). |
  277. | `Wanted to register a provider but web is missing` | The profile has no `@deepseek-ai/dsh-web`; this plugin needs it for the replacement (the tools still work). |
  278. | Results look thin | A few engines rate-limit per IP; `rustxng_status` / RustXNG's `/stats` show which are suspended. `!engine query` still works. |
  279. | The log says `skipped engine=google … unknown engine type` | RustXNG 0.27 removed the Google engines, and an older `settings.toml` still lists them. Start-up continues with the remaining engines; delete those `[[engines]]` blocks when convenient. |
  280. | A hand-started binary answers on 29483, not 8888 | RustXNG 0.27+ defaults to 29483. Start it with `--port 8888` to match this plugin's default `baseUrl`, or set `baseUrl` to `http://127.0.0.1:29483`. Managed starts are unaffected — the plugin passes `--port` itself. |
  281. | A Japanese page comes back as `����` / `�N` | The site declares its encoding only in `<meta>`. Turn on `webFetch.enabled` (see [Optional: charset-aware fetch](#optional-charset-aware-fetch)), or read it with `curl … \| iconv -f SHIFT_JIS -t UTF-8`. |
  282. ## Development
  283. ```bash
  284. node tests/smoke.mjs # payload normalisation + platform mapping (+ live search if an instance answers)
  285. node tests/apply.test.mjs # host half against a stub instance: provider gate, selection, tools, live values
  286. node tests/resolve.test.mjs # host-package resolution through a symlinked launcher (Linux npm-global layout)
  287. node tests/tools.test.mjs # the search tool triggers auto-start; status stays read-only
  288. node tests/install.test.mjs # release asset naming, SHA-256 verification, the pinned fallback
  289. node tests/process.test.mjs # idle rule, binary discovery, a real start/health/idle-stop cycle
  290. node tests/signal.test.mjs # SIGTERM takes the child with it (POSIX; skips on Windows)
  291. node scripts/contract-smoke.mjs # the four upstream surfaces against a release (see docs/UPSTREAM.md)
  292. ```
  293. `apply.test.mjs` and `resolve.test.mjs` need no running instance and no network.
  294. Layout:
  295. ```
  296. index.js host plugin: Config, provider + tools wiring, selection hand-over,
  297. symlink-aware host-package resolution
  298. lib/rustxng-client.js HTTP client: query building, payload normalisation, timeouts
  299. lib/web-provider.js the `rustxng` seam provider and the web.searchProvider hand-over
  300. lib/fetch-provider.js optional charset-aware fetch provider (BOM → header → <meta>)
  301. lib/tools.js rustxng_search / rustxng_status
  302. lib/client.js settings card (Plugins → RustXNG)
  303. scripts/install-binary.mjs cross-platform release downloader with SHA-256 check
  304. scripts/verify-linux.sh 12-item instance verification for POSIX hosts
  305. ```
  306. ## License and attribution
  307. MIT — see [LICENSE](LICENSE).
  308. RustXNG itself is **AGPL-3.0-or-later** and is *not* bundled here: the plugin talks to a
  309. separate process over HTTP, and `scripts/install-binary.mjs` downloads it from its own
  310. release page. If you redistribute a modified RustXNG, AGPL §13 applies to that work, not to
  311. this plugin.

Ratings and comments

Sign in to rate this skill.

Sign in

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