Skip to content

Releases

v0.4.0 — network trigger rules

Choose a tag to compare

@tstefank tstefank released this 25 Jun 10:16

Phase-3 alerting lands: pounce now classifies each correlated connection against the trigger rules in TRIGGERS.md, replacing the earlier ✓/? verdict with a type · severity · confidence finding model. Still the zero-FDA MVP (Phases 1–3); still observe-only.

Highlights

  • Trigger rules — ⚠ alert / ? to review / ✓ expected, led by a one-line verdict:
    • #1 capability mismatch — a local-only tool (built-in prior + learned baseline) egressed at all
    • #2 destination mismatch — a call connected somewhere it didn't declare (eTLD+1 compare; the declared host's own IPs count as legit)
    • #3 cloud-metadata / raw-IP properties
    • #4 novel destination — a new registrable domain for a (server, tool), soft during its first-session learning window
  • Learned baseline — persisted per-(server, tool) profile at ~/.pounce/profile.json, order-independent, learned on wrap session close.
  • Confidence = attribution × naming; low-confidence findings stay in the timeline rather than pushing.
  • Dedupe — one finding per (tool call, destination), shown as ×N.

The headline exfil demo now reads at a glance:

⚠ 1 alert — destination mismatch
  tools/call fetch  {"url":"https://example.com"}
     ✓ tcp 93.184.216.34:443  declared example.com
     ⚠ tcp 1.1.1.1:443  declared example.com — connected to 1.1.1.1 (no DNS)

The feature (#5) was adversarially reviewed before merge; 9 issues from that pass were fixed with tests.

Install (macOS)

curl -sSL -o pounce https://github.com/tstefank/pounce/releases/download/v0.4.0/pounce-darwin-arm64
chmod +x pounce && xattr -d com.apple.quarantine pounce 2>/dev/null || true

(Use pounce-darwin-amd64 on Intel.) Verify with checksums.txt.

Full changelog: v0.3.1...v0.4.0

v0.3.1 — verdict-first view + parallel correctness

Choose a tag to compare

@tstefank tstefank released this 18 Jun 12:13

A UX + correctness release on top of the MVP. Same capabilities (Phases 1–3, zero FDA), but the output now reads at a glance and parallel servers are handled correctly.

Legibility

pounce view defaults to a verdict-first summary — a one-line verdict, then each tool call with the connections it caused:

node fetch-server.mjs  <session>
? 1 connection to an IP with no DNS lookup

  tools/call fetch  {"url":"https://api.example.com"}
     ✓ tcp 93.184.216.34:443  api.example.com
     ? tcp 45.83.12.9:443  no DNS lookup — unverified destination

1 tool call · 2 connections · 1 unverified    (--timeline for the full log)
  • Two-level confidence: ✓ confirmed (the connection went where the call declared), ? unverified (a host the call didn't declare, or no DNS lookup at all). There's deliberately no red "⚠ malicious" verdict — passive correlation can't assert that (a no-DNS connection may just be a cached lookup), so pounce reports honest confidence and leaves hard alarms to a future rule layer.
  • --timeline keeps the full chronological protocol + OS log.
  • --all [--limit N] rolls several sessions into one overview — the view when multiple servers run at once.

Parallel correctness

  • Destination-matched attribution: a connection now attributes to the call whose arguments declared its host (via DNS), so concurrent tool calls to different hosts split correctly instead of both landing on the latest call.
  • Unique session ids: two shims starting in the same millisecond no longer collide into one log (the id carries the PID).
  • DNS is shared: resolutions are broadcast to every session (connections stay attributed by PID subtree), so a legitimate connection isn't mis-flagged just because mDNSResponder did the lookup.

Validated live: two servers wrapped at once (one trojan, one honest) show one ? and one ✓, correctly separated. scripts/demo-parallel.sh reproduces it.

See docs/correlation.md for the model and caveats (DNS-cache false positives, conservative declaration).

Install

Static binaries, no dependencies:

chmod +x pounce-darwin-arm64   # or -amd64 on Intel
xattr -d com.apple.quarantine pounce-darwin-arm64
mv pounce-darwin-arm64 /usr/local/bin/pounce

Verify with shasum -a 256 -c checksums.txt.

Full changelog: v0.3.0...v0.3.1

v0.3.0 — MVP: intent↔effect correlation with divergence flagging

Choose a tag to compare

@tstefank tstefank released this 12 Jun 15:27

The MVP. pounce now closes the loop: declared intent (tool calls) → actual OS effect (network connections) → divergence. Other tools see one half — the tool call or the syscall. pounce ties them together and flags where they disagree. All of this is zero Full Disk Access.

14:00:00.000 ->  tools/call fetch  {"url":"https://api.example.com/data"}  -> ok
14:00:00.050 · dns  api.example.com → 93.184.216.34   node pid 999
14:00:00.200 · net  tcp 93.184.216.34:443  out  node pid 999
14:00:00.400 · net  tcp 45.83.12.9:443     out  node pid 999

correlation (window 3s):
  tools/call fetch → caused 2
      tcp 93.184.216.34:443  (api.example.com, declared)   ← declared host → DNS → connection ✓
      tcp 45.83.12.9:443     (unresolved — no DNS)          ← hardcoded IP
  ⚠ 1 undeclared destination — IP not resolved from any host:
      tcp 45.83.12.9:443     (unresolved — no DNS)

What's new (Phase 3 — correlation)

  • internal/correlate joins each request to the connections that occurred during its execution window, and flags two kinds of divergence:
    • Out-of-band (timing): a connection while no tool call was active — the server reached out on its own.
    • Undeclared destination (DNS): a connection to an IP that no DNS lookup produced — a hardcoded/exfil destination, caught even inside a benign call's window. This is the teeth: time-based attribution alone can't catch a rogue server that connects to a malicious IP under cover of a legitimate fetch.
  • The pktap parser now decodes DNS (query→response, joined by transaction id) into host → IPs, so connections can be checked against what the server actually resolved. Declared hosts come from http(s):// URLs in tool-call args (conservatively — we never over-declare and suppress an alarm).
  • view shows DNS resolutions and a correlation section; --window tunes the attribution window.
  • Validated live on macOS: a real example.com connection ties back to its DNS lookup; a hardcoded 1.1.1.1 connection is flagged.

See docs/correlation.md for the mechanics and the honest caveats (DNS-cache false positives, DoH, correlation ≠ proof).

The full picture (Phases 1–3)

Tier Needs Gives
Protocol timeline nothing declared tool calls
Network capture (sudo pounce daemon) root, no FDA actual per-process connections
Correlation (pounce view) nothing the join + divergence flags

Install

Static binaries, no dependencies:

chmod +x pounce-darwin-arm64   # or -amd64 on Intel
xattr -d com.apple.quarantine pounce-darwin-arm64
mv pounce-darwin-arm64 /usr/local/bin/pounce

Verify with shasum -a 256 -c checksums.txt. Build from source: go build -o pounce ./cmd/pounce.

Next

Phase 4: eslogger file/exec capture (root + FDA) — file reads and process spawns join through the same correlator. A rules/actions sink can then fire on a detected divergence.

Full changelog: v0.2.0...v0.3.0

v0.2.0 — OS ground truth: per-process network capture

Choose a tag to compare

@tstefank tstefank released this 12 Jun 12:17

The first release with OS ground truth. Beyond the declared tool calls (Phase 1), pounce can now show the actual per-process network activity those calls cause — attributed to the wrapped server's PID subtree.

sudo pounce daemon        # opt-in privileged capture: root, NO Full Disk Access
pounce wrap -- <server>   # auto-reports its subtree to the daemon; no privilege
pounce view               # network events interleaved into the timeline
13:01:28.517 · net  tcp 104.20.23.154:443  out  curl pid 50592   ← the connection a tool caused

What's new (Phase 2 — network tier)

  • pounced daemon (sudo pounce daemon): runs the system tcpdump on the pktap pseudo-interface as root, attributes every connection to a session's PID subtree, and streams it back over a local Unix socket. One capture stream serves all wrap sessions. Root-only, no FDA.
  • Privilege split per the design: the client-launched wrap shim stays unprivileged and just reports its child PID subtree; the socket verifies peer credentials (LOCAL_PEERCRED). No daemon running → wrap behaves exactly as in v0.1.x.
  • view interleaves network events into the timeline and records capture provenance (tcpdump/macOS versions).
  • Hardened attribution: anchored parsing, IPv6, and fail-safe-to-"attribution unavailable" with a drift counter + a live CI self-check, so a future tcpdump/macOS format change trips CI, not users.
  • Also includes the v0.1.x line: tool-execution-error surfacing, and a wrap stdin-hang fix.

A note on the capture mechanism (macOS 26)

Network attribution needs a per-packet PID. On macOS 26 / tcpdump Apple-158 the binary paths don't expose it: the public libpcap API cannot enable DLT_PKTAP (confirmed with a pure-C probe — not a Go bug), and written pcap/pcapng drops the pid. So pounce reads the pid from the system tcpdump's text pktap metadata (-k NP) — same kernel pid — with strict, drift-guarded parsing. Details and the future raw-BPF option are recorded in the repo.

Install

Static binaries, no dependencies. Download for your Mac, then:

chmod +x pounce-darwin-arm64   # or -amd64 on Intel
xattr -d com.apple.quarantine pounce-darwin-arm64   # if Gatekeeper blocks it
mv pounce-darwin-arm64 /usr/local/bin/pounce

Verify with shasum -a 256 -c checksums.txt. Or build from source: go build -o pounce ./cmd/pounce.

Not included

File/exec capture via eslogger (Phase 4: root + FDA) and intent↔effect correlation (Phase 3) — next on the roadmap. Linux is later.

Full changelog: v0.1.1...v0.2.0

v0.1.1 — surface tool-execution errors

Choose a tag to compare

@tstefank tstefank released this 08 Jun 18:33

Patch release. Phase 1 (stdio shim + protocol tee), now hardened against real-world MCP traffic.

Fixed

  • view now surfaces tool-execution errors. MCP reports a failed tools/call two ways: a JSON-RPC error object, or a successful response whose result.isError is true (the tool ran but failed). Previously only the first was flagged, so execution-level failures rendered as -> ok. They now show -> tool error: <message> and count in the summary.

Validated against real servers

Tested end-to-end through pounce against @modelcontextprotocol/server-everything (notifications, streaming progress, high-volume logging, resources, prompts), server-memory, server-sequential-thinking, and OpenClaw — both as an MCP client (OpenClaw → pounce → server) and as an MCP server (pounce wrap -- openclaw mcp serve). Forwarding remained byte-for-byte identical throughout.

Install

Download the binary for your Mac below, then:

chmod +x pounce-darwin-arm64   # or -amd64 on Intel
xattr -d com.apple.quarantine pounce-darwin-arm64   # if Gatekeeper blocks it
mv pounce-darwin-arm64 /usr/local/bin/pounce

Verify with shasum -a 256 -c checksums.txt. Or build from source: go build -o pounce ./cmd/pounce.

Full changelog: v0.1.0...v0.1.1

v0.1.0 — Phase 1: stdio shim + protocol tee

Choose a tag to compare

@tstefank tstefank released this 08 Jun 13:31

First release of pounce — ground truth for what AI coding agents and MCP servers actually do.

Wrap any MCP server in one line and see every JSON-RPC tool call it makes. Observe-only: the bytes between client and server are forwarded byte-for-byte, so the wrapped server behaves exactly as if pounce weren't there.

pounce wrap -- npx -y @modelcontextprotocol/server-filesystem /tmp
pounce view

What's in this release (Phase 1)

  • wrap — transparent stdio tee: launches the real MCP server, forwards stdin/stdout/stderr unchanged, and records every JSON-RPC message to ~/.pounce/sessions/<id>.jsonl.
  • view — replays the session as a tool-call timeline: pairs each request with its response (direction-aware id matching), summarizes initialize / tools/list / roots/list results, with optional ANSI color.
  • Newline-delimited JSON-RPC 2.0 parsing confirmed against the MCP 2025-06-18 spec; handles legacy batch frames.
  • Architected so an HTTP/SSE proxy and a log/hook ingester can slot in behind the same intent-source interface later.

No privileges required. macOS-first.

Install

Download the binary for your Mac below, then:

chmod +x pounce-darwin-arm64   # or -amd64 on Intel
xattr -d com.apple.quarantine pounce-darwin-arm64   # if Gatekeeper blocks it
mv pounce-darwin-arm64 /usr/local/bin/pounce

Verify with shasum -a 256 -c checksums.txt. Or build from source: go build -o pounce ./cmd/pounce.

Binaries are unsigned (Phase 5 will add notarized/Homebrew packaging). Not yet on a Homebrew tap.

Not in this release

OS-level capture (files/network/processes) and intent↔effect correlation — see the roadmap in the README. Linux support is later too; these are darwin/amd64 + darwin/arm64 only.