More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIMuseMuseDotsDots+21 more

    hetzer

    1

    Enterprise-grade secret mediation and stream redaction for AI agents to prevent credential leaks.

    $9.90

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    hetzer

    hetzer

    Example session with this skill installed

    I need to push the current changes to the main branch on GitHub, but I don't want to expose my GITHUB_TOKEN in the logs. How do I do this safely?

    • Read your context and instructions
    • Compiled the hetzer

    I will execute the git push using Hetzer's scoped execution to ensure your GITHUB_TOKEN remains masked and isolated from the session logs.

    Secure Git Push Execution

    StepActionStatus
    1Verify github-token in vaulthetzer_vault_has(github-token) -> true
    2Prepare scoped environment--strict isolation enabled
    3Execute mediated commandhetzer exec --allow github-token -- git push
    4Stream RedactionActive (sliding-window)
    
    # Executing scoped command...
    hetzer exec --allow github-token --strict -- git push origin main
    
    # [Hetzer] Mediation active for: github-token
    # [Hetzer] Redacting stdout/stderr streams...
    # Enumerating objects: 5, done.
    # Counting objects: 100% (5/5), done.
    # Delta compression using up to 8 threads
    # Compressing objects: 100% (3/3), done.
    # Writing objects: 100% (3/3), 342 bytes | 342.00 KiB/s, done.
    # Total 3 (delta 2), reused 0 (delta 0), pack-reused 0
    # To github.com:user/repo.git
    #    a1b2c3d..e4f5g6h  main -> main
    

    Next steps

    • Run hetzer_vault_list() to see other available credential scopes for this project.
    • If you need to add new deployment keys, run hetzer creds set <id> in your local terminal.
    • Review .hetzer/brokers/ if you want to transition this to a loopback proxy for added memory safety.

    Connects securely to your tools. The creator never sees your data.

    About this skill

    Agents handling cleartext API keys, database URLs, and tokens in shell logs or prompt histories represent a critical security vulnerability. Hetzer solves this by providing enterprise-grade secret mediation and stream redaction, ensuring models never touch raw credentials.

    What it does

    • Secret Masking: Replaces raw strings with secretRef syntax to prevent credentials from leaking into model context or logs.
    • Scoped Execution: Runs shell commands through a mediator that injects secrets only at the subprocess boundary.
    • Stream Redaction: Continuously filters child process stdout and stderr through a sliding-window redactor to catch accidental leaks.
    • HTTP Brokering: Uses loopback proxies to handle API authentication, keeping upstream keys entirely out of process memory.
    • Canary Tripwires: Injects honeytokens to detect and terminate malicious scripts attempting to exfiltrate data.

    How it works

    1. Registration: The user registers sensitive keys out-of-band using hetzer creds set to keep them in an AES-256-GCM vault.
    2. Reference: The agent uses the secretRef:id syntax in configuration files or environment variables.
    3. Execution: The agent wraps shell commands in hetzer exec --allow <id> to grant temporary, scoped access.
    4. Verification: The agent uses MCP tools like hetzer_vault_has to check credential availability without viewing the secret itself.

    Frameworks & tools

    Built for Node.js environments (v22.5.0+). Compatible with MCP-enabled agents including Claude Code, Cursor, Windsurf, and Roo Code.

    Why this beats prompting it yourself

    System prompts cannot reliably prevent a model from echoing a variable it just read or logging it during a failed build. Hetzer enforces safety at the process level, providing a physical barrier that works even if the model ignores instructions.

    Use cases

    • Secure Publishing: Running npm publish or git push without exposing tokens in the terminal scrollback.
    • CI/CD Automation: Mediating database migrations where the agent requires access to a production connection string.
    • Untrusted Scripts: Executing third-party dependencies or external scripts within a sandboxed container environment.

    Known limitations

    Requires Node.js 22.5.0 or higher. It does not intercept low-level kernel APIs or memory scrapers outside the mediated process tree.

    Requires Node.js 22.5.0+. Does not intercept low-level kernel APIs or memory scrapers. Security relies on same-user trust for vault key access.

    How to use

    1. 1

      Connect your agent to the Agensi MCP

      Copy the prompt and paste it into Claude, ChatGPT, Cursor or any agent that supports MCP. It sets up the connection for you. Manual setup

    2. 2

      Sign in to Agensi

      Your agent shows a sign-in link. Sign in and click Allow.

    3. 3

      Ask for what you need

      Your agent loads this skill and uses it on your task. It always asks before any payment.

    Reviews

    No reviews yet

    Be one of the first to try it. Every listed skill goes through the trust checks below.

    Security scanned

    Checked by our 8-point scan before listing

    Fresh listing

    Recently published to Agensi

    Money-back guarantee

    Doesn't do what its page promises? You get your money back.

    Trust & safety

    Security scan

    Security scan passed 1 month ago

    Requires

    hetzer
    Node.js
    prisma

    Permissions

    Terminal / Shell
    Listed1 month ago

    What's inside

    Frequently Asked Questions

    Hetzer prevents credentials like API keys and database URLs from appearing in plain text within LLM logs, shell history, or prompt contexts by using secure secret references and real-time stream redaction.

    Hetzer requires Node.js v22.5.0 or higher and is designed for MCP-enabled environments, making it compatible with agents like Claude Code, Cursor, Windsurf, and Roo Code.

    Unlike system prompts which can be ignored or bypassed by a model, Hetzer acts as a physical process-level barrier that replaces raw strings with references, ensuring the model never interacts with the actual secret.

    You get the complete Hetzer toolset including the AES-256-GCM vault system, the `hetzer exec` mediator for scoped shell access, and the MCP-compatible verification tools.

    Setup involves registering your sensitive keys out-of-band using the `hetzer creds set` command, which stores them securely in a local vault before you reference them in your agent's workflow.

    New in Security