pendnt MCP server
Commit 15. Sept. 2026Ermöglicht dauerhafte menschliche Freigaben, Benachrichtigungen und eventgesteuerte Wake-ups für Headless Claude Code Agents.
Auch bekannt als Pendnt/pendnt-plugin, pendnt-plugin
- Stars
- 0
- Tools
- —
- Downloads, 30 Tage
- —
- Neueste Version
- 0.2.0
- Letzter Commit
- 15. Sept. 2026
- Lizenz
- MIT
Was ist pendnt MCP?
pendnt ist ein MCP server. Ermöglicht dauerhafte menschliche Freigaben, Benachrichtigungen und eventgesteuerte Wake-ups für Headless Claude Code Agents.
Zusammenfassung generiert aus dem README des Projekts
Über pendnt MCP server
pendnt bietet eine Möglichkeit, Claude Code Sessions mit einem Remote-Workspace zu verbinden, um Headless Agents zu verwalten. Es wurde für Entwickler entwickelt, die interaktive oder Headless Claude Code Instanzen ausführen und Permission-Prompts ohne Terminal handhaben müssen. Durch die Nutzung dieses Servers können Agents menschliche Freigaben anfordern, Benachrichtigungen senden und eventgesteuerte Wake-ups über ein robustes System auslösen.
Nutzer können dies über einen PermissionRequest-Hook implementieren, der automatisch vor der Tool-Nutzung ausgeführt wird, oder über das dedizierte permission_prompt MCP Tool. Das Setup erfordert einen PENDNT_API_KEY und kann mit einer PENDNT_URL konfiguriert werden, um auf die Production-API oder eine lokale Development-Instanz zu verweisen. Der Server enthält 14 Tools wie request_approval, notify, schedule_wakeup und kv_set, um dem Modell die direkte Kontrolle über den Workspace-Status und die Kommunikation zu geben.
Diese Lösung ist einzigartig, da sie lang laufende Approval-Prozesse ermöglicht. Während Standard-Tool-Calls eventuell ein Timeout verursachen, kann das permission_prompt Tool einen Call bis zu 540 Sekunden offen halten. Es folgt einem Fail-Closed-Sicherheitsmodell: Jeder Netzwerkfehler, ein fehlender Key oder ein Timeout führt zur Ablehnung, um sicherzustellen, dass Headless Agents keine unbefugten Aktionen ausführen.
Was du damit machen kannst
- 1Headless Tool-Execution freigebenEin Entwickler kann einem Headless Claude Code Agent die Ausführung eines Commands erlauben, indem er eine Anfrage von einem mobilen Gerät oder einem Web-Inbox bestätigt.
- 2Agent-Status-Updates erhaltenDas System kann Benachrichtigungen oder Nachrichten über abgeschlossene Durchläufe an einen externen Endpoint weiterleiten, um dich über den Fortschritt des Agents auf dem Laufenden zu halten.
Geschrieben aus dem README des Projekts. Jeder Use Case wurde gegen ein Zitat daraus geprüft.
So installierst du pendnt MCP
Formate geprüft am 10. Nov. 2026Zu Cursor hinzufügenZu Goose hinzufügenpendnt MCP in Claude Code installieren
$ claude mcp add --transport http pendnt-plugin https://api.pendnt.dev/mcppendnt MCP in Cursor installieren
~/.cursor/mcp.json
{
"mcpServers": {
"pendnt-plugin": {
"url": "https://api.pendnt.dev/mcp"
}
}
}pendnt MCP in VS Code installieren
.vscode/mcp.json
{
"servers": {
"pendnt-plugin": {
"type": "http",
"url": "https://api.pendnt.dev/mcp"
}
}
}pendnt MCP in VS Code CLI installieren
$ code --add-mcp '{"name":"pendnt-plugin","type":"http","url":"https://api.pendnt.dev/mcp"}'pendnt MCP in Codex installieren
$ codex mcp add pendnt-plugin --url https://api.pendnt.dev/mcppendnt MCP in Codex config.toml installieren
~/.codex/config.toml
[mcp_servers.pendnt-plugin] url = "https://api.pendnt.dev/mcp"
pendnt MCP in Gemini CLI installieren
$ gemini mcp add -s user --transport http pendnt-plugin https://api.pendnt.dev/mcppendnt MCP in Gemini settings.json installieren
~/.gemini/settings.json
{
"mcpServers": {
"pendnt-plugin": {
"url": "https://api.pendnt.dev/mcp",
"type": "http"
}
}
}Konfiguration
MCP_TOOL_TIMEOUTPENDNT_API_KEYPENDNT_URL
| Name | Beschreibung | Typ |
|---|---|---|
| MCP_TOOL_TIMEOUT | — | |
| PENDNT_API_KEY | — | |
| PENDNT_URL | — |
Automatisierte Checks
Geluften am 15. Nov. 2026Vollständiger Bericht →Noch nicht verifiziert. Ein Server benötigt einen Score von 80, keine kritischen Befunde und genug Daten für unsere Prüfung. Wie die Checks funktionieren · Was du für mehr Punkte verbessern kannst
- Source Repository verknüpft und erreichbarpendnt/pendnt-plugin is public and reachablegithub.com/pendnt/pendnt-plugin ↗Bestanden
- Paket nennt dieses Repository als QuelleNicht geprüft
- Build-Provenienz (Sigstore-Attestierung)Nicht geprüft
- Open Source Lizenz (OSI)MITspdx.org/licenses/MIT.html ↗Bestanden
- Commit oder Release im letzten JahrLast commit or release 2026-09-15github.com/pendnt/pendnt-plugin ↗Bestanden
- OpenSSF ScorecardNicht geprüft
- Package-Name ähnelt keinem populären PackageNicht geprüft
- Keine kritischen Advisories im Paket oder seinen AbhängigkeitenNicht geprüft
- Keine versteckten Anweisungen an das Modell0 tool descriptions and the README read; no override phrases, credential paths or hidden charactersBestanden
- Destruktive Tools sind markiertNicht geprüft
- Remote-Endpoint beantwortet den MCP-HandshakeHTTPS endpoint answered 401 (sign-in required)Bestanden
README
Auf GitHub ansehenpendnt (Claude Code plugin)
Try it in 10 seconds — no account:
curl https://api.pendnt.dev/try?plain=1returns a 72-hour trial key (20 requests) with a quickstart.
Wires a Claude Code session — interactive or headless (claude -p) — up
to a pendnt workspace: durable human approvals, notifications, and a "run finished" ping,
without the agent needing a terminal.
"pendnt" is a placeholder product name. It's kept in exactly one place — PRODUCT_NAME in
lib/config.mjs — plus the name fields in
plugin.json, marketplace.json and
.mcp.json, and the matching MCP server name registered in
/app/src/routes/mcp.ts. Rename all of those together and it's renamed
everywhere that matters.
This plugin ships two independent ways to answer permission prompts headlessly — pick one (or both;
--permission-prompt-tool takes priority when both are wired up, see §1a below):
- A
PermissionRequesthook (hooks/permission-request.mjs) — works with plainclaude -p, no extra flags. Runs automatically before every tool-use prompt. - The
permission_promptMCP tool, via--permission-prompt-tool mcp__pendnt__permission_prompt— Claude Code's own dedicated mechanism for headless permission prompts (seeINTEGRATIONS.md§1a).
Plus a Notification hook and a Stop hook that both relay to POST /v1/notify — see
What's included below.
Install
Local marketplace (for trying this out before publishing anywhere)
This repo doubles as its own local marketplace — .claude-plugin/marketplace.json
lists this plugin with source: "./", pointing at the same directory plugin.json lives in. From
Claude Code:
/plugin marketplace add Pendnt/pendnt-plugin
/plugin install pendnt@pendnt
(or non-interactively: claude plugin marketplace add Pendnt/pendnt-plugin && claude plugin install pendnt@pendnt)
To publish for real later, split marketplace.json out into its own repo with source pointing at
this plugin's repo (see INTEGRATIONS.md §1d for the marketplace
manifest shape and github/git-subdir/npm/archive source types), then
claude plugin marketplace add <owner>/<repo> from anywhere.
Env vars
| Variable | Required | Default | Meaning |
|---|---|---|---|
PENDNT_API_KEY |
yes | — | Authorization: Bearer <key> for every call to the API (aio_..., from POST /dev/bootstrap locally, or your real workspace's API key in production). Without it, the PermissionRequest/Notification/Stop hooks all fail closed (deny / no-op) rather than erroring the session. |
PENDNT_URL |
no | https://api.pendnt.dev |
Base URL of the pendnt REST API — not including /mcp or /v1. Point this at http://localhost:8787 for local dev against wrangler dev (see below). |
PENDNT_APPROVAL_TIMEOUT_S |
no | 600 (10 min) |
Total wall-clock budget the PermissionRequest hook spends re-polling before it gives up and denies. Each individual poll is capped server-side at 25s (wait_s), so the hook loops GET /v1/requests/:id?wait_s=25 until this budget runs out. |
Set them in your shell, or in .claude/settings.json under env — see
settings.json docs. .mcp.json's ${PENDNT_URL:-...} /
${PENDNT_API_KEY} syntax is Claude Code's own env-var expansion for .mcp.json values (headers
and URLs) — see INTEGRATIONS.md §1e.
What's included
.mcp.json— registers thependntremote MCP server (${PENDNT_URL:-https://api.pendnt.dev}/mcp,Authorization: Bearer ${PENDNT_API_KEY}) so all 14 tools (request_approval,check_request,permission_prompt,notify,create_endpoint,list_endpoints,wait_for_event,schedule_wakeup,list_wakeups,cancel_wakeup,kv_get,kv_set,kv_delete,whoami) are available to the model directly, undermcp__pendnt__<tool>— exceptpermission_prompt, which Claude Code removes from its own visible tool list once named by--permission-prompt-tool(see below), since it's meant to be called by the CLI itself, not by the model.hooks/hooks.json— wires three hooks (shape matchessettings.json'shookskey, seeINTEGRATIONS.md§1d):PermissionRequest→hooks/permission-request.mjs. Fires before every tool-use prompt. POSTs a summary of the tool call toPOST /v1/requests(kind: "approval",wait_s: 25,timeout_s: $PENDNT_APPROVAL_TIMEOUT_S), then re-pollsGET /v1/requests/:id?wait_s=25until it's answered or the totalPENDNT_APPROVAL_TIMEOUT_Sbudget elapses. Prints exactly one JSON object perINTEGRATIONS.md§1b'sPermissionRequestcontract:
or{ "hookSpecificOutput": { "hookEventName": "PermissionRequest", "decision": { "behavior": "allow", "updatedInput": {} } } }{"behavior": "deny", "message": "..."}. Fails closed on every error path (missing API key, network failure, operator denies, request expires, timeout) — the only way to getallowis an explicit approval. An operator using the answer page's free-text box (always shown, even forkind: "approval"requests) is treated as approval only if the text starts with yes/y/allow/approve/ok — anything else denies with that text as the reason.Notification→hooks/notify.mjs. Relaysnotification_type/messagetoPOST /v1/notify. Cannot block Claude Code (per the hook's own semantics) and never tries to — always exits 0.Stop→hooks/stop.mjs. Relays a"run finished"message toPOST /v1/notifyat the end of every turn. Never returns{"decision":"block"}— it only notifies, it doesn't keep the agent going.
lib/— the three hook scripts' shared bits:config.mjs(env vars + thePRODUCT_NAMEconstant),client.mjs(thinfetchwrappers for/v1/requestsand/v1/notify),stdin.mjs(hook stdin JSON parsing). No npm dependencies — plain Node 18+ (fetch,AbortController) is enough.
The --permission-prompt-tool path (§1a)
Instead of (or in addition to — Claude Code prefers --permission-prompt-tool over hooks when both
apply) the PermissionRequest hook, you can point Claude Code's dedicated permission-prompt mechanism
directly at the permission_prompt MCP tool this plugin's .mcp.json registers — the one tool in this
server purpose-built for this flag (see /app/README.md's permission_prompt section for the full
contract):
export PENDNT_API_KEY=aio_...
export PENDNT_URL=https://api.pendnt.dev # or http://localhost:8787 for local dev
export MCP_TOOL_TIMEOUT=600000 # ms — must exceed PERMISSION_PROMPT_WAIT_S (default 540s)
claude -p --permission-prompt-tool mcp__pendnt__permission_prompt "deploy to prod"
Three things worth knowing before you rely on this path:
- Claude Code blocks the first turn until the
pendntMCP server connects, capped byMCP_TIMEOUT(default 30s, env var, milliseconds) — bump it if your network is slow:export MCP_TIMEOUT=60000(fromINTEGRATIONS.md§1a). - As of CLI ≥2.1.199, an
allowfrom a--permission-prompt-toolis converted todenyfor any MCP tool call flagged_meta["anthropic/requiresUserInteraction"]— this prompt tool can't rubber-stamp those regardless of what the operator answers (also fromINTEGRATIONS.md§1a). permission_promptholds the MCP tool call open server-side for up toPERMISSION_PROMPT_WAIT_S(env var on/app, default 540s = 9 min) waiting for the operator, unlike every other tool's ≤25swait_s. Claude Code's ownMCP_TOOL_TIMEOUT(its per-tool-call timeout, ms, default 30000) must be set higher than that or the CLI gives up first — henceexport MCP_TOOL_TIMEOUT=600000above.
Unlike request_approval, permission_prompt does return Claude Code's exact {behavior, updatedInput, updatedPermissions, interrupt} / {behavior:"deny", message, interrupt} contract natively — an allow
echoes the original input back as updatedInput, a deny (or an unanswered timeout) carries a
human-readable message. That's the same translation the PermissionRequest hook below does by hand for
its own hook-shaped contract; permission_prompt does it as the MCP tool result directly, which is what
--permission-prompt-tool actually reads.
Headless example
export PENDNT_API_KEY=aio_...
export PENDNT_URL=https://api.pendnt.dev
export MCP_TOOL_TIMEOUT=600000
claude -p --permission-prompt-tool mcp__pendnt__permission_prompt \
"review open PRs and merge the ones that pass CI"
Or, with the PermissionRequest hook doing the work instead (no extra flag needed once the plugin is
installed):
export PENDNT_API_KEY=aio_...
export PENDNT_URL=https://api.pendnt.dev
claude -p "review open PRs and merge the ones that pass CI"
Either way, every tool-use prompt now creates a durable approval request instead of blocking on a
terminal that doesn't exist — check your configured channels (email/web inbox — see /app/README.md's
"Channels" section for what's actually implemented today), answer from your phone, and the agent
resumes.
Running the hook locally against wrangler dev
From /app:
cd ../app
npm install
npm run db:migrate:local
npm run dev # http://localhost:8787
In another terminal, bootstrap a workspace + API key (see /app/README.md) and point the plugin's env
vars at it:
BOOT=$(curl -s -X POST http://localhost:8787/dev/bootstrap -d '{}')
export PENDNT_API_KEY=$(echo "$BOOT" | jq -r .api_key)
export PENDNT_URL=http://localhost:8787
Then either run a hook script directly, feeding it the JSON a real Claude Code hook invocation would send on stdin (useful for iterating on the hook without a full Claude Code session):
echo '{"session_id":"s1","cwd":"'"$PWD"'","tool_name":"Bash","tool_use_id":"toolu_1","tool_input":{"command":"deploy prod"}}' \
| PENDNT_APPROVAL_TIMEOUT_S=60 node hooks/permission-request.mjs
...or install the plugin locally (/plugin marketplace add Pendnt/pendnt-plugin from Claude Code, see
Install) and drive a real session — with PENDNT_URL/PENDNT_API_KEY exported in the
shell Claude Code runs in, every tool-use prompt round-trips through your local wrangler dev
instance. Answer the request the same way /app/README.md's curl walkthrough does: compute the HMAC
signature yourself (it's a pure function of the request id and SIGNING_SECRET) and POST /a/<id>/<sig>, or watch the log delivery channel's console output from wrangler dev for the
answer link once a real channel is wired up.
Caveats
- No npm dependencies by design (
fetch/AbortControlleronly) — every hook script runs under plainnode hooks/*.mjs, nonpm installstep inside the plugin itself. - The
PermissionRequesthook's fail-closed defaults (missing key, network error, timeout → deny) are a deliberate safety choice, not a limitation to work around — a headless agent with nobody to ask should not proceed by default. hooks/hooks.json'sNotificationmatcher is not narrowed to specificnotification_types — every notification (including ones that aren't permission-prompt-related) gets relayed. Narrow the matcher or filter insidehooks/notify.mjsif that's noisier than you want.
Guides
Practical writeups on running agents unattended, at pendnt.dev/guides: --dangerously-skip-permissions alternatives · claude -p on cron · the --permission-prompt-tool contract · hooks for unattended runs · exit codes: retry vs stay dead
pendnt MCP Fragen
Wie füge ich pendnt MCP zu Claude Code hinzu?
Führe claude mcp add --transport http pendnt-plugin https://api.pendnt.dev/mcp in deinem Terminal aus. Füge --scope user hinzu, damit der Server in jedem Projekt verfügbar ist.
Wie füge ich pendnt MCP zu Cursor hinzu?
Öffne ~/.cursor/mcp.json und füge den Server unter mcpServers hinzu, mit der Cursor-Config aus dem Installationsabschnitt oben.
Wie kann ich pendnt ohne Account ausprobieren?
Du kannst einen 72-Stunden-Testschlüssel mit 20 Requests erhalten, indem du einen spezifischen curl-Befehl ausführst.
Was passiert, wenn der API-Key fehlt oder ein Netzwerkfehler auftritt?
Das System ist auf Fail-Closed ausgelegt. Das bedeutet, die Anfrage wird abgelehnt oder es wird ein No-op ausgeführt, anstatt dem Agent die Fortsetzung zu erlauben oder einen Session-Error zu verursachen.