@nexusbloom/cli 0.3.4 → 0.8.0

package/README.md

@@ -11,23 +11,33 @@ npm install -g @nexusbloom/cli
 ## Quick Start
 
 ```bash
-# List available tools (interactive pagination, 10 per page)
+# List available tools (interactive pagination, 20 per page)
 nxb list
 
-# Search with pagination
+# Search with pagination — every long list has a search option
 nxb list -s ssl
+nxb search "ssl"
+nxb abbr -s ssl
+nxb cache list -s json
+
+# Bare `nxb run` shows the tool list (and prompts to search when large)
+nxb run
+nxb run -s gradient
+
+# Build a pipeline interactively, wiring against real tool output
+nxb pipe --build
+
+# Check whether a tool's declared output_schema matches what it returns
+nxb doctor data-generator
+
+# Exits non-zero on drift, so it works as a CI gate
+nxb doctor data-generator || exit 1
 
 # Non-interactive mode (single page dump)
 nxb list --no-interactive
 
 # JSON output (all commands)
 nxb --json list
-
-# Show tool abbreviations (paginated)
-nxb abbr
-
-# Search tools
-nxb search "ssl"
 ```
 
 ## Running Tools
@@ -48,6 +58,9 @@ nxb run ssl-certificate-checker domain=example.com --local
 # Interactive runner (select tool → pick inputs → auto-build command)
 nxb run
 
+# Narrow the picker first
+nxb run -s gradient
+
 # Pipe stdin through a tool
 echo '{"domain":"example.com"}' | nxb transform ssl-certificate-checker
 ```
@@ -61,53 +74,175 @@ nxb info ssl-certificate-checker
 # Show abbreviations (useful for quick tool references)
 nxb abbr
 nxb abbr ip                  # Filter abbreviations by query
+nxb abbr -s ip               # Same, explicit flag
 
 # Interactive pagination for lists
 nxb list                      # Browse pages with prev / next / done
-nxb list -s validate           # Filtered + paginated
+nxb list -s validate          # Filtered + paginated
+nxb list --refresh            # Bypass cache, re-fetch the catalogue
+nxb list --offline            # Cache only, no network
 
-# Search (full-text across slugs, names, descriptions, tags)
+# Search (full-text across slugs, names, descriptions, categories, tags)
 nxb search "validate"
 ```
 
+Search matches case-insensitively across slug, name, description, category and
+tags. Multi-word queries narrow the result set — `nxb search "json format"`
+matches tools mentioning **both** words.
+
 ## Configuration
 
 ```bash
-# Set config values
-nxb config set key YOUR_KEY               # Set an API key
-nxb config set default-tool ssl-scanner    # Set default tool
+# Set config values (secrets are stored but never echoed back)
+nxb config set key YOUR_KEY
+nxb config set supabaseKey YOUR_SUPABASE_ANON_KEY
+nxb config set telemetry false
+
+# Remove a stored value (e.g. rotate away an old API key)
+nxb config unset key
 
-# Get config values
-nxb config get key                         # Get specific value
-nxb config get                             # List all config values
+# Get config values — secret values are always redacted
+nxb config get
+nxb config get key
 
 # Environment variables (alternative to config)
 #   NEXUSBLOOM_API_KEY        — API key (can also use `--key`)
 #   NEXUSBLOOM_API_URL        — API base URL (default: https://nexusbloom.dev)
 #   NEXUSBLOOM_SUPABASE_URL   — Supabase URL (for fallback fetching)
-#   NEXUSBLOOM_SUPABASE_ANON_KEY — Supabase anon key (for fallback fetching)
+#   NEXUSBLOOM_SUPABASE_ANON_KEY — Supabase anon key (enables the fallback fetcher)
+#   NEXUSBLOOM_TELEMETRY      — set to `false` to disable the run counter
+#   NXB_NO_INTERACTIVE        — force non-interactive output
 ```
 
-## Local Tool Cache
+No credentials are bundled with the CLI. The Supabase fallback stays disabled
+until you supply your own key.
+
+## Pipelines
+
+Chain tools by piping one tool's output into the next tool's input.
 
 ```bash
-# List cached tools
-nxb cache list
+# Frequency -> how many rows to generate -> encode the first one
+nxb pipe 'frequency-analyzer text=@in | data-generator count=$total_words format=json | base64-tool text=$data|first.id|str action=encode'
+
+# Read the pipeline's input from stdin
+echo "some text to analyse" | nxb pipe 'frequency-analyzer text=@in | base64-tool text=$total_words|str action=encode'
+
+# Check the wiring and types without running anything
+nxb pipe --dry-run 'frequency-analyzer text=@in | data-generator count=$word_frequency format=json'
 
-# Clear the local tool cache
-nxb cache clear
+# List the available transforms
+nxb pipe --transforms
 ```
 
-## Scaffolding
+### Connections
+
+| Form | Meaning |
+|------|---------|
+| `key=value` | literal |
+| `key=@in` | the pipeline's standard input |
+| `key=$field` | a field from the previous step |
+| `key=$` | the whole previous output |
+| `key=$data[0].email` | array index + nested field |
+| `key=$text|len` | apply a transform |
+| `key=$max|int(0)` | transform with an argument |
+| `key=$data|first.email` | transform, then keep going into the result |
+| `key=$missing|default(7)` | fall back when the path is absent |
+
+A step separator is written with surrounding whitespace (` | `); a `|` inside a
+`key=$...` token is always a transform.
+
+### Type safety
+
+Conversions that cannot lose information happen silently. Conversions that can
+lose information require an explicit transform:
+
+| From → To | Behaviour |
+|-----------|-----------|
+| `integer → number` | automatic (widening) |
+| `number → integer` | requires `\|int()` |
+| `integer/number/boolean → string` | automatic |
+| `string → integer/number/boolean` | requires a cast |
+| `array → scalar` | requires `\|first()`, `\|last()`, `\|get(i)` |
+| `* → enum` | validated against the allowed values |
+
+The wiring is checked **before** anything runs, so a broken pipe is reported
+before any side effects:
 
 ```bash
-# Interactive tool creation
-nxb create
+$ nxb pipe 'frequency-analyzer text=hi | data-generator count=$word_frequency format=json'
+  ✗ step 2: frequency-analyzer.word_frequency is array but data-generator.count
+    wants integer — add |first()
+```
+
+Everything is re-checked against real values at runtime, because declared
+schemas can be wrong. `nxb doctor` finds that drift ahead of time:
 
-# Non-interactive tool creation
-nxb create --slug my-tool --name "My Tool" --desc "Does something useful"
+```bash
+$ nxb doctor some-tool
+  ! undeclared output fields: summary, meta
+  ✗ score: declared integer, actually returns string
 ```
 
+### Interactive builder
+
+`nxb pipe --build` walks you through building a pipeline. It runs each tool as
+you go and lists **what it actually returned** — including fields its schema
+never mentioned — before asking what to send onward. A browser node builder can
+only trust `output_schema`; this can execute the tool and look.
+
+```bash
+$ nxb pipe --build
+  Step 1
+  Tool     › frequency-analyzer
+   text          hello world
+   mode          words
+  ✓ ran frequency-analyzer · 12ms
+  Output
+      total_words        integer  2
+      character_frequency array   [9]
+  Send this output into another tool? yes
+  Step 2
+  frequency-analyzer → count  integer
+    ✔ data_generator...  array → integer  needs a transform
+    · set by hand
+    frequency-analyzer.total_words  integer  2
+```
+
+### Saved pipelines
+
+```bash
+nxb pipeline list
+nxb pipeline run my-pipeline
+nxb pipeline delete my-pipeline
+```
+
+Pipelines are JSON files in `~/.config/nexusbloom/pipelines/` — plain text, so
+they diff, sync and live in git. No database, no migrations.
+
+## Local Tool Cache
+
+Tool catalogues and downloaded tool source are cached on disk so `list`,
+`abbr` and `--local` runs work offline and stay fast.
+
+```bash
+nxb cache path     # show exactly where config + cache live
+nxb cache list     # list cached tools (-s to filter)
+nxb cache clear    # delete everything, including the legacy cache location
+```
+
+Locations follow the XDG spec:
+
+| What | Where |
+|------|-------|
+| Config (contains your API key) | `$XDG_CONFIG_HOME/nexusbloom/config.json` — mode `0600`, dir `0700` |
+| Tool catalogue | `$XDG_CACHE_HOME/nexusbloom/tools-list.json` |
+| Tool source | `$XDG_CACHE_HOME/nexusbloom/tools/<slug>.json` |
+
+Earlier versions cached inside the installed package directory, which meant the
+cache was wiped by every `npm update -g` and could fail on root-owned global
+installs. `nxb cache clear` removes that leftover directory too.
+
 ## JSON Input Generation
 
 ```bash
@@ -126,23 +261,98 @@ nxb json --template data-generator -s count=3 | nxb run data-generator --input @
 
 ## Options
 
-| Flag | Description |
-|------|-------------|
-| `--json` | Output results in JSON format (global flag, place before subcommand) |
-| `--no-interactive` | Disable interactive pagination for `list`/`abbr` |
+| Flag | Commands | Description |
+|------|----------|-------------|
+| `--json` | all | Output results in JSON (global — place before the subcommand) |
+| `-s, --search <query>` | `list`, `run`, `abbr` | Filter a list by name, slug, category or tags |
+| `--no-interactive` | `list`, `search`, `abbr` | Disable interactive pagination |
+| `-r, --refresh` | `list` | Bypass the catalogue cache and re-fetch |
+| `--offline` | `list` | Use only cached data, never the network |
+| `-k, --key <key>` | `run`, `transform` | API key (or `NEXUSBLOOM_API_KEY`) |
+| `-i, --input <json>` | `run` | Inline JSON input, or `@-` for stdin |
+| `-f, --file <path>` | `run` | Read input from a JSON file |
+| `--local` | `run`, `transform` | Execute `coreLogic` on this machine |
+| `--dry-run` | `pipe`, `pipeline run` | Check wiring and types without running |
+| `--remote` | `pipe`, `pipeline run` | Run every step against the API |
+| `--transforms` | `pipe` | List the available connection transforms |
+| `--build` | `pipe` | Build a pipeline interactively |
+| `-t, --template <slug>` | `json` | Generate a JSON template for a tool |
+| `-i, --interactive` | `json` | Prompt for each field |
+| `-s, --set <key=value>` | `json` | Set specific field values |
+| `-a, --add <json>` | `json` | Merge additional JSON into the output |
+
+Subcommands: `config list|set|get|unset`, `cache path|clear`,
+`pipeline list|run|delete`.
+
+Exit codes are meaningful for scripting: `0` success, `1` anything the CLI
+diagnosed — unknown tool, broken wiring, type mismatch, empty catalogue, or an
+unreachable API. `--json` puts machine-readable results on stdout and keeps
+progress, warnings and errors on stderr, so `nxb --json list | jq` is always
+safe.
 
 ## Interactive Mode Features
 
-- **Paginated browsing**: `nxb list` and `nxb abbr` show 10 items per page with prev/next navigation
+- **Paginated browsing**: `nxb list` and `nxb abbr` show 20 items per page with prev/next navigation
+- **Search-first**: any list long enough to page through offers `-s/--search`
 - **Interactive runner**: `nxb run` without a slug opens a tool selector, then prompts for each input field, then builds and executes the command
 - **Abbreviation resolution**: Tool slugs can be typed using auto-generated abbreviations (e.g. `scc` for `ssl-certificate-checker`)
+- **Script-safe**: when stdout/stdin is piped (or `CI` is set), prompts are never opened. `nxb run` prints a searchable tool list and exits instead of hanging
 
 ## Local Execution
 
-The `--local` flag fetches the tool's v2 source code from the NexusBloom API, caches it locally, and executes the `coreLogic()` function directly on your machine. This is useful for:
+The `--local` flag fetches the tool's v2 source code from the NexusBloom API,
+caches it locally, and executes the `coreLogic()` function directly on your
+machine. This is useful for:
 
 - Offline use (after initial fetch)
 - Faster repeated execution (cached)
 - Privacy-sensitive inputs (data stays on your machine)
 
-Use `nxb cache clear` to clear the local source cache.
+****This executes JavaScript downloaded from the network.** Tool code runs in a
+disposable child process with a hard `SIGKILL` deadline, so a tool that loops
+forever, allocates without bound, or calls `process.exit()` cannot take the CLI
+with it. Run `nxb cache clear` to remove downloaded source and stop trusting it.
+
+Note that this is isolation, not a security sandbox — the child runs with your
+user's permissions. Prefer remote execution for tools you do not trust.
+
+A tool's `coreLogic` must be **self-contained**: local execution strips module
+syntax and evaluates the function in isolation, so `import` statements are
+removed rather than resolved. Relative imports like `import { helper } from
+"./util"` will fail at runtime. `export async function coreLogic`,
+`export const coreLogic = async () => {}` and plain `function coreLogic` are all
+supported.
+
+## Development
+
+```bash
+npm test              # 500+ tests, no network required
+npm run test:coverage # with a coverage report
+npm run test:watch    # re-run on change
+```
+
+The suite runs fully offline and is isolated from your real config, API key and
+network — both properties are enforced by guard tests, not assumed. See
+[TESTING.md](./TESTING.md) for the harness and its gotchas.
+
+## Security Notes
+
+- No API keys or Supabase keys are shipped inside the package.
+- Manifest text fetched from the network is **parsed, never evaluated**; the
+  literal parser rejects anything that is not plain data.
+- Tool code runs in a child process with a hard timeout, a memory cap, and
+  captured stdio, so it cannot hang, OOM or corrupt the CLI's output.
+- Pipeline slugs are validated before being used as cache filenames.
+- `config.json` is written with mode `0600`; secret values are redacted by
+  `nxb config get` and never echoed by `nxb config set` or `config unset`.
+- `nxb config unset` exists so a rotated API key can actually be removed.
+- `nxb transform` writes the payload to stdout exactly once and nothing else, so
+  `nxb transform <tool> | jq` is safe.
+- Tool slugs are validated against a strict pattern before being used as cache
+  filenames or query strings, which also blocks PostgREST filter injection.
+- Run telemetry sends only the tool slug, is bounded by a 1.5s abort timeout, and
+  is skipped entirely when disabled.
+- Test isolation is itself guarded: the suite cannot read your real config or
+  spend your API key, and canary tests fail if a secret is ever printed.
+- The run counter sends only the tool slug. Disable it with
+  `nxb config set telemetry false`.

package/TESTING.md

@@ -0,0 +1,125 @@
+# Testing the CLI
+
+The test suite runs entirely offline and never touches a developer's real
+config, credentials or network. Both of those properties are enforced, not
+assumed — see [Leak guards](#leak-guards).
+
+```bash
+npm test              # run everything
+npm run test:coverage # run everything with a coverage report
+npm run test:watch    # re-run on change
+node --test --import ./test/setup.mjs test/pipe.test.js   # one file
+```
+
+## The isolation harness
+
+Every test file is launched with `--import ./test/setup.mjs`. That module runs
+**before any `src/` file is loaded**, which is the only moment it can work:
+`paths.js` and `API_BASE` are evaluated at import time, so isolation set up
+inside a test file would already be too late.
+
+`test/setup.mjs` gives each test file:
+
+| | |
+|---|---|
+| `XDG_CONFIG_HOME` / `XDG_CACHE_HOME` | a fresh `mkdtemp` directory, so tests read and write a throwaway config instead of yours |
+| `HOME` | masked, so any fallback path cannot reach your real home |
+| `NEXUSBLOOM_API_URL` | `https://api.nxb.invalid` — `.invalid` is reserved by RFC 2606, so a request that escapes a stub fails instead of reaching production |
+| `NEXUSBLOOM_API_KEY`, `NEXUSBLOOM_SUPABASE_ANON_KEY` | deleted, so a test can never spend your key |
+| `NXB_NO_INTERACTIVE`, `CI` | set, so no prompt can block a run |
+| `NEXUSBLOOM_TELEMETRY` | deleted, so no test can phone home |
+| `process.stdin` | replaced with a double that is **not** a TTY but does emit `end` |
+
+That last row is subtle and load-bearing. `readStdin()` resolves on `end`, or
+immediately when stdin is a TTY. Under `node --test` stdin is a pipe that is
+never closed, so `end` never arrives and any test reaching `readStdin()` waits
+forever — which surfaces as an 800-second file timeout rather than a failing
+assertion. The double has to satisfy three things at once: stay non-TTY so
+`isInteractive()` is correctly false, deliver `end` to a listener that attaches
+later, and hold no OS handle so the file can still exit. A test that wants piped
+input uses `withStdin()`.
+
+## Helpers
+
+| helper | use |
+|---|---|
+| `helpers/net.js` | `resetNetwork()` · `route/json/text/status` · `calledWith` · `calls` |
+| `helpers/output.js` | `captureOutput(fn)` · `captureBoth(fn)` → `{value, stdout, stderr}` |
+| `helpers/cli.js` | `withExitCode(fn)` → `{value, exitCode}` |
+| `helpers/stdin.js` | `withStdin(text, fn)` |
+| `helpers/capture.js` | `captureIO` — string chunks only |
+| `helpers/ui-double.mjs` | scripted stand-in for the interactive prompts |
+| `helpers/ui-hook.mjs` | `module.register` hook that redirects only `run.js`'s `./ui.js` import |
+
+## Gotchas
+
+Each of these cost real debugging time. They are properties of the runner and
+the harness, not opinions.
+
+**`node --test` writes its own protocol to stdout as Buffers.** A capture helper
+that decodes Buffers into the captured text corrupts it, and a
+`JSON.parse(captured)` fails intermittently with `Unexpected token` depending on
+timing. Record string chunks only and pass binary straight through. Both
+`helpers/output.js` and `helpers/capture.js` do this.
+
+**Do not capture stdout around anything that awaits a real timer or async gap.**
+The runner's own reporting written during that window is swallowed, and the file
+reports a wrong final test count with no error at all.
+
+**Wrap anything that reports a failure in `withExitCode`.** The CLI signals
+failure by setting `process.exitCode = 1` and returning, so the caller can keep
+working. That is right for the CLI and wrong for a test: a perfectly correct test
+of a failure path would make the whole file exit non-zero.
+
+**`resetNetwork()` between cases, not just between tests.** Routes only append
+and the first match wins, so registering two responses for one pattern leaves
+the second as dead code and every assertion after it passes for the wrong reason.
+
+**`await import("node:fs")` yields a namespace, not a live binding.** A stub
+assigned to the *default* export is invisible to a named-export read from inside
+the module. To exercise a path that checks the filesystem, change the
+filesystem — e.g. `sandbox-missing.test.js` copies `sandbox.js` into a temp
+directory with no `runner.js` beside it, which is a real broken install.
+
+**Module-level state latches.** `runnerMissing` in `sandbox.js` stays true once
+set, so that behaviour lives in its own test file; `node --test` gives each file
+a separate process, which is the isolation it needs.
+
+**Interactive code is tested by injection, not by a terminal.** Inquirer cannot
+be driven headlessly and a pending prompt keeps the process alive forever. The
+wizard takes a `prompts` bundle (`wizard-flow.test.js`); `run.js`'s interactive
+half is reached through a `module.register` hook that swaps only its `./ui.js`
+import (`run-interactive.test.js`). Both keep the real decision logic in `src`
+and replace only the presentation.
+
+**`index.js` is spawned, not imported.** It parses argv on import. Spawning it
+is also the honest way to assert the two contracts users depend on: exit codes,
+and the stdout/stderr split.
+
+## Writing a test for a new module
+
+1. `import` it normally at the top of the file. The `--import` hook has already
+   run, so isolation is in place.
+2. Network: `beforeEach(() => resetNetwork())`, `after(() => restoreNetwork())`.
+3. Failure paths: wrap in `withExitCode` and assert `exitCode`.
+4. Anything reading stdin: `withStdin`, or just let the default resolve `""`.
+5. Assert behaviour, not coverage. A test that exists only to execute a line is
+   a maintenance liability that fails for the wrong reasons.
+
+## Leak guards
+
+`test/isolation.test.js` is not an ordinary unit test file. Each test fails if a
+future change lets the suite read the developer's real config, reuse a real API
+key, or reach the real network:
+
+- config and cache resolve inside the temp sandbox, never under the real home
+- no inherited credentials or telemetry opt-in survive into the process
+- the API base is unroutable, so an unstubbed request fails rather than escaping
+- a canary secret never appears in captured stdout or stderr
+- redacted config leaks neither the value nor a fragment of it
+- `config.json` is `0600` inside a `0700` directory
+- no source file contains a hardcoded credential
+- no inlined JWT grants more than the `anon` role
+
+If you add a code path that could print a secret, add a canary test for it in the
+same change.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nexusbloom/cli",
-  "version": "0.3.4",
+  "version": "0.8.0",
   "description": "NexusBloom CLI — run tools and workflows from your terminal",
   "type": "module",
   "bin": {
@@ -9,7 +9,8 @@
   "files": [
     "src/",
     "package.json",
-    "README.md"
+    "README.md",
+    "TESTING.md"
   ],
   "publishConfig": {
     "access": "public"
@@ -22,5 +23,11 @@
     "chalk": "^5.3.0",
     "commander": "^12.0.0",
     "qrcode": "^1.5.4"
+  },
+  "scripts": {
+    "test": "node --test --import ./test/setup.mjs test/*.test.js",
+    "test:coverage": "node --test --experimental-test-coverage --import ./test/setup.mjs test/*.test.js",
+    "test:watch": "node --test --watch --import ./test/setup.mjs test/*.test.js",
+    "lint": "node --check src/index.js"
   }
-}
+}

package/src/abbr.js

@@ -1,17 +1,19 @@
 /**
  * abbr.js — `nxb abbr` command.
  *
- * Simple paginated abbreviation view.
+ * Paginated abbreviation view.
  *
- *   nxb abbr                   — interactive pagination (10/page)
- *   nxb abbr ip                — filter by query (matches slug, abbr, or name)
- *   nxb abbr --json           — raw JSON
- *   nxb abbr --no-interactive — single dump
+ *   nxb abbr                 — interactive pagination (20/page)
+ *   nxb abbr ip              — filter by query (matches slug, abbr, or name)
+ *   nxb abbr -s ip           — same, explicit flag
+ *   nxb abbr --json          — raw JSON
+ *   nxb abbr --no-interactive— single dump
  */
 
 import chalk from "chalk";
-import { fetchTools, generateAbbreviations } from "./tools.js";
+import { fetchTools, generateAbbreviations, filterTools } from "./tools.js";
 import { paginate, paginateInteractive, PAGE_SIZE } from "./ui.js";
+import { diagnoseEmptyCatalogue } from "./diagnostics.js";
 
 function renderAbbrPage(result, abbrMap) {
   if (result.total === 0) {
@@ -30,22 +32,27 @@ function renderAbbrPage(result, abbrMap) {
 
 export async function abbrAction(opts = {}) {
   const { query, json: jsonMode, interactive = true, force = false, offline = false } = opts;
+  const search = query || opts.search;
 
   const tools = await fetchTools({ force, offline });
+  if (!tools || tools.length === 0) {
+    return diagnoseEmptyCatalogue({ offline, jsonMode, source: "catalogue" });
+  }
   const abbrMap = generateAbbreviations(tools.map((t) => t.slug));
 
-  let filtered = tools;
-  if (query) {
-    const q = query.toLowerCase();
-    filtered = tools.filter((t) => {
-      const abbr = abbrMap[t.slug];
-      return (
-        abbr?.toLowerCase().includes(q) ||
-        t.slug.toLowerCase().includes(q) ||
-        (t.name || "").toLowerCase().includes(q)
-      );
-    });
-  }
+  // Match slug / name / description / category, plus the abbreviation itself —
+  // the abbreviation is what you actually type, so it has to be searchable.
+  const filtered = search
+    ? (() => {
+        const byFields = filterTools(tools, search);
+        const seen = new Set(byFields.map((t) => t.slug));
+        const q = search.toLowerCase();
+        const byAbbr = tools.filter(
+          (t) => !seen.has(t.slug) && (abbrMap[t.slug] || "").toLowerCase().includes(q)
+        );
+        return [...byFields, ...byAbbr];
+      })()
+    : tools;
 
   if (jsonMode) {
     const output = filtered.reduce((acc, t) => { acc[t.slug] = abbrMap[t.slug]; return acc; }, {});
@@ -55,7 +62,7 @@ export async function abbrAction(opts = {}) {
 
   if (!interactive) {
     if (filtered.length === 0) {
-      console.log(chalk.yellow(`  No abbreviations${query ? ` matching "${query}"` : ""}.`));
+      console.log(chalk.yellow(`  No abbreviations${search ? ` matching "${search}"` : ""}.`));
       return;
     }
     const result = paginate(filtered, filtered.length, 1);
@@ -73,7 +80,7 @@ export async function abbrAction(opts = {}) {
       console.log(chalk.bold(`\n  Tool Abbreviations  (${result.total} · page ${result.page}/${result.totalPages})\n`));
       renderAbbrPage(result, abbrMap);
     },
-    {}
+    { interactive }
   );
 }