More screenshots

    Works with the AI Agents you already use

    Claude CodeClaude CodeCursorCursorCodex CLICodex CLIDeepSeekDeepSeekMuseMuse+22 more

    EgressLeak: Agent Outbound Egress & PII Auditor

    1

    Audit and block coding agent PII leaks, telemetry tracking, and unauthorized HTTP egress with deterministic hooks.

    $6

    Secure checkout via Stripe

    Money-back guarantee

    Converts to your local currency at checkout

    Security scanned
    EgressLeak: Agent Outbound Egress & PII Auditor

    EgressLeak: Agent Outbound Egress & PII Auditor

    Example session with this skill installed

    Audit my Claude Code session logs for email leaks in outbound requests and generate a guardrail hook.

    • Read your context and instructions
    • Compiled the egressleak
    • Generated the document

    I have audited your local configuration and session transcripts for egress leaks. The scan identified that your oauthAccount.emailAddress is currently being injected into User-Agent headers for outbound WebFetch calls.

    Egress Audit Report

    Rule IDCategoryStatusFinding
    EGL001IdentityFAILFound personal email in ~/.claude.json
    EGL002TelemetryFAILActive machineID detected; DISABLE_TELEMETRY not set
    EGL007EgressWARNEmail leaked in User-Agent during curl tool use
    EGL008EgressPASSNo identity leaks found in URL query parameters
    EGL011EgressINFOOutbound traffic detected to api.sec.gov and nominatim.openstreetmap.org
    EGL014FilterCLEANLoopback traffic (localhost:3000) excluded from report

    Generated PreToolUse Hook

    // ~/.claude/hooks/egress-guard-hook.mjs
    export async function preToolUse({ toolName, arguments: args, env }) {
      const sensitivePatterns = [/user@example\.com/i, /\/Users\/jdoe/i];
      const argString = JSON.stringify(args);
    
      if (sensitivePatterns.some(pattern => pattern.test(argString))) {
        console.error(`[EgressLeak] Blocked ${toolName}: Potential PII leak detected.`);
        return { field: "arguments", value: args, error: "Tool execution blocked due to PII leak." };
      }
    
      return { field: "arguments", value: args };
    }
    

    Settings Configuration

    Add this to your ~/.claude/settings.json:

    {
      "hooks": {
        "PreToolUse": "node ~/.claude/hooks/egress-guard-hook.mjs"
      },
      "env": {
        "DISABLE_TELEMETRY": "1",
        "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1"
      }
    }
    

    Next steps

    1. Save the hook script to your local hooks directory.
    2. Update your global settings file with the provided JSON block.
    3. Run node scripts/egressleak.mjs --json to verify the fix in a new session.

    social

    1793942658654-27cz.png

    PDF · document

    Generated

    Example file from a real run - the skill writes it into your workspace.

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

    About this skill

    logo.png Coding agents like Claude Code and Codex CLI can unintentionally leak your email, OS username, and API tokens through outbound HTTP headers and URL parameters. This tool audits your local config files and session transcripts to find these leaks and locks down the egress.

    What it does

    • Identity audit scans ~/.claude.json and ~/.gitconfig for PII and active hardware telemetry IDs.
    • Transcript analysis parses session logs to detect leaked emails in User-Agent headers and ?authuser= queries.
    • Egress monitoring flags tool calls contacting external non-loopback domains or uploading local files via curl.
    • Telemetry detection identifies active Statsig or GrowthBook tracking IDs that bypass standard opt-outs.
    • Guardrail generation produces deterministic PreToolUse hooks to intercept and block sensitive data transmission.
    • False-positive filtering distinguishes between synthetic AI commit emails and real personal PII.

    How it works

    1. Run the egressleak.mjs script to scan local configuration files and project session transcripts.
    2. Review the Two-Plane report covering identity exposure (Plane 1) and outbound HTTP egress (Plane 2).
    3. Use the --emit-hook flag to generate a custom PreToolUse guardrail script.
    4. Merge the generated JSON snippet into your global or project-level agent settings to enforce the blocklist.

    Frameworks & tools

    Zero-dependency Node.js script compatible with Claude Code, Codex CLI, and any agent using the Model Context Protocol (MCP).

    Why this beats prompting it yourself

    Standard system prompts often fail to suppress PII when an agent autonomously invokes shell tools like curl or requests. This skill uses deterministic file-system auditing and programmatic guardrails that operate outside the LLM's context window, ensuring leaked data is caught even if the agent "forgets" its instructions.

    Use cases

    • Audit local agent logs for leaked API keys or Bearer tokens before sharing transcripts.
    • Prevent coding agents from including your personal email in outbound HTTP headers.
    • Block agents from establishing unauthorized remote SSH MCP tunnels.
    • Strip hardware and machine telemetry IDs from agent-initiated requests.

    Known limitations

    Requires Node.js to run the audit scripts. Audit coverage is currently focused on Claude Code and Codex CLI directory structures.

    Find more skills like this on the Claude Skills Marketplace, the Codex Skills Marketplace and the Gemini Skills Marketplace, or browse Claude Skills for LLM Ops.

    Requires Node.js for CLI audits. Limited to Claude Code and Codex CLI directory structures for session transcript parsing.

    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 buying a skill.

    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 11 days ago

    Software
    egressleakNode.js@modelcontextprotocol/server-filesystem

    Permissions

    Terminal / Shell
    Network Access
    Listed11 days ago

    What's inside

    Frequently Asked Questions

    This skill protects your privacy by auditing local configuration files and session transcripts for PII (like emails and hardware IDs) that coding agents often leak via HTTP headers or telemetry tracking. It then generates deterministic guardrails to intercept and block these leaks before they leave your machine.

    It is optimized for Claude Code and Codex CLI, but its zero-dependency Node.js script and generated guardrails are compatible with any agent platform that supports the Model Context Protocol (MCP) or custom tool hooks.

    Unlike system prompts which can be ignored or forgotten by an LLM, egressleak uses deterministic programmatic hooks. These operate outside the agent's context window, ensuring that even if an agent attempts a 'curl' or 'request' that contains PII, the transmission is caught and blocked by the file-system guardrail.

    You will receive the 'egressleak.mjs' audit script, a comprehensive documentation guide for interpreting the Two-Plane reports, and the logic to generate custom 'PreToolUse' guardrail snippets for your agent configuration.

    No, this tool operates locally using Node.js to scan your specific directory structures and logs. Your sensitive configuration data and session transcripts are audited on your machine and are never sent to an external server for processing.

    Installation is straightforward: ensure you have Node.js installed, run the audit script against your local config files, and then merge the resulting JSON guardrail snippet into your agent's global or project settings.

    New in LLM Ops