ClawTV

AI-powered Apple TV remote that can see the screen and navigate any app autonomously using vision + remote control.

When to use (trigger phrases)

Use this skill immediately when the user asks:

• - "play [movie/show] on Apple TV"
• "search for [content] on [Netflix/Plex/YouTube/etc]"
• "open [app] on the TV"
• "turn on subtitles" / "go to TV settings"
• "what's playing on Apple TV?"
• "take a screenshot of the TV"
• Any Apple TV navigation or control task

Quick start

CODEBLOCK0

Required Credentials

ANTHROPICAPIKEY (Required for AI/Vision Mode)

The do command (AI agent mode) requires an Anthropic API key to access Claude's vision API for screenshot analysis and navigation decisions.

CODEBLOCK1

Or add to your shell profile (~/.zshrc, ~/.bashrc).

Note: This is only required for the do command. Manual commands (cmd, type, launch) and plex direct control do not use the API.

Plex Credentials (Optional)

For instant Plex playback without the vision loop, add these to ~/.clawtv/config.json:

CODEBLOCK2

• - plexurl: Your Plex server address (local or remote)
• plextoken: Authentication token from your Plex account
• plex_client: Name of the Plex client on your Apple TV

Get your Plex token: https://support.plex.tv/articles/204059436-finding-an-authentication-token-x-plex-token/

Privacy & Data

What Data is Collected and Sent

Screenshots:

• - ClawTV captures screenshots of your Apple TV screen using QuickTime Player or Xcode
• Screenshots are saved locally to ~/.clawtv/screenshots/ with timestamps
• When using the do command (AI agent mode), screenshots are sent to Anthropic's Claude API for vision analysis
• Screenshots may contain sensitive on-screen content including:

Anthropic API:

• - Only the do command sends data to Anthropic
• Data sent: screenshots (JPEG compressed) + your goal/instruction + conversation history
• Anthropic's data retention policy: https://support.anthropic.com/en/articles/7996885-how-long-do-you-store-personal-data
• Manual commands (cmd, type, launch) and Plex direct control do NOT send any data to external APIs

Credential Storage

Apple TV Pairing Credentials:

• - Stored unencrypted in ~/.clawtv/config.json in your home directory
• Contains device identifiers and pairing tokens for remote control
• File permissions: readable only by your user account (standard Unix permissions)

Plex Tokens (if configured):

• - Stored unencrypted in the same ~/.clawtv/config.json file
• Grants full access to your Plex server and library
• Can be used to play, pause, search, and control any Plex client

Anthropic API Key:

• - Stored in environment variables or your shell profile
• Grants access to your Anthropic account and incurs API usage charges

Recommendations

1. 1. Use a budget-limited API key: Set spending limits on your Anthropic account to prevent unexpected charges
2. Review config file permissions: Ensure ~/.clawtv/config.json is only readable by your user
3. Be aware of screenshot content: Screenshots are sent to Anthropic's API and may contain sensitive information
4. Monitor API usage: The do command can make multiple API calls per task (5-20 steps typical)
5. Use manual commands when possible: cmd, type, and launch have zero API cost and send no data externally

Security Considerations

Plaintext Credential Storage

• - Apple TV pairing credentials and Plex tokens are stored in plaintext in INLINECODE20
• The file is in your user home directory (~/.clawtv/) with standard Unix file permissions
• Any process running as your user can read these credentials
• If your Mac is compromised, these credentials are accessible
• Consider this when deciding whether to configure Plex integration

Screenshot Privacy

• - Screenshots may contain sensitive content visible on your TV screen
• Screenshots are saved locally to ~/.clawtv/screenshots/ and persist until manually deleted
• When using AI agent mode (do), screenshots are transmitted to Anthropic's servers
• DRM content (Netflix, Disney+, etc.) cannot be captured via QuickTime, but works with Xcode method
• Review screenshot history periodically and delete sensitive captures

API Cost and Autonomous Behavior

• - The do command runs in a loop (up to 20 steps) and makes Claude API calls automatically
• Each step = 1 API call with screenshot (~$0.01-0.02 per step depending on model)
• A stuck or confused agent could consume all 20 steps before giving up
• Cost implications: Complex tasks can cost $0.10-0.20; monitor your Anthropic usage dashboard
• Recommendation: Set spending limits on your Anthropic account

Manual Commands are API-Free

• - cmd, type, launch, and plex commands do not use the Claude API
• No screenshots are sent externally when using these commands
• Zero cost, zero external data transmission
• Use these for privacy-sensitive operations

Network Exposure

• - ClawTV communicates with your Apple TV over your local network using the Companion protocol
• Plex integration (if configured) communicates with your Plex server (local or remote)
• No external network access except:

Setup (first-time only)

1. Install dependencies

CODEBLOCK3

For QuickTime screenshot method (recommended):
CODEBLOCK4

2. Pair with Apple TV (remote control)

CODEBLOCK5

Pairing credentials are saved to ~/.clawtv/config.json.

3. Set up screenshots

QuickTime (recommended):
CODEBLOCK6

• - QuickTime Player opens and selects your Apple TV as video source
• Accept the AirPlay pairing on your TV (one-time PIN)
• Subsequent runs reuse the existing mirror instantly (~0.6s per screenshot)

Xcode (fallback for DRM apps):

1. 1. On Apple TV: Settings > Privacy & Security → enable "Share with App Devs"
2. Then Settings > Remotes and Devices > Remote App and Devices
3. On Mac: Open Xcode, press Cmd+Shift+2 (Devices)
4. Click your Apple TV in sidebar, enter pairing code
5. Keep Xcode Devices window open while using ClawTV

4. Set API key

CODEBLOCK7

Or add to your shell profile (~/.zshrc, ~/.bashrc).

5. Optional: Plex direct control setup

For instant Plex playback without vision loop, add to ~/.clawtv/config.json:

CODEBLOCK8

Get your Plex token: https://support.plex.tv/articles/204059436-finding-an-authentication-token-x-plex-token/

Commands

AI Agent Mode (do)

Tell ClawTV what you want and it figures out the rest using vision + reasoning.

CODEBLOCK9

How it works:

1. 1. Takes screenshot of Apple TV
2. Sends to Claude vision API to analyze UI
3. Decides what to do (navigate, select, type, launch app)
4. Sends remote commands
5. Takes another screenshot to verify
6. Repeats until goal is accomplished (max 20 steps)

Examples:
CODEBLOCK10

Token optimizations (automatic):

• - Plex goals bypass vision entirely via direct API (instant, pennies)
• Sliding window: only last 2 screenshots kept in context (~70% token reduction)
• Images compressed to JPEG 800px q50 (~40% fewer image tokens)
• System prompt cached via cache_control (90% savings on steps 2+)
• Haiku 4.5 for routine steps, auto-escalates to Sonnet 4.5 when stuck

Playback pattern: Navigate → start playback → verify playing → skip intro if visible → disconnect → report done

Remote Commands (cmd)

Send direct remote control commands without AI.

CODEBLOCK11

Available commands:
up, down, left, right, select, menu, home, play, pause, play_pause, next, previous, volume_up, volume_down, INLINECODE50

Examples:
CODEBLOCK12

Timing: Insert sleep:X between commands to add delays (in seconds).

Type Text (type)

Type text into a focused search/text field on the TV.

CODEBLOCK13

Example:
CODEBLOCK14

Note: The text field must already be focused. Use cmd to navigate to search first, or use do for full automation.

Launch App (launch)

Launch an app by bundle ID.

CODEBLOCK15

Example:
CODEBLOCK16

Common bundle IDs:

Use python3 ~/Developer/clawtv/clawtv.py apps for the full list on your device.

Plex Direct Control (plex)

Bypass the entire vision loop using Plex API directly. Searches your library and tells the Plex client on Apple TV to play. Instant playback, zero vision cost.

CODEBLOCK17

Requirements:

• - plex_url, plex_token, and plex_client in INLINECODE74
• Plex server running and accessible from Mac
• Plex client running on Apple TV

Auto-detection: The do command automatically detects Plex goals (e.g., "play Fight Club on Plex") and routes through this path without any vision API calls.

Screenshot (screenshot)

Take a screenshot of the Apple TV and save to ~/.clawtv/screenshots/.

CODEBLOCK18

Screenshot methods:

DRM apps (YouTube, Netflix, Disney+, HBO Max) enforce HDCP and terminate the QuickTime AirPlay mirror entirely. Use Xcode method for these apps, or use Lookout for its own UI.

Configuration: Set default method in ~/.clawtv/config.json:
CODEBLOCK19

Values: auto (tries quicktime → lookout → xcode), quicktime, lookout, INLINECODE82

Disconnect QuickTime (disconnect)

Close the QuickTime mirror and auto-resume playback on the TV.

CODEBLOCK20

Why: QuickTime mirroring shows a red recording border on the TV and routes audio to the Mac. After starting playback, always disconnect to remove the border and restore audio to the TV.

Auto-resume: Sends play command twice to ensure playback resumes.

Status Commands

CODEBLOCK21

Important Notes

DRM Limitations

DRM apps (YouTube, Netflix, Disney+, HBO Max) terminate the QuickTime AirPlay mirror entirely. When this happens:

• - QuickTime method shows a black screen
• ClawTV auto-detects the disconnection in auto mode
• Falls back to Xcode method automatically
• Or manually use: INLINECODE87

Apps that work with QuickTime: Plex (local media), Settings, home screen, Apple TV+, most non-DRM apps.

QuickTime Side Effects

When QuickTime mirror is active:

• - Red recording border appears on TV
• Audio routes to Mac instead of TV speakers
• DRM apps may refuse to play

Solution: Always run disconnect after starting playback. The do command does this automatically.

Cost

Vision loop (AI agent mode): Uses Claude API for every see-think-act step. Each step = 1 API call with screenshot.

• - Typical task: 5-10 steps = few cents
• Complex navigation: up to 20 steps = ~$0.10-0.20
• Uses Haiku 4.5 (cheap) with auto-escalation to Sonnet 4.5 when stuck

Plex direct control: 2 API calls total (pennies) — no vision loop.

Manual commands (cmd, type, launch): Zero API cost.

Config File

INLINECODE93 stores:

CODEBLOCK22

Companion Project

Lookout — tvOS app with built-in HTTP screenshot server at port 8080. Fastest possible screenshot method (~100ms) but only captures Lookout's own UI, not other apps.

Requirements

• - macOS (uses AppleScript for automation)
• Apple TV 4K (gen 2 or later, tvOS 16+) on same network as Mac
• Python 3.9+
• Anthropic API key for Claude vision
• QuickTime Player (built-in) or Xcode (free from App Store)

Troubleshooting

"No Apple TV found"

• - Run python3 ~/Developer/clawtv/clawtv.py scan to verify device is on network
• Check that Apple TV and Mac are on same WiFi/LAN
• Verify Apple TV is awake (not in sleep mode)

"QuickTime mirror disconnected"

• - DRM app killed the mirror — use --method xcode instead
• Or use Plex direct control to bypass vision entirely

"Screenshot failed"

• - QuickTime: Ensure AirPlay pairing is accepted on TV
• Xcode: Verify Devices window is open and Apple TV is connected
• Try --method auto to fall back automatically

"API key not found"

• - Set export ANTHROPIC_API_KEY=sk-ant-... in your shell
• Or add to ~/.zshrc or ~/.bashrc

"Plex not found"

• - Verify plex_url, plex_token, and plex_client in config
• Run python3 ~/Developer/clawtv/clawtv.py plex clients to verify client name
• Ensure Plex server is running and accessible

Architecture

CODEBLOCK23

Stack:

• - pyatv — Apple TV remote control (Companion protocol)
• QuickTime Player — AirPlay mirror for screenshots (primary)
• Xcode — Developer device screenshots (fallback)
• Claude — Vision + reasoning for autonomous navigation
• python-plexapi — Plex direct control

License

MIT — see LICENSE