Interceptor

What this skill does

## Customization

**Before executing, check for user customizations at:**
`~/.claude/PAI/USER/SKILLCUSTOMIZATIONS/Interceptor/`

If this directory exists, load and apply any PREFERENCES.md, configurations, or resources found there. These override default behavior. If the directory does not exist, proceed with skill defaults.


## MANDATORY: Voice Notification (REQUIRED BEFORE ANY ACTION)

**You MUST send this notification BEFORE doing anything else when this skill is invoked.**

1. **Send voice notification**:
   ```bash
   curl -s -X POST http://localhost:31337/notify \
     -H "Content-Type: application/json" \
     -d '{"message": "Running the WORKFLOWNAME workflow in the Interceptor skill to ACTION"}' \
     > /dev/null 2>&1 &
   ```

2. **Output text notification**:
   ```
   Running the **WorkflowName** workflow in the **Interceptor** skill to ACTION...
   ```

**This is not optional. Execute this curl command immediately upon skill invocation.**

# Interceptor — Stealth Browser Automation

**Tool:** `interceptor` CLI — Chrome extension that controls the real browser from the inside.
**Repo:** https://github.com/Hacker-Valley-Media/slop-browser
**Install:** `~/Projects/interceptor` (built from source — see `Workflows/Update.md`)

### Why Interceptor?

agent-browser (the Browser skill) uses CDP — sites can detect it. Interceptor is a Chrome extension that operates through the actual browser UI. No debugger, no automation flags, no separate browser instance. You stay logged in, you pass bot detection, the agent sees what you see.

### Prerequisites

- Chrome or Brave running with the Interceptor extension loaded
- `interceptor` CLI in PATH (`/opt/homebrew/bin/interceptor`)
- `interceptor-daemon` in PATH (`/opt/homebrew/bin/interceptor-daemon`)
- Native messaging manifest registered (`bash ~/Projects/interceptor/scripts/install.sh --chrome --skip-extension`)
- (Optional, macOS) `interceptor-bridge` helper app — see "Bridge" section below

### Bridge — macOS Native Helper App

The bridge is an optional Swift helper that runs as a LaunchAgent and unlocks
capabilities the Chrome extension can't provide on its own: OS-level synthetic
input (`act --os`), accessibility tree of native macOS apps, app control,
clipboard, screen capture beyond Chrome, audio/speech, files, notifications,
HealthKit, Apple Intelligence. ~95% of typical work doesn't need it.

**Status check:** `interceptor status` reports `bridge: running` with PID + socket
when it's up, or `bridge: not running` when it isn't.

**Lifecycle (install / verify / troubleshoot / uninstall) lives entirely in
`Workflows/Update.md` section 6.** Future updates flow through the Update
workflow — never reach for the upstream `install-bridge.sh` directly; that
script breaks on Apple Silicon (`/usr/local/bin` needs sudo, but sudoing the
whole script makes `launchctl bootstrap` target uid 0 instead of the user).
The skill's procedure is the canonical one.

**Security model — read before installing:**

- Transport is a **UNIX domain socket** at `/tmp/interceptor-bridge.sock`.
  Local-only; no network listener; not reachable from another machine.
- **No authentication on the socket.** Any local process running as your user
  can connect and execute every bridge action — including synthetic input,
  clipboard read, audio capture, screenshots. macOS TCC permissions
  (Accessibility, Input Monitoring, Screen Recording, Microphone) are granted
  to the bridge once and inherited by every socket client.
- **Marginal risk is supply-chain:** a malicious package installed via
  bun/brew/npm gains a one-step path to OS-level input/screen/clipboard without
  needing its own permission grants — the bridge has them.
- Single-user Mac threat model: acceptable, since anything running as you can
  already do this with effort. Multi-user Macs need socket hardening (see
  Update.md section 6c).
- Binary built locally from `~/Projects/interceptor/interceptor-bridge/Sources/`,
  not a downloaded prebuilt. Provenance is Swift source we just compiled.

---

## Compound Commands (Preferred)

These collapse multi-step patterns into single invocations — fewer tool calls, fewer tokens:

```bash
interceptor open "https://example.com"              # Open URL, wait, return tree + text
interceptor open <url> --tree-only|--text-only|--full|--no-wait
interceptor read                                     # Tree + text for active tab
interceptor read <ref>                               # Tree + text for element subtree
interceptor read --include-style|--include-frames
interceptor act <ref>                                # Click + wait + return updated tree + diff
interceptor act <ref> "value"                        # Type + wait + return updated tree
interceptor act <ref> --os                           # OS-level trusted input (requires bridge)
interceptor act <ref> --keys "Enter"                 # Send keyboard shortcut
interceptor inspect                                  # Tree + text + network log + headers
interceptor inspect --net-only                       # Network only
```

## Core Commands

```bash
# State + discovery
interceptor state [--full]              # DOM tree + metadata
interceptor tree [--filter all] [--depth N] [--max-chars N]
interceptor diff                         # Changes since last state/tree read
interceptor find "query" [--role button] # Find elements by name
interceptor text [<index|ref>]
interceptor html <index|ref>

# Element interaction
interceptor click <ref>                  # Click by ref (eN)
interceptor click <ref> --at X,Y         # Click at coordinates
interceptor dblclick <ref> --at X,Y
interceptor rightclick <ref> --at X,Y
interceptor type <ref> <text> [--append]
interceptor type "role:name" <text>      # Semantic selector
interceptor select <ref> <value>         # Dropdown
interceptor focus|hover <ref>
interceptor drag <ref> --from X,Y --to X,Y [--steps N] [--duration MS]
interceptor keys "<combo>"               # e.g. "Control+A"

# Navigation + tabs
interceptor navigate <url>
interceptor back | forward
interceptor scroll <up|down|top|bottom>
interceptor wait <ms> | wait-stable [--ms N] [--timeout N]
interceptor tabs
interceptor tab new [url] | tab close [id] | tab switch <id>

# Capture
interceptor screenshot [--save] [--format png|jpeg] [--full] [--clip X,Y,W,H] [--element N]
interceptor eval <code> [--main]         # JS in isolated or main world
interceptor capture start | frame | stop # tabCapture stream

# Style injection (test redesigns live)
interceptor style inject --css "<rules>" [--top-only]
interceptor style remove <handle>

# Cookies
interceptor cookies <domain>
interceptor cookies set <json>
interceptor cookies delete <url> <name>
```

## Network

```bash
# Passive capture (always-on, no CDP fingerprint)
interceptor net log [--filter <pat>] [--limit N] [--since <ts>]
interceptor net headers [--filter <pat>]   # CSRF, auth headers
interceptor net clear

# Request override (passive, no CDP)
interceptor override "*pattern*" key=value
interceptor override clear

# CDP-attached interception (explicit opt-in — leaves debugger banner)
interceptor network on [patterns...]
interceptor network off
interceptor network log
interceptor network override on '<json>'
interceptor network override off

# SSE streams (LLM responses, live feeds)
interceptor sse log [--filter <pat>] [--limit N]
interceptor sse streams
interceptor sse tail [--filter <pat>]

# Header rewriting
interceptor headers add <name> <value>
interceptor headers remove <name>
interceptor headers clear
```

## Recording (Session Monitor)

Record real user actions on the active tab, replay as a deterministic plan script.

```bash
interceptor monitor start ["instruction"]   # Start recording
interceptor monitor pause | resume
interceptor monitor stop                     # End + emit summary
interceptor monitor status [--all]
interceptor monitor list                     # All sessions
interceptor monitor tail [--current] [--raw] # Live tai