mcp-node-zig
Run commands, manage long-running sessions, and read/write files on the host through MCP.
Inspect host info: hostname, OS, load, memory, root disk, uptime (
sys_info).Run one-shot commands with verbatim argv and no shell, returning structured stdout/stderr/exit code (
exec).Run shell scripts through bash/sh/fish/zsh or cmd/powershell (
exec_shell).Start long-running processes and manage sessions: poll output, wait, write stdin, kill process tree, close, list sessions.
Read UTF-8 text files with character offset/limit.
Write files from base64, create parent dirs, set POSIX mode, get SHA-256 and size.
List directories with entry type, size, mtime, and truncation flag.
mcp-node-zig
Your servers call home. Your agent gets a structured shell on any machine, even behind NAT; you keep the keys, the perimeter and the kill switch.

mcp-node-zig is one static binary that speaks MCP. Put it on a machine and your agent can run commands, drive long-running sessions and read or write files there. The node dials out to a hub you run (the same binary), so the machine opens no inbound ports, no SSH key ever reaches the agent, and no third-party cloud sits in the path. The link is mutually authenticated with HMAC-SHA256 and runs over TLS, the hub rate-limits handshakes per source, and every tool call can land in a tamper-evident audit log.
2.0 ms cold start · 1.2 ms p50 exec round-trip · 1.57 MiB idle RSS · 9.6 MiB binary (benchmarks)
Install
curl -fsSL https://raw.githubusercontent.com/alexchen-sys/mcp-node-zig/main/install.sh | shThe script detects the platform, downloads the latest release, verifies it against SHA256SUMS.txt and installs to /usr/local/bin (or ~/.local/bin). For a hub with the built-in TLS server, add MCP_NODE_FLAVOR=tls (Linux and macOS releases). Pin a version with MCP_NODE_VERSION=0.5.0, change the target directory with PREFIX=/some/dir.
Manual install, Linux x86_64:
curl -L https://github.com/alexchen-sys/mcp-node-zig/releases/download/v0.5.0/mcp-node-v0.5.0-x86_64-linux.tar.gz | tar xzOther targets on the releases page: aarch64-linux, aarch64-macos, x86_64-windows. Each release ships SHA256SUMS.txt, signed with cosign keyless (Sigstore); install.sh verifies the signature when cosign is on your PATH.
Related MCP server: interminal
Quickstart
openssl rand -hex 32 > token
./mcp-node-v0.5.0-x86_64-linux/mcp-node &
curl -sS http://127.0.0.1:8341/mcp \
-H 'Content-Type: application/json' \
-H "X-Node-Token: $(cat token)" \
--data '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"sys_info","arguments":{}}}'You get back hostname, OS, load, memory and uptime as JSON. Now attach your agent:
claude mcp add --transport http mcp-node http://127.0.0.1:8341/mcp \
--header "X-Node-Token: $(cat token)"curl.exe -L -o mcp-node.zip https://github.com/alexchen-sys/mcp-node-zig/releases/download/v0.5.0/mcp-node-v0.5.0-x86_64-windows.zip
Expand-Archive mcp-node.zip
[guid]::NewGuid().ToString('N') + [guid]::NewGuid().ToString('N') | Set-Content -NoNewline -Encoding Ascii token
.\mcp-node-v0.5.0-x86_64-windows\mcp-node.exeFrom a second window:
Invoke-RestMethod -Uri http://127.0.0.1:8341/mcp -Method Post -ContentType "application/json" `
-Headers @{ "X-Node-Token" = (Get-Content token) } `
-Body '{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"sys_info","arguments":{}}}'Why
Keys stay with you. The agent holds a token for the node, never an SSH key. Stop the node and access is gone; rotate the token and every old copy stops working.
Nothing to provision. No Node, no Python, no OpenSSH, no keys to distribute. Copy one file and run it.
Processes outlive requests. Start a build, disconnect, come back and read the output by offset.
Cheap to keep running. 1.57 MiB idle. Each extra connected agent adds about 304 KiB, not a second ~100–150 MiB server process.
No shell unless you ask.
execpasses argv verbatim.exec_shellis the one explicit shell layer.Kills the whole tree. Process groups on POSIX, Job Objects on Windows. No orphaned children holding pipes.
Every call on the record. Turn on the audit log and each tool call leaves an HMAC-chained JSONL line that
audit-verifychecks offline.Linux, macOS, Windows. All three are built and smoke-tested in CI on every push.
How is this different from SSH?
They solve different problems, and they work well together.
SSH is a secure transport and a terminal for people. It has encryption, key management, agent forwarding, PTYs, scp/sftp/rsync and decades of hardening. Keep using it for all of that.
mcp-node is an execution API for agents. Through SSH, an agent gets one string that a remote shell parses again, plus raw bytes and an exit status. Here it gets:
argv without a shell. No second round of quoting for a remote shell to reparse. A shell is used only when you ask for
exec_shell.Structured results.
stdout,stderr,exit_code,truncated_*and timings as JSON, with per-call timeouts.Sessions that outlive the request.
exec_start, thenexec_pollby byte offset,exec_writeto stdin,exec_waitup to 300 s,exec_killfor the whole tree. A dropped connection doesn't kill the build.Verified file writes.
write_filetakes plain text or base64 and returns the SHA-256 of what landed on disk.A self-describing interface. Any MCP client discovers the tools from
tools/list; nothing to teach the agent.
For remote machines, reverse connect replaces the tunnel: no sshd on the target and no key in the agent's hands. Where SSH is already in place, the two pair up: the node listens on 127.0.0.1 and you forward the port (ssh -L 8341:127.0.0.1:8341 host).
Reverse connect (no inbound ports)
For machines behind NAT or without sshd, run the node with
--connect hub:port: it dials out to a hub (the same binary with
MCP_NODE_HUB_LISTEN), and clients reach it at /n/<name>/mcp on the hub.
The default setup wraps the link in TLS: the hub's link port stays on
127.0.0.1 behind a TLS terminator (nginx stream, stunnel, HAProxy), and
the node dials it with MCP_NODE_CONNECT_TLS=1:
# hub; nginx/stunnel terminates TLS on :8400 and forwards to 127.0.0.1:8401
MCP_NODE_HUB_LISTEN=127.0.0.1:8401 MCP_NODE_HUB_SECRET_FILE=nodes ./mcp-node
# node; `nodes` on the hub holds the line laptop:<secret>, `secret` here holds <secret>
MCP_NODE_NAME=laptop MCP_NODE_CONNECT_SECRET_FILE=secret MCP_NODE_CONNECT_TLS=1 \
./mcp-node --connect hub.example.com:8400The -tls release build (or any binary built with -Dtls-server) can serve TLS on the link port itself
(MCP_NODE_HUB_TLS_CERT_FILE / MCP_NODE_HUB_TLS_KEY_FILE), with no
terminator in front; the hub then sees the real peer addresses, so its
per-source handshake limits apply as written.
Full setup, a terminator config and the plain TCP variant for trusted networks are in docs/reverse-connect.md.
stdio mode
Clients that spawn their servers as subprocesses can run the node directly
with --stdio (or MCP_NODE_STDIO=1). Messages are newline-delimited
JSON-RPC: one request per line on stdin, one response per line on stdout.
There is no listener and no token, since whoever holds the pipes started the
process. Logs go to stderr only; the node exits 0 when stdin closes and kills
any non-durable sessions still running (durable sessions are exactly the
opt-in exception: they detach and survive, see
Durable sessions).
{
"mcpServers": {
"mcp-node": {
"command": "mcp-node",
"args": ["--stdio"]
}
}
}--stdio can't be combined with --connect or MCP_NODE_HUB_LISTEN.
Audit log
Set MCP_NODE_AUDIT_FILE and every tool call leaves one append-only JSONL
record, chained with HMAC-SHA256 so edits, deletions and reordering of past
records are detectable offline:
openssl rand -hex 32 > audit-key && chmod 600 audit-key
MCP_NODE_AUDIT_FILE=/var/log/mcp-node.jsonl MCP_NODE_AUDIT_KEY_FILE=./audit-key ./mcp-node
mcp-node audit-verify --anchor /var/log/mcp-node.jsonlThe node records each tools/call (tool, transport, peer, per-tool argument
summary, result), the hub records relay routing plus link lifecycle; the
two join by req_id. Scripts, file contents and stdout are never logged.
Details and the threat model: docs/audit-log.md.
Tools
Tool | Does |
| hostname, OS, load, memory, uptime |
| run argv to completion, no shell; |
| run a script via |
| start a long-running process as a session |
| read session output from byte offsets, |
| block until the session exits or |
| write base64 bytes to stdin; |
| kill the session's process tree |
| free the session; idempotent |
| list live sessions |
| read UTF-8 text with offset/limit or |
| write plain text ( |
| list entries with type, size, mtime |
| copy a file or directory tree to an exact new destination; staged and atomically published, never overwrites |
Full schemas via tools/list. exec and exec_shell timeouts default to 120 s, clamped to 1–1800 s.
Durable sessions
Exec sessions live in the node process, not in any connection. A session
survives a hub<->node link drop, a hub restart and any client disconnect:
capture keeps running while nobody polls, and after a reconnect the same
session_id continues from the byte offsets of your last reply (no gaps,
no duplicates). exec_list recovers ids when a reply was lost.
By default, sessions live in memory (unknown_session after a node process
restart such as a crash, OOM kill or reboot). Output per stream is capped at MCP_NODE_MAX_OUT
bytes; once the cap is hit the head is kept, truncated_* is set,
and lost_*_bytes reports how many subsequent bytes were dropped.
Finished sessions are reaped MCP_NODE_SESSION_TTL_S after completion;
running sessions are not reaped by time.
Opt-in disk durability (durable: true)
With MCP_NODE_STATE_DIR (or --state-dir) configured, exec_start accepts
"durable": true: the child's stdout/stderr are appended to per-session log
files on disk from the moment of spawn, and the session record commits before
the child starts writing. After a node restart the node recovers the session:
exec_poll on the same id returns recovered: true with byte-exact deltas
from your offsets, and exec_kill continues to work because every signal is gated on a
verified process identity (PID + start-time + boot id). The leader is
signaled through pidfd, which cannot target a recycled PID. A narrow race
remains if a process group is torn down and its ID is recreated between the
identity check and the group signal.
Data at rest: argv, cwd and the full stdout/stderr logs persist in
plaintext under the state dir (treat it like shell history when commands may output secrets).
It stays on the local disk and requires 0700 permissions.
Recovered sessions report degraded capabilities explicitly in their status fields:
stdin_available: false (exec_write returns StdinUnavailable), and when
an orphaned child exited while the node was down, exit_code is null
with completion_reason: "orphaned_exit". Records bound to another
token remain isolated by owner hash. Owner binding applies to
policy-token identities; with no policy configured every request shares the
default zero owner. A durable session closed
or reaped returns unknown_session with expired: true for a bounded
recency window. durable: true without a state dir is refused as
DurabilityDisabled; the state dir itself must be private (0700) and is
locked against concurrent node processes (StateDirLocked). MCP_NODE_STATE_MAX_BYTES
(default 64 MiB) caps total local state storage. In v0.5.0 durable sessions are Linux-only; other
platforms return DurabilityUnsupported.
An unknown or expired session_id returns
{"ok": false, "error": "unknown_session", "session_id": ..., "expired": ..., "message": ...}
as a structured tool result (isError: true) rather than a protocol-level JSON-RPC -32602. expired: true
means this node recently held the session and closed, reaped or evicted
it (a bounded recency window: ids removed long ago are forgotten and
answer expired: false, as do ids this node never had or that pre-date a
node restart; the message says so). exec_close keeps its idempotent
{"ok": true, "already_closed": true} for the same case.
Clients
Every client below uses the same URL and token. Authorization: Bearer <token> works everywhere; X-Node-Token: <token> is accepted for clients that can't set Authorization.
Cursor (.cursor/mcp.json):
{
"mcpServers": {
"mcp-node": {
"url": "http://127.0.0.1:8341/mcp",
"headers": { "Authorization": "Bearer <token>" }
}
}
}VS Code (.vscode/mcp.json):
{
"servers": {
"mcp-node": {
"type": "http",
"url": "http://127.0.0.1:8341/mcp",
"headers": { "Authorization": "Bearer <token>" }
}
}
}Codex (~/.codex/config.toml):
[mcp_servers.mcp-node]
url = "http://127.0.0.1:8341/mcp"
http_headers = { "Authorization" = "Bearer <token>" }Claude Desktop and other JSON clients: same as Cursor, plus "type": "http".
Clients that only speak stdio: run the node itself with --stdio (see stdio mode), or bridge to a remote node over HTTP with npx mcp-remote http://127.0.0.1:8341/mcp --header "Authorization: Bearer <token>"
Security
Token required. The server refuses to start with a missing or empty token file. Comparison is constant-time.
Per-token argument gating (optional).
MCP_NODE_POLICY_FILEconstrains what each client token may do at the argument level: argv[0] allowlists, path prefixes for reads/writes/cwd, timeout and write-mode caps, token-owned sessions. See argument gating.Loopback by default. It binds
127.0.0.1. To expose it, setMCP_NODE_HOSTand add thehost:portclients use toMCP_NODE_ALLOWED_HOSTS.Host and Origin checked before the body is parsed: unknown Host gets 421, unknown Origin gets 403.
TLS on the wire. The node link runs over TLS, served by the hub itself in a
-Dtls-serverbuild or by any terminator. The local HTTP API stays on loopback; to expose it, front it with a reverse proxy, tunnel or VPN, for examplecaddy reverse-proxy --from node.example.com --to 127.0.0.1:8341.The token is a shell as the user the node runs as. Run it under an account scoped to what the agent should touch.
Security model
Whoever holds the client token runs commands. On a plain node that means the node; on a hub the token reaches every connected node, so treat the hub token as the sum of them.
The hub sees everything. TLS ends on it (or in front of it), so it handles every request and response in plaintext, and a hub that holds a node's secret can run anything on that node.
A node secret is a shell on that node and owns its name. With
name:secretlines each name has its own secret; a single shared secret lets any holder connect under any name, including one not yet taken.The handshake authenticates, and every later frame is tagged. Hub and node prove the secret with HMAC-SHA256 over fresh nonces, and post-handshake frames carry per-direction HMAC-SHA256 tags with strict sequence numbers, so an active relay cannot forge, reorder, or replay them. Plain TCP frames are still not encrypted: a relay can read (not change) them.
Use TLS across anything you don't control.
MCP_NODE_CONNECT_TLS=1makes the node verify the certificate chain and server name, with no switch to turn that off. A binary built with-Dtls-serverserves TLS on the hub's link port itself (see Reverse connect); otherwise terminate TLS in front of that port and keep it on loopback.Plain TCP links are for the same host or a trusted LAN.
Handshake limits are per source address. The hub runs at most 16 unauthenticated handshakes in total and 4 from one IPv4 address or IPv6 /64; 8 failed handshakes within a minute block that source for a minute. 127.0.0.1 and ::1 are exempt, so behind a local TLS terminator every peer looks the same: set per-IP limits there (nginx
limit_conn) and firewall the public port to known sources where you can. With the built-in TLS server the hub sees the real peer address, so these limits work fully.Scopes are opt-in, not a sandbox. Without
MCP_NODE_POLICY_FILEevery token can call every tool; with it, each token gets its own tool list and argument limits (argument gating). An allowed interpreter is still arbitrary code.Out of scope: sandboxing and a compromised hub or node host. The node runs with the full rights of its OS user. (The audit log detects record tampering; it cannot defend against an attacker who controls the host.)
Token permissions
MCP_NODE_POLICY_FILE turns one shared token into a set of tokens, each
with its own tool list and argument boundaries:
{
"version": 1,
"tokens": [
{
"file": "/etc/mcp-node/tokens/build",
"tools": ["sys_info", "exec", "read_file", "list_dir"],
"exec_argv0": ["/usr/bin/git", "/usr/bin/make"],
"exec_cwd": ["/srv/build"],
"max_timeout_s": 120,
"read_paths": ["/srv/build"],
"read_deny": ["/srv/build/keys"]
},
{"file": "/etc/mcp-node/tokens/admin", "allow_all": true}
]
}The node checks every call before anything runs: a denied exec never
starts, a denied write never opens the file. Policy bounds argv[0], cwd,
read and write paths, the timeout ceiling and the mode of created files.
Paths are canonicalized (symlinks, ..) and compared per whole segment.
Sessions belong to the token that opened them. A denial comes back as
{"ok": false, "error": "PolicyDenied", "reason": ...} and lands in the
audit log as a policy.deny event. Token values never appear in the
policy or the log.
Without the variable the node behaves as before. With a policy set, the
node's own token (MCP_NODE_TOKEN_FILE) must itself be one of the
tokens[].file entries; the node refuses to start with InvalidConfig
otherwise. The parser is strict: an
unknown key or a contradiction stops startup. A hub does not take a
policy, because the /n/<name>/mcp route forwards bodies to nodes
verbatim; policy lives on each node. An allowed interpreter (python3,
bash) still means arbitrary code. Details and limits:
docs/arg-gating.md.
Configuration
Environment variables, plus two command-line flags: --connect (reverse
connect target) and --state-dir (durable session journal; same as
MCP_NODE_STATE_DIR, the flag wins).
Variable | Default |
| unset; when set (or |
|
|
|
|
|
|
|
|
| unset (no argument gating; see docs/arg-gating.md) |
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
| unset; |
| unset; |
| unset; enables the audit log at this path |
| unset; HMAC key for the audit chain (0600), separate from token and link secret |
|
|
|
|
|
|
mcp-node --version prints the version, --help the flags; any other
argument than these, --connect, --stdio and --state-dir is an error. The one
subcommand is mcp-node audit-verify [--anchor] <file>..., which checks an
audit log chain offline.
Reverse-connect variables (MCP_NODE_CONNECT*, MCP_NODE_HUB_*) are listed in
docs/reverse-connect.md.
Troubleshooting
Symptom | Fix |
401 | Wrong or missing token. If you send both headers, they must match. |
421 | Add the |
403 | Browser |
415 | Send |
Connection refused | Check |
Exits at startup | Create a non-empty token file. |
Roadmap
Shipped: reverse connect with a mutual HMAC handshake plus authenticated, sequence-checked frames, TLS on the node link (every platform), per-source handshake limits, the tamper-evident audit log, per-token tool and argument scopes, exec sessions that survive a dropped link or hub restart, durable exec sessions that survive a node restart (opt-in, Linux), cosign-signed releases with build provenance.
Next: per-node keypairs instead of shared secrets, durable sessions on macOS/Windows, and a PTY for interactive TUIs. The API is 0.x and may still change before 1.0.
Build from source
Requires Zig 0.16.
git clone https://github.com/alexchen-sys/mcp-node-zig
cd mcp-node-zig
zig build test
zig build -Doptimize=ReleaseSafe # → zig-out/bin/mcp-nodeOn Linux the binary is static with no libc. macOS links only libSystem; Windows only kernel32/ntdll.
License
MIT. The node, the hub, scopes and the audit log stay MIT for good; if a paid offering ever appears, it will be a hosted control plane, not features taken out of this binary.
Available Tools
13 toolsexecRun Command (no shell)ADestructive
Run argv to exit, no shell: metacharacters are data. Shell syntax: exec_shell. Long-running or interactive: exec_start. timeout in seconds, default 120, clamped to [1, 1800]. Invalid UTF-8 in stdout/stderr becomes U+FFFD.
Inputs: argv (required), cwd, timeout. Returns: ok, error, stderr, stdout, +4 more
exec_closeClose SessionADestructiveIdempotent
Kill if running, join threads, free the session. Idempotent: repeat calls return ok, already_closed=true. Close every session you start; sessions persist across requests.
Inputs: session_id (required). Returns: ok, error, already_closed
exec_killKill SessionADestructive
Kill the session's process tree (POSIX: SIGKILL to the process group; Windows: job object). Safe on a dead session. Output stays pollable; free with exec_close.
Inputs: session_id (required). Returns: ok, error
exec_listList SessionsARead-onlyIdempotent
List live sessions: session_id, pid, argv, done, exit_code, timestamps. No arguments. Recovers ids after a lost reply.
Inputs: no named parameters. Returns: ok, error, sessions
exec_pollPoll SessionARead-onlyIdempotent
Read new session output from byte offsets: stdout/stderr deltas, done, exit_code, truncation flags. Pass back the offsets from the previous reply to resume. Same payload as exec_wait.
Inputs: session_id (required), stderr_offset, stdout_offset. Returns: ok, done, error, stderr, +8 more
exec_shellRun Shell ScriptADestructive
Run one script through one shell (POSIX: bash/sh/fish/zsh -c; Windows: cmd /c, powershell -c). Only for shell syntax: pipes, redirects, &&, globs; otherwise exec. timeout in seconds, default 120, clamped to [1, 1800]. Invalid UTF-8 in stdout/stderr becomes U+FFFD.
Inputs: script (required), cwd, shell, timeout. Returns: ok, error, stderr, stdout, +4 more
exec_startStart SessionADestructive
Start a process as a session; returns session_id at once. Use when it outlives the call, streams output or reads stdin (exec_write). Then exec_poll, exec_wait, exec_kill, exec_close. Sessions persist across requests; finished ones are reaped after the session TTL.
Inputs: argv (required), cwd. Returns: ok, pid, error, session_id
exec_waitWait For SessionARead-onlyIdempotent
Block until the session exits or timeout elapses (default 30s, max 300s). Returns the exec_poll payload with deltas from the given offsets.
Inputs: session_id (required), timeout, stderr_offset, stdout_offset. Returns: ok, done, error, stderr, +8 more
exec_writeWrite To SessionA
Write bytes to session stdin; eof=true closes stdin afterwards. For interactive programs started by exec_start.
Inputs: data_b64 (required), session_id (required), eof. Returns: ok, eof, bytes, error
list_dirList DirectoryARead-onlyIdempotent
List directory entries sorted by name: name, type (d dir, l symlink, f file), size in bytes, mtime in Unix seconds. Max 2000 per call; truncated=true if more.
Inputs: path. Returns: ok, path, count, error, +3 more
read_fileRead FileARead-onlyIdempotent
Read a text file as UTF-8 (invalid bytes replaced): size, offset, content, has_more. offset/limit count characters, not bytes. Default limit 200000; files over 64 MiB are rejected.
Inputs: path (required), limit, offset. Returns: ok, path, size, error, +3 more
sys_infoSystem InfoARead-onlyIdempotent
Host summary: hostname, OS, load, memory, root disk (disk_root: total/used/free bytes), uptime. No arguments, read-only; use as a connectivity check.
Inputs: no named parameters. Returns: os, mem, node, machine, +4 more
write_fileWrite FileADestructive
Write base64 content to a file, overwriting; creates parent dirs by default. Returns size and sha256 of the written bytes.
Inputs: path (required), content_b64 (required), mode, mkdirs. Returns: ok, path, size, error, +1 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 13 tools
The nine exec_* tools form a coherent session lifecycle (start/poll/wait/write/kill/close/list) with distinct roles, and the file tools (read_file/write_file/list_dir) are clearly separate. The main overlap is the trio exec vs exec_shell vs exec_start and the fact that exec_poll and exec_wait return identical payloads, which could cause occasional misselection.
All names are lowercase snake_case following a predictable verb_noun pattern. The exec_* family is systematically prefixed, and file tools (read_file/write_file/list_dir) and sys_info-adjacent tools follow consistent conventions throughout.
13 tools is well within the ideal range and each tool earns its place. The session lifecycle is broken into focused operations rather than being crammed into one overloaded tool, and the file/host operations round out the set without bloat.
The surface covers process execution (one-shot, shell, and session-based), full file read/write/list, and host info, which is solid lifecycle coverage. Minor gaps remain (no file delete/stat/move/copy), but these are workaroundable via exec/exec_shell.
Maintenance
Related MCP Connectors
Remote MCP server exposing your Node Command fleet (files, shell, processes, browser) to AI hosts.
SSH client, server management and one remote MCP URL for your machines, with human approvals.
Remote MCP server for supportsheep: run AI interviews and manage support content for your blog.
Remote MCP server for supportsheep: run AI interviews and manage support content for your blog.
Related MCP Servers
- FlicenseNot gradedqualityNot gradedmaintenanceA secure and pluggable MCP server to run terminal commands on your local machine or cloud server — remotely, safely, and with LLMs or agentic clients.-
- AlicenseAqualityCmaintenanceMCP server for SSH and local terminal access. Supports interactive commands, long-running processes, and TUI apps like tmux/zellij64MIT
- FlicenseAqualityBmaintenanceCross-platform MCP server for policy-controlled command execution on Linux and Windows, with no SSH dependency.3-
- AlicenseNot gradedqualityBmaintenanceTurns any Linux server into an AI-agent-accessible machine over HTTPS, allowing MCP clients like ChatGPT, Claude, and Grok to securely control files, run shell commands, inspect system state, query SQLite, and work with git behind a bearer token.76 npm4MIT