mcp-gtv — Erwann Mest

Proof of concept — experimental and unfinished. This package is not yet published to npm. The API, tool names, and behaviour may change or break at any time. Run it from source (see Development). Do not use in production.

@kud/mcp-gtv exposes Google TV control to any MCP client, letting an assistant open apps, control playback, type into search fields, and read back what's currently on the TV.

🌟 Features

🔌 Zero credentials — reads paired devices from ~/.config/gtv/config.json; no API key, no token, no extra setup
📺 Device switching — list all paired TVs and switch the active target at any time during a session
🎮 Full remote control — send any key from navigation and media to volume, power, and input
⌨️ IME text input — type arbitrary text into the focused field directly, without keycode mapping
🚀 App launcher — launch Netflix, YouTube, Prime Video, Spotify, and more by name, or pass any raw deep-link URI
📡 State feedback — every control tool returns the TV's resulting state (power, volume, foreground app) so the model can confirm its action landed
🤖 Broad MCP client support — stdio transport works with Claude Desktop, Claude Code, Cursor, and any MCP-compatible client

🚀 Quick Start

1. Pair your TV first

Pairing is handled by @kud/gtv-cli, not this server. If you have not paired a device yet:

npx @kud/gtv-cli pair

Follow the PIN prompt on the TV. The paired device is written to ~/.config/gtv/config.json — the shared config store that mcp-gtv reads automatically. You only need to do this once per device.

2. Run the server from source

The package is not yet on npm. Clone the repo and run with tsx:

git clone https://github.com/kud/mcp-gtv.git
cd mcp-gtv
npm install
npm run dev

3. Ask naturally

Once an MCP client has the server connected:

"What's playing on the TV right now?" "Open Netflix" "Turn up the volume" "Go back to the home screen" "Type 'Blade Runner' into the search field"

This server works well for discrete, confirmable actions: opening apps, controlling playback, adjusting volume, typing into search, and checking what's currently on screen. It is not suited to navigating menus or lists inside an app — see Known Limitations.

🔧 MCP Client Setup

The server uses stdio transport and requires no environment variables.

Not yet on npm. The npx @kud/mcp-gtv form shown below will not work until the first publish. For now, use the local dev config instead.

Local development (current)

Add to .mcp.json in your project root, pointing at your local clone:

{
  "mcpServers": {
    "mcp-gtv": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcp-gtv/src/index.ts"]
    }
  }
}

The repo also ships a .mcp.json at the root — open the repo in Claude Code and it will be picked up automatically.

Claude Desktop / Claude Code (once published)

{
  "mcpServers": {
    "mcp-gtv": {
      "command": "npx",
      "args": ["-y", "@kud/mcp-gtv"]
    }
  }
}

Claude Desktop — edit ~/Library/Application Support/Claude/claude_desktop_config.json.

Claude Code — add to .mcp.json in your project root, or to ~/.claude/mcp.json for global availability.

Cursor / other MCP clients

Use the same npx -y @kud/mcp-gtv command with stdio transport once published. Consult your client's documentation for the exact config location.

🛠 Tools Reference

Every control tool returns the TV's resulting state (connected, powered, foreground app, volume) so the model can confirm its action landed.

Tool	Description	Arguments
`gtv_list_devices`	List all paired devices, marking the current one	—
`gtv_set_device`	Switch the active device by host (IP) or name	`device: string`
`gtv_get_state`	Read live state: connected, powered, foreground app (package + friendly name), volume	—
`gtv_send_key`	Send a remote key press; power and volume keys wait for the state echo	`key: string`
`gtv_type_text`	Type text into the focused field via IME	`text: string`
`gtv_launch_app`	Launch an app by catalog name/id or deep-link URI; waits for and returns the foreground app with a `confirmed` flag	`app: string`

Valid keys for `gtv_send_key`

home  back  power  up  down  left  right  select
play  stop  next   prev  fwd  rwd
vol-up  vol-down  mute
menu  search  sleep  wakeup  input  enter
channel-up  channel-down  info  guide  settings

App catalogue for `gtv_launch_app`

ID	App
`netflix`	Netflix
`youtube`	YouTube
`primevideo`	Prime Video
`plex`	Plex
`putio`	Put.io
`arte`	Arte
`disney`	Disney+
`spotify`	Spotify
`twitch`	Twitch
`max`	Max

You can also pass any raw deep-link URI directly (e.g. intent://... or market://launch?id=com.example.app).

⚠️ Known Limitations

No screen awareness. The Android TV Remote protocol only streams power state, volume, and foreground app package — never screen contents, focus position, or menu structure. The server can launch apps, control playback, type into search, and confirm those actions landed. It cannot see the screen, so navigating menus, folders, or lists inside an app is not reliably possible. Deep in-app navigation would require an ADB or computer-vision channel; that is deliberately out of scope.
Store-mediated app launching. App launch uses market://launch?id=<package>, which the Play Store may auto-launch OR simply display as a store listing (showing an "Open" button) even when the app is installed. Reliable direct launch is not available over the remote protocol. When the store page opens instead, send select to open the app.
Current device only. All tools act on the device selected by gtv_set_device (or the default from the config). Interactive pairing over MCP is not implemented — pair first with npx @kud/gtv-cli pair.
First-call latency. The first tool call in a session opens a TLS connection and waits for the TV's telemetry burst to settle (~350 ms quiet, capped at 2 s). Subsequent calls reuse the warm session and are near-instant.

🔧 Development

Project layout

mcp-gtv/
├── src/
│   └── index.ts        # MCP server — session management, all tool handlers
├── test/
│   └── tools.test.ts   # Unit tests (Node built-in test runner)
├── dist/               # Compiled output (tsup, gitignored)
├── .mcp.json           # Local MCP client config for dev (auto-loaded by Claude Code)
├── TESTING.md          # Manual test plan — run against a real TV before publishing
└── tsup.config.ts

Scripts

Script	Purpose
`npm run dev`	Run source directly with `tsx`
`npm run build`	Compile to `dist/` via tsup
`npm run build:watch`	Watch mode
`npm run test`	Run test suite (Node built-in runner)
`npm run typecheck`	TypeScript type check only
`npm run inspect`	Open MCP Inspector for interactive tool testing

Clone and run

git clone https://github.com/kud/mcp-gtv.git
cd mcp-gtv
npm install
npm run dev

Use npm run inspect to open the MCP Inspector and exercise all tools interactively without a full MCP client.

Testing

A manual test plan that covers every tool against a real TV lives in TESTING.md. Run through it before any publish.

Releasing

Releases are tag-driven via GitHub Actions with OIDC Trusted Publishers — no manual npm publish needed. The first publish has not happened yet; once the initial OTP bootstrap is done, subsequent releases will follow the tag workflow:

git tag v0.2.0
git push origin v0.2.0

🏗 Tech Stack

Package	Role
`@kud/gtv`	Google TV domain library — device store, key codes, app catalogue, remote connection
`@modelcontextprotocol/sdk`	MCP server primitives (`McpServer`, `StdioServerTransport`)
`zod`	Tool input schema validation
`tsup`	ESM bundler / compiler
`tsx`	TypeScript execution for dev and tests

Ecosystem

@kud/androidtv-remote   ← low-level pairing & remote protocol
       ↑
  @kud/gtv              ← domain library (devices, keys, apps)
       ↑
  ┌────┴────┐
  │         │
mcp-gtv   gtv-cli       ← MCP surface / terminal surface

This server is the MCP client surface of the ecosystem. @kud/gtv-cli is the interactive terminal counterpart — and the tool you use to pair devices before this server can control them.