raidcom-mcp 0.0.0-stage → 0.1.3

package/CHANGELOG.md

@@ -0,0 +1,64 @@
+# Changelog
+
+## Unreleased
+
+## 0.1.3 — 2026-10-28
+
+### Added
+
+- **`RAIDCOM_HTTP_CLIENT_IP_HEADER`** reads the client's address from a header a trusted proxy sets, such as `cf-connecting-ip` behind Cloudflare. On Render, which sits behind Cloudflare, counting `X-Forwarded-For` entries gave a Cloudflare address, so every user shared the rate limit and the in-progress cap of their Cloudflare edge.
+- **`RAIDCOM_HTTP_DEBUG_CLIENT=true`** makes `/healthz` show the forwarding headers it received, to choose the proxy settings.
+
+## 0.1.2 — 2026-10-27
+
+0.1.0 and 0.1.1 were withdrawn from npm and can't be published again there; this is the first version on npm since. 0.1.1's GitHub release and Docker image stay available.
+
+### Security
+
+- **Script text could carry shell commands through two global options.** `global.pair_type` was written into scripts without a check (`"pair_type": "$(id)"` produced `run raidcom lock resource -I$(id)0`), and `global.instance` was only checked when a step produced at least one command (`"instance": "0;id"` produced `export HORCMINST=0;id`). All global options are now checked once, before anything is written: `pair_type` must be H, M, TC or SI, `instance` and `unit` whole numbers from 0 to 9999, and unknown global options are refused.
+- **A value starting with `#` was written unquoted,** so the shell treated the rest of the line as a comment and dropped options after it, including `-checkmode precheck`. Values containing `#` are now always quoted.
+- **Values that start with `-` and a letter are refused,** so a value such as `"CL1-A-0 -IH9"` can't add options of its own.
+- **LDEV IDs that aren't numbers** (`abc`, `1e+308`) are now errors rather than warnings.
+
+### Fixed
+
+- **A request could stop or slow the HTTP server.** A range with numbers above 2^53 made range expansion loop until the process ran out of memory; very long command names took seconds of CPU; large `foreach` and `zip` lists were expanded before the 500-command limit was checked. Ranges now only use exact numbers, lists stop at the limit while they are expanded, and names longer than 64 characters are refused before any matching.
+- **Slow clients could take every HTTP slot.** Clients now have 10 seconds to send headers and 15 to send the whole request, and one address may have at most 8 requests in progress.
+- **Behind a trusted proxy, the rate limit used the client-supplied X-Forwarded-For entry.** `RAIDCOM_HTTP_TRUST_PROXY` now takes the number of proxies in front of the server (`true` still means one), and the client address is the entry that many places from the right, as Express does it. With proxies configured, `/healthz` shows the address the server takes as the caller's, to check the number. The limiter remembers at most 10,000 addresses.
+- **Empty `foreach` or `zip` lists, or a script with no commands,** are errors instead of an empty script reported as success.
+- **`raidcom_check_command`:** the two words after `-login` are always dropped, even when the password starts with `-`; a bare `-I` and a repeated option are reported.
+- **Names such as `constructor` or `__proto__`** in queries, recipe IDs, parameters and option names no longer crash a tool or slip past checks.
+- **`create-dp-pool`:** giving only one of the two thresholds is an error instead of being ignored.
+- **Search confidence:** a tie between the top results is now rated low, and the search evaluation checks that high-confidence results are right at least 85% of the time.
+- **Release pipeline:**
+  - the MCP Registry rejected `server.json` (description over 100 characters);
+  - the plugin bump never started after automatic releases; Release now starts it once npm has the version;
+  - plugin releases no longer become the repository's "latest" release;
+  - the CHANGELOG heading checks match the exact version;
+  - rebuilding an older release no longer moves the Docker `latest` tag back;
+  - the Windows test uses the smoke test from the tag;
+  - the Windows package tests run again (the job was missing from 0.1.1's Release workflow);
+  - the plugin's lockfile is audited and watched by Dependabot.
+
+## 0.1.1 — 2026-10-26
+
+### Added
+
+- **More release packages.** Every release now also has a Claude Desktop extension (`.mcpb`), standalone packages for macOS, Linux and Windows (x64 and arm64) with a Node.js runtime bundled, and a zip of the `raidcom-command-builder` skill, besides the npm package and the Docker image. `SHA256SUMS` covers them all. The Windows packages are tested on Windows x64 and arm64 machines. CI builds the Desktop extension, the skill zip and the Linux x64 standalone package on every pull request and smoke-tests them. INSTALL.md has a section for each.
+- **Claude Code plugin `raidcom-community`** (`plugin/`, listed by `.claude-plugin/marketplace.json`; see README.plugin.md). It installs the server from a pinned npm version and adds the `raidcom-command-builder` skill. It needs no settings. The Plugin release workflow opens a pull request that moves the plugin to each new server release (including the lockfile), and tags `plugin-v<version>` and creates a GitHub release with the plugin zip when that pull request is merged.
+- **Security scanning in CI.** CodeQL (security-extended queries) runs on every pull request, push to `main` and weekly. Dependency review fails a pull request that adds a vulnerable dependency. A Security audit workflow runs `npm audit` on the runtime dependencies and a Trivy scan of the Docker image on pull requests that touch dependencies or the Dockerfile, and weekly.
+- **Recipe `create-mainframe-pool`:** creates a mainframe parity group (always `-emulation 3390-V`, not a parameter), assigns an SSID, creates and quick-formats 3390 LDEVs and makes them a DP pool, with `HORCC_DRIVEOPERATION=1` exported at the top of the script. Recipes can now export environment variables (`env`).
+- **CU:LDEV notation** (`dd:0f`) is accepted for LDEV IDs and range-checked, and ranges such as `dd:00-dd:0f` expand in recipes and scripts.
+- `add parity_grp` accepts `-emulation`, which the manual's syntax line leaves out but mainframe-capable systems use. The generator records it as an addition.
+- **The Release workflow also pushes the image to Docker Hub** (`subramaniamv/raidcom-mcp`) when the `DOCKERHUB_USERNAME` and `DOCKERHUB_TOKEN` repository secrets are set; otherwise it pushes to ghcr.io only.
+- **Build, CI and release pipeline.** CI now also builds the npm package and installs it into an empty folder to check it starts over stdio and HTTP (`npm run package`, `npm run smoke`). Merging a pull request that bumps `version` in `package.json` tags the commit (the Tag release workflow, which requires a matching `CHANGELOG.md` section) and starts the Release workflow: it re-runs the tests, attaches the package and `SHA256SUMS` to a GitHub release, publishes to npm with provenance, lists the version in the MCP Registry and pushes a multi-arch image to ghcr.io.
+
+## 0.1.0
+
+First version.
+
+- Eight read-only MCP tools: `raidcom_list_commands`, `raidcom_describe_command`, `raidcom_build_command`, `raidcom_check_command`, `raidcom_build_script`, `raidcom_list_recipes`, `raidcom_build_recipe`, `raidcom_model_limits`.
+- A catalogue of 178 commands (218 syntax forms, 562 examples) generated from the Command Reference, with per-model limits for VSP One Block 24/26/28, VSP 5000 series and VSP E series.
+- Thirteen recipes: FC, iSCSI and NVMe/TCP provisioning, DP pools, extending and deleting volumes, command devices, zero-page reclaim, inventory, copy groups.
+- Stdio and stateless Streamable HTTP transports (bearer token, TLS or proxy, host and origin checks, rate limit).
+- Build-only by design: no tool connects to a storage system or runs a command.

package/INSTALL.md

@@ -0,0 +1,169 @@
+# Installing raidcom-mcp
+
+raidcom-mcp only builds command text. It needs no access to a storage system, no credentials and no CCI installation.
+
+## Choose an install method
+
+Every release on GitHub has these files, with `SHA256SUMS` to check them:
+
+| You use | Install with | Needs Node.js? |
+|---|---|---|
+| Claude Desktop | the [`.mcpb` extension](#claude-desktop-extension-mcpb) | No (Claude Desktop brings its own) |
+| Claude Code | the [plugin](#claude-code-plugin) | Yes, 22.19 or later |
+| Any MCP client, no Node.js installed | a [standalone package](#standalone-package) | No |
+| Any MCP client, with Node.js | the [npm package](#from-the-npm-package) or [from source](#from-source) | Yes, 22.19 or later |
+| A server for others to use | [Docker](#docker) or [HTTP](#run-over-http) | No |
+
+### Verify your download
+
+```bash
+sha256sum -c SHA256SUMS --ignore-missing
+```
+
+On macOS, use `shasum -a 256 -c SHA256SUMS --ignore-missing`; on Windows, compare `Get-FileHash <file>` with the line in `SHA256SUMS`.
+
+## Claude Desktop extension (.mcpb)
+
+1. Download `raidcom-mcp-<version>.mcpb`.
+2. Open it, either by double-clicking it or by dragging it onto Claude Desktop.
+3. Click **Install**, then enable the extension. There are no settings to fill in.
+
+The extension runs with the Node.js built into Claude Desktop. To remove it, go to **Settings → Extensions**.
+
+### Add the command-builder skill (optional)
+
+The `raidcom-command-builder` skill guides Claude through finding a command, building it, and showing it with its warnings. The Claude Code plugin includes it. For Claude Desktop or claude.ai, download `raidcom-command-builder-<version>.zip` from the same release (don't unzip it) and upload it under **Settings → Capabilities → Skills**. Skills need a Pro, Max, Team or Enterprise plan with code execution turned on.
+
+## Standalone package
+
+Each standalone package contains the server and its own Node.js runtime:
+
+| System | Package |
+|---|---|
+| macOS, Apple silicon | `raidcom-mcp-<version>-darwin-arm64.tar.gz` |
+| macOS, Intel | `raidcom-mcp-<version>-darwin-x64.tar.gz` |
+| Linux, x64 | `raidcom-mcp-<version>-linux-x64.tar.gz` |
+| Linux, arm64 | `raidcom-mcp-<version>-linux-arm64.tar.gz` |
+| Windows, x64 | `raidcom-mcp-<version>-win-x64.zip` |
+| Windows, arm64 | `raidcom-mcp-<version>-win-arm64.zip` |
+
+The Linux packages need glibc 2.28 or later (RHEL/Rocky 8+, Debian 10+, Ubuntu 20.04+). On Alpine Linux, use [Docker](#docker) or the npm package.
+
+### macOS and Linux
+
+```bash
+sudo tar -xzf raidcom-mcp-<version>-linux-x64.tar.gz -C /opt
+sudo ln -sf /opt/raidcom-mcp-<version>-linux-x64/bin/raidcom-mcp /usr/local/bin/raidcom-mcp
+```
+
+The server command is then `/usr/local/bin/raidcom-mcp`. The launcher follows the symlink to find its runtime.
+
+### Windows
+
+Unzip the archive to a folder such as `C:\Program Files\raidcom-mcp`. The server is started by its bundled `runtime\node.exe` running `dist\index.js`:
+
+```powershell
+& "C:\Program Files\raidcom-mcp\raidcom-mcp-<version>-win-x64\runtime\node.exe" "C:\Program Files\raidcom-mcp\raidcom-mcp-<version>-win-x64\dist\index.js"
+```
+
+From a Command Prompt you can also run `bin\raidcom-mcp.cmd`. In MCP client configs use `node.exe` and `index.js` as shown above, because clients often can't start `.cmd` files directly.
+
+## Claude Code plugin
+
+```
+/plugin install raidcom-community --marketplace visubramaniam/raidcom-mcp
+```
+
+See [README.plugin.md](README.plugin.md).
+
+## From the npm package
+
+```bash
+npm install -g raidcom-mcp
+raidcom-mcp          # MCP over stdio
+```
+
+Requires Node.js 22.19 or later (`node --version`).
+
+## From source
+
+```
+git clone https://github.com/visubramaniam/raidcom-mcp.git
+cd raidcom-mcp
+npm ci
+npm test
+```
+
+`npm test` builds the server, runs the unit tests and the search evaluation.
+
+## Connect it to Claude
+
+### Claude Code
+
+```
+claude mcp add raidcom -- node /absolute/path/to/raidcom-mcp/dist/index.js
+```
+
+### Claude Desktop
+
+Add this to `claude_desktop_config.json` (Settings → Developer → Edit config) and restart Claude Desktop:
+
+```json
+{
+  "mcpServers": {
+    "raidcom": { "command": "node", "args": ["/absolute/path/to/raidcom-mcp/dist/index.js"] }
+  }
+}
+```
+
+### Other MCP clients
+
+Any client that starts a stdio server can run `node dist/index.js`. Clients that speak Streamable HTTP can use the hosted mode below.
+
+## Docker
+
+```
+docker build -t raidcom-mcp .
+docker run -i --rm raidcom-mcp                    # MCP over stdio
+```
+
+See [README.docker.md](README.docker.md) for hosting.
+
+## Run over HTTP
+
+```
+export RAIDCOM_TRANSPORT=http
+export RAIDCOM_HTTP_TOKEN=$(openssl rand -hex 32)
+node dist/index.js
+# [raidcom-mcp] ready: ... listening on http://127.0.0.1:8361/mcp
+```
+
+The transport is stateless: every request is independent, so any number of instances can sit behind a load balancer. Clients send `Authorization: Bearer <token>`.
+
+Which settings are required depends on where it listens:
+
+- **Loopback only** (the default `127.0.0.1`): a token, or `RAIDCOM_HTTP_OPEN=true`.
+- **Reachable by other machines**: also TLS. Either give the server a certificate (`RAIDCOM_HTTP_TLS_CERT`, `RAIDCOM_HTTP_TLS_KEY`) or put it behind a reverse proxy or load balancer that ends TLS and set `RAIDCOM_HTTP_BEHIND_TLS_PROXY=true`.
+- **A public name**: list it in `RAIDCOM_HTTP_ALLOWED_HOSTS` (for example `raidcom.example.com`), or requests are refused with 403 to defend against DNS rebinding.
+- **Behind a proxy**: set `RAIDCOM_HTTP_TRUST_PROXY` to the number of proxies in front of the server (`true` means one), so the rate limits apply per user. Each proxy adds an entry to `X-Forwarded-For`; the server takes the entry that many places from the right, and ignores entries further left, which the client could have written. Too low a number makes every user look like the same proxy (they then share one rate limit); too high lets a client choose its own address. To check the number, open `/healthz`: behind proxies it shows `client`, which should be your own public address (compare with `curl https://ifconfig.me`). Hosting platforms often have more than one proxy, and some put a CDN in front whose own proxies vary in number. If the address `/healthz` shows never matches yours, set `RAIDCOM_HTTP_DEBUG_CLIENT=true` and open `/healthz` again: it lists the forwarding headers it received. Behind Cloudflare (Render, for example) use `RAIDCOM_HTTP_CLIENT_IP_HEADER=cf-connecting-ip` instead of counting proxies; Cloudflare overwrites that header on every request, so a client can't set it. Turn the debug setting off again afterwards.
+
+A public service that anyone may use can run with `RAIDCOM_HTTP_OPEN=true`: the server holds no secrets and cannot reach any array, so the risk is limited to load, which the rate limit and the 256 KB body limit bound.
+
+### Check that it works
+
+```
+curl http://127.0.0.1:8361/healthz
+curl -s http://127.0.0.1:8361/mcp -H "Authorization: Bearer $RAIDCOM_HTTP_TOKEN" \
+  -H "content-type: application/json" -H "accept: application/json, text/event-stream" \
+  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'
+```
+
+You can also explore it with the MCP Inspector: `npm run inspect`.
+
+## Running the commands it builds
+
+raidcom-mcp does not run them. On a host with CCI installed and a running HORCM instance (see the `raidcom://notes/horcm-setup` resource), review the command or script and run it there. Scripts read credentials from `$RAIDCOM_USER` and `$RAIDCOM_PASSWORD` in your shell when built with `login: true`; they are never written into the script.
+
+## Upgrading and uninstalling
+
+`git pull && npm ci && npm test`. To uninstall, remove the MCP entry from your client and delete the folder.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Vinod Subramaniam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.docker.md

@@ -0,0 +1,50 @@
+# Running raidcom-mcp with Docker
+
+## Build
+
+```
+docker build -t raidcom-mcp .
+```
+
+## Stdio (a local client)
+
+```
+docker run -i --rm raidcom-mcp
+```
+
+## Hosted over HTTP
+
+```
+docker run -d --name raidcom-mcp -p 8361:8361 \
+  -e RAIDCOM_TRANSPORT=http \
+  -e RAIDCOM_HTTP_HOST=0.0.0.0 \
+  -e RAIDCOM_HTTP_TOKEN="$(openssl rand -hex 32)" \
+  -e RAIDCOM_HTTP_BEHIND_TLS_PROXY=true \
+  -e RAIDCOM_HTTP_ALLOWED_HOSTS=raidcom.example.com \
+  -e RAIDCOM_HTTP_TRUST_PROXY=true \
+  raidcom-mcp
+curl http://127.0.0.1:8361/healthz
+```
+
+Put a reverse proxy or load balancer in front that ends TLS and forwards `/mcp` and `/healthz` to port 8361. Leave out `RAIDCOM_HTTP_TOKEN` and set `RAIDCOM_HTTP_OPEN=true` for a public service without authentication. The container runs as the unprivileged `node` user, needs no volumes, and needs no outbound network access.
+
+Example `docker-compose.yml`:
+
+```yaml
+services:
+  raidcom-mcp:
+    build: .
+    restart: unless-stopped
+    ports: ["127.0.0.1:8361:8361"]
+    read_only: true
+    environment:
+      RAIDCOM_TRANSPORT: http
+      RAIDCOM_HTTP_HOST: 0.0.0.0
+      RAIDCOM_HTTP_BEHIND_TLS_PROXY: "true"
+      RAIDCOM_HTTP_ALLOWED_HOSTS: raidcom.example.com
+      RAIDCOM_HTTP_TRUST_PROXY: "true"
+      RAIDCOM_HTTP_TOKEN: ${RAIDCOM_HTTP_TOKEN:?set a token}
+    healthcheck:
+      test: ["CMD", "wget", "-qO-", "http://127.0.0.1:8361/healthz"]
+      interval: 30s
+```

package/README.md

@@ -1,3 +1,120 @@
-# Temporary Holding Version
+# raidcom-mcp: build Hitachi raidcom commands from plain-language requests
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+A community MCP server that turns a request such as *"present four 100 GB volumes from pool 0 to host esx01 on CL1-A and CL2-A"* into validated `raidcom` commands. It is **build-only**: it never connects to a storage system, never runs a command and holds no credentials. It returns command text (or a shell script) for a person to review and run on a host with CCI installed. That makes it safe to host online for anyone to use.
+
+It is an independent project, not an official Hitachi Vantara product.
+
+## What it does
+
+- **Finds the right command.** `raidcom_list_commands` ranks the 178 commands in the catalogue against a question (BM25 with synonyms and verb intent) and says how confident it is.
+- **Builds one command.** `raidcom_build_command` takes a command name and options as structured data, checks them against the manual's syntax and the storage model's limits, and returns the command line.
+- **Builds many.** `raidcom_build_script` repeats steps over ranges (`foreach`, `zip`), adds `get command_status` after asynchronous commands, optionally locks the resource group, and returns a script that stops at the first failure.
+- **Ready-made workflows.** `raidcom_list_recipes` and `raidcom_build_recipe` cover 14 common jobs: FC, iSCSI and NVMe/TCP provisioning, DP pools, mainframe (3390) pools, extending and deleting volumes, command devices, zero-page reclaim, inventory, copy groups.
+- **Checks an existing command.** `raidcom_check_command` parses a pasted command line (never executing it; shell operators are refused) and reports every problem.
+- **Knows the model limits.** `raidcom_model_limits` gives the LDEV, LUN, pool, serial and port ranges of VSP One Block 24/26/28, VSP 5000 series and VSP E series.
+
+All eight tools are marked read-only. There is no tool that executes anything.
+
+## How the catalogue is made
+
+`spec/raidcom-catalog.json` is generated by `scripts/generate-catalog.mjs` from the text of the *Command Control Interface Command Reference* (MK-90RD7009). For every command it keeps the name, supported models, a one-line summary, each syntax form (as a small grammar), each option's value shape and a short description, and the command lines of the manual's examples. Hitachi's prose, tables and output samples are not copied. The manuals themselves are not part of this repository; to regenerate the catalogue with your own copy:
+
+```
+pdftotext -layout CCI_Command_Reference.pdf cci-reference.txt
+npm run generate-catalog -- cci-reference.txt
+```
+
+`tests/unit/catalog.test.mjs` replays every example in the manual through the parser and validator (about 96% pass; the rest are places where the manual's syntax line and its examples disagree).
+
+## Validation
+
+- Unknown options, wrong number of values, values outside an option's allowed words, and missing required options (checked against the syntax grammar) are errors with a suggested fix.
+- LDEV IDs, LUN IDs, pool IDs, serial numbers and port names (`CL1-A`, `CL3-B-12`) are checked against the model you give, or the widest range of any model.
+- Values that a shell could misread (`; | & $ \` > < ' "` and so on) are refused, and names with spaces are quoted.
+- Because the manual's syntax lines are occasionally incomplete, `strict: false` turns *missing option* errors into warnings. Unknown options and out-of-range values stay errors.
+- Out of scope: the `pair*` commands (paircreate, pairdisplay, ...) from the Quick Reference, and `raidcom -login`/`-logout` lines as commands of their own (scripts can add them with `login: true`, reading `$RAIDCOM_USER` and `$RAIDCOM_PASSWORD` from the shell).
+
+## Setup
+
+You need Node.js 22.19 or later.
+
+```
+git clone https://github.com/visubramaniam/raidcom-mcp.git
+cd raidcom-mcp
+npm ci
+npm run build
+```
+
+### Claude Code
+
+```
+claude mcp add raidcom -- node /path/to/raidcom-mcp/dist/index.js
+```
+
+### Claude Desktop
+
+Add to `claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "raidcom": { "command": "node", "args": ["/path/to/raidcom-mcp/dist/index.js"] }
+  }
+}
+```
+
+### Claude Desktop, standalone packages
+
+Each [release](https://github.com/visubramaniam/raidcom-mcp/releases) has a Claude Desktop extension (`.mcpb`), standalone packages for macOS, Linux and Windows with Node.js bundled, the npm package, and a skill zip. See [INSTALL.md](INSTALL.md).
+
+### Claude Code plugin
+
+```
+/plugin install raidcom-community --marketplace visubramaniam/raidcom-mcp
+```
+
+See [README.plugin.md](README.plugin.md).
+
+### Hosted over HTTP
+
+```
+RAIDCOM_TRANSPORT=http RAIDCOM_HTTP_HOST=0.0.0.0 RAIDCOM_HTTP_TOKEN=$(openssl rand -hex 32) \
+RAIDCOM_HTTP_BEHIND_TLS_PROXY=true RAIDCOM_HTTP_ALLOWED_HOSTS=raidcom.example.com node dist/index.js
+```
+
+The endpoint is `/mcp` (stateless Streamable HTTP); `/healthz` reports liveness. See [INSTALL.md](INSTALL.md) and [README.docker.md](README.docker.md).
+
+## Configuration
+
+| Variable | Default | Meaning |
+|---|---|---|
+| `RAIDCOM_TRANSPORT` | `stdio` | `stdio` or `http` |
+| `RAIDCOM_HTTP_HOST` | `127.0.0.1` | Address to listen on |
+| `RAIDCOM_HTTP_PORT` | `8361` | Port (`0` picks a free one) |
+| `RAIDCOM_HTTP_TOKEN` | none | Bearer token, at least 32 characters. Required unless `RAIDCOM_HTTP_OPEN=true` |
+| `RAIDCOM_HTTP_OPEN` | `false` | Serve anyone who can reach the port, without a token |
+| `RAIDCOM_HTTP_TLS_CERT`, `RAIDCOM_HTTP_TLS_KEY` | none | PEM files; the server then speaks HTTPS |
+| `RAIDCOM_HTTP_BEHIND_TLS_PROXY` | `false` | A proxy or load balancer ends TLS. Needed for non-loopback addresses without TLS |
+| `RAIDCOM_HTTP_ALLOWED_HOSTS` | none | Extra `Host` values to accept (`*` for any) |
+| `RAIDCOM_HTTP_ALLOWED_ORIGINS` | none | `Origin` values to accept (`*` for any) |
+| `RAIDCOM_HTTP_RATE_LIMIT` | `120` | Requests per minute per client (`0` for none) |
+| `RAIDCOM_HTTP_CLIENT_IP_HEADER` | none | A header your proxy sets to the client's address, e.g. `cf-connecting-ip` behind Cloudflare (Render uses Cloudflare). Takes precedence over `X-Forwarded-For` |
+| `RAIDCOM_HTTP_DEBUG_CLIENT` | `false` | `/healthz` also shows the forwarding headers it received, to choose the two settings above |
+| `RAIDCOM_HTTP_TRUST_PROXY` | `false` | Take the client address from `X-Forwarded-For`: `true` for one proxy in front, or the number of proxies (see [INSTALL.md](INSTALL.md#run-over-http)) |
+| `RAIDCOM_CATALOG`, `RAIDCOM_LIMITS`, `RAIDCOM_RECIPES`, `RAIDCOM_EXAMPLES` | bundled | Use another spec file (an empty `RAIDCOM_EXAMPLES` turns the example questions off) |
+
+## Tests
+
+```
+npm test
+```
+
+runs the unit tests (`tests/unit`) and the search evaluation (`tests/search-eval.mjs`: 40 tuning and 30 held-out requests, each with a minimum top-1 and top-3 score that may only go up).
+
+## Contributing
+
+See [CONTRIBUTING.md](CONTRIBUTING.md). Security problems: [SECURITY.md](SECURITY.md).
+
+## License
+
+MIT, see [LICENSE](LICENSE). "Hitachi", "raidcom" and "VSP" are trademarks of their owners; this project is not affiliated with or endorsed by Hitachi.

package/README.plugin.md

@@ -0,0 +1,56 @@
+# The raidcom-community Claude plugin
+
+**raidcom-community** is a Claude plugin that installs the [raidcom-mcp](README.md) server, so Claude can turn a storage task into validated Hitachi `raidcom` commands and scripts. It also adds a skill, `raidcom-command-builder`, that guides Claude through the work.
+
+> Not an official Hitachi Vantara product: raidcom-mcp and this plugin are an independent community project, not supported by or affiliated with Hitachi Vantara.
+
+It is **build-only**. It needs no credentials and no access to a storage system, and it never runs a command. Claude shows you the command or script; you review it and run it on a host with CCI installed.
+
+## Where it works
+
+| Where | Works? |
+|---|---|
+| **Claude Code**: terminal, IDE extensions, and the desktop app's Code tab | Yes |
+| **Claude chat** (claude.ai, desktop and mobile chat) | No: chat doesn't run plugins' local servers. Use the hosted HTTP server instead, if one is available to you ([INSTALL.md](INSTALL.md#run-over-http)) |
+
+## Install
+
+Requires Node.js 22.19 or later, with npm. In a Claude Code session:
+
+```
+/plugin install raidcom-community --marketplace visubramaniam/raidcom-mcp
+```
+
+Or from your shell:
+
+```bash
+claude plugin marketplace add visubramaniam/raidcom-mcp
+claude plugin install raidcom-community@raidcom-community
+```
+
+Claude Code installs the server from the plugin's `package.json` (pinned to an exact version of the `raidcom-mcp` npm package, and to a lockfile with integrity hashes once the release workflow has added it). There are no settings to fill in.
+
+## Use
+
+Ask in plain language:
+
+- *"Present four 100 GB volumes from pool 0 to host esx01 on CL1-A and CL2-A on a VSP One Block 28."*
+- *"Write the commands to create a mainframe pool from these drives."*
+- *"Check this command: raidcom add lun -port CL1-A-0 -ldev_id 200 -lun_id 1"*
+- *"Which raidcom command shows free LDEV IDs?"*
+
+Start the skill by name with `/raidcom-community:raidcom-command-builder`.
+
+## Update, disable and uninstall
+
+```bash
+claude plugin update raidcom-community@raidcom-community
+claude plugin disable raidcom-community@raidcom-community
+claude plugin uninstall raidcom-community@raidcom-community
+```
+
+Each plugin version installs a matching `raidcom-mcp` version; [CHANGELOG.md](CHANGELOG.md) lists what changed.
+
+## Privacy
+
+The server runs on your computer, makes no network requests and stores nothing. Requests you make to Claude go to Anthropic as usual; the plugin adds nothing to them beyond the tool results.