gameye-mcp

# Gameye MCP Server

A [Model Context Protocol](https://modelcontextprotocol.io) server for the [Gameye](https://gameye.com) game server orchestration API. It lets an AI agent (Claude Code, Claude Desktop, Cursor, or any MCP client) launch and inspect game server sessions, check image tags and regions, and fetch logs and artifacts. You talk to it in plain language, and you don't have to leave your editor.

> **Status: beta** (`0.x`). Tools, inputs and outputs may change between releases, and there may be bugs. The server says so to every client that connects, on startup, and in `gameye_context`. It is published on npm as [`gameye-mcp`](https://www.npmjs.com/package/gameye-mcp), as a container image at `ghcr.io/gameye/gameye-mcp`, and in the [MCP Registry](https://registry.modelcontextprotocol.io) as `io.github.Gameye/gameye-mcp`; see the [changelog](https://github.com/Gameye/gameye-mcp/blob/main/CHANGELOG.md) for what changed in each release.

## Quick start

```bash
GAMEYE_API_TOKEN=<your-token> npx -y gameye-mcp
```

It needs Node.js 22 or newer. The server speaks MCP over stdio. Normally your MCP client starts it for you (see [Install](#install)), so you rarely need to run it by hand.

## Environments

Gameye has two public API hosts. The server targets **sandbox** by default.

| `GAMEYE_ENV` | Host | Who it is for |
|---|---|---|
| `sandbox` (default) | `https://api.sandbox-gameye.gameye.net` | Self-serve customers. This is your permanent home and runs live matches, not just tests. |
| `production` | `https://api.production-gameye.gameye.net` | Enterprise customers. |

The environment is a property of the server process. No tool takes an environment argument, so an agent can't switch to production partway through a conversation. If you need both, configure two named server entries (for example `gameye-sandbox` and `gameye-production`), each with its own token.

## Environment variables

| Variable | Required | Default | Description |
|---|---|---|---|
| `GAMEYE_API_TOKEN` | **Yes** | — | Gameye API token. Use the least-privileged scopes you need (see below). |
| `GAMEYE_ENV` | No | `sandbox` | `sandbox` or `production`. Selects the API host. |
| `GAMEYE_API_URL` | No | — | Overrides the host, for testing only. Must be `https`. If it equals one of the two known hosts, it must match `GAMEYE_ENV` or the server refuses to start. Any other URL is labelled `custom` in every tool result. |
| `GAMEYE_ENABLE_ADMIN_TOOLS` | No | unset | Set to `1` to register the admin tools (create or edit applications, create tokens). They stay off when this is unset. |
| `GAMEYE_TIMEOUT_MS` | No | `30000` | Per-request timeout in milliseconds, a positive whole number. Log snapshots get at least 60 s and artifact downloads at least 120 s. A request that runs out of time comes back as a tool error: `Request to <host> timed out after <n>s`. |

## Install

### Claude Code

```bash
claude mcp add gameye --env GAMEYE_API_TOKEN=<your-token> -- npx -y gameye-mcp
```

For production, add `--env GAMEYE_ENV=production` and use a production token.

### Other MCP clients

Most clients (Claude Desktop, Cursor, Windsurf and others) accept an `mcpServers` block:

```json
{
  "mcpServers": {
    "gameye": {
      "command": "npx",
      "args": ["-y", "gameye-mcp"],
      "env": {
        "GAMEYE_API_TOKEN": "<your-token>",
        "GAMEYE_ENV": "sandbox"
      }
    }
  }
}
```

Restart the client after you change its configuration.

`npx -y gameye-mcp` runs the latest release. To stay on one version, name it: `npx -y gameye-mcp@0.1.3` (or `"args": ["-y", "gameye-mcp@0.1.3"]`).

### Docker

No Node.js on the machine? Run the published image instead. It works on amd64 and arm64:

```json
{
  "mcpServers": {
    "gameye": {
      "command": "docker",
      "args": ["run", "-i", "--rm", "-e", "GAMEYE_API_TOKEN", "-e", "GAMEYE_ENV", "ghcr.io/gameye/gameye-mcp"],
      "env": {
        "GAMEYE_API_TOKEN": "<your-token>",
        "GAMEYE_ENV": "sandbox"
      }
    }
  }
}
```

With Claude Code: `claude mcp add gameye --env GAMEYE_API_TOKEN=<your-token> -- docker run -i --rm -e GAMEYE_API_TOKEN ghcr.io/gameye/gameye-mcp`.

- Pass each variable with `-e NAME` (no value), so Docker copies it from the client's environment and the token never appears in the command line.
- Keep `-i` and never add `-t`: a terminal mangles the JSON-RPC messages on stdout.
- To stay on one version, use a version tag such as `ghcr.io/gameye/gameye-mcp:0.1.3`.
- Files the server writes stay inside the container, and `--rm` deletes them:
  - `gameye_get_artifacts` saves its download under the temp directory. To keep it, mount a directory and point the temp directory at it: `-v /absolute/dir:/out -e TMPDIR=/out`. The path the tool reports is the container path; the file is in `/absolute/dir` on the host.
  - `gameye_create_token` (admin tools only) writes to the `outputPath` you give it. Mount a directory the same way and pass an `outputPath` under `/out`.
  - The server runs as uid 1000, so on Linux the mounted directory must be writable by that user.

## Token scopes

Give the server a token with only the scopes it needs.

| Recipe | Scopes | What the agent can do |
|---|---|---|
| Observer | `session:read` `logs:read` `artifact:read` `regions:read` `region:read` `application:read` | Inspect sessions, logs, artifacts, regions and applications. No changes. |
| Operator | Observer + `session:start` `session:stop` `session:write` | Also launch and stop sessions and update session state. |
| Admin tools | Operator + `application:write` `token:write` | Also create or edit applications and create tokens. Requires `GAMEYE_ENABLE_ADMIN_TOOLS=1`. |

**Never pass your Gameye API token into a game server's environment.** A game server doesn't need it, and anything inside the container can read it.

## Available tools

Every tool result starts with the environment and host it used, for example `[sandbox · api.sandbox-gameye.gameye.net]`.

| Tool | Kind | Description |
|---|---|---|
| `gameye_context` | read | Show the environment, host and server version this server targets, whether admin tools are enabled, and the guardrail defaults (session TTL, `launched-by` label, token expiry) |
| `gameye_launch_session` | write, `dryRun` | Start a containerized game server (billable). Default TTL and agent label applied; see [Guardrails](#guardrails) |
| `gameye_list_sessions` | read | List running sessions (filterable; `all=true` for every status) |
| `gameye_describe_session` | read | Get session details, ports and players |
| `gameye_stop_session` | destructive, `dryRun` | Stop one session by its exact ID |
| `gameye_player_join` | write | Register one or more players as joined |
| `gameye_player_leave` | write | Remove one or more players from a session |
| `gameye_get_locations` | read | List locations that can host an image right now |
| `gameye_list_regions` | read | List the regions available to your organization |
| `gameye_check_tag` | read | Check whether an image tag is available in a region |
| `gameye_list_applications` | read | List your applications with registry, resources, regions and ports |
| `gameye_list_registry_tags` | read | List an application's tags in its upstream registry (paged) |
| `gameye_enable_tag` | write, `dryRun` | Enable an image tag for an application so Gameye preloads it |
| `gameye_get_logs` | read | Fetch session logs |
| `gameye_get_artifacts` | read | Download a file or directory from a session container as a tar archive |
| `gameye_create_application` | admin, `dryRun` | Create an application. Only with `GAMEYE_ENABLE_ADMIN_TOOLS=1` |
| `gameye_edit_application` | admin, destructive, `dryRun` | Change an application; omitted fields stay unchanged. Only with `GAMEYE_ENABLE_ADMIN_TOOLS=1` |
| `gameye_create_token` | admin, `dryRun` | Create an API token and write it to a file. Only with `GAMEYE_ENABLE_ADMIN_TOOLS=1` |

Every tool carries MCP annotations: read tools set `readOnlyHint`, `gameye_stop_session` and `gameye_edit_application` set `destructiveHint`, and every tool that calls the Gameye API sets `openWorldHint`.

The tool set covers every operation in the Gameye client API. `tests/parity.test.ts` checks this against the vendored spec in `spec/`.

## Guardrails

These behave the same on sandbox and production, because sandbox runs live matches for self-serve customers.

- **Dry run.** `gameye_launch_session`, `gameye_stop_session`, `gameye_enable_tag` and the admin tools accept `dryRun: true`. The tool returns the exact request (method, host, path and body) with the API token masked, and sends nothing.
- **Bounded sessions.** A launch without `ttl` gets a `30m` TTL, and the result says the default was applied. Every launch sends the label `launched-by: gameye-mcp`, replacing any `launched-by` value the caller passes, so agent-launched sessions can be found with `gameye_list_sessions` and `filter: { "launched-by": "gameye-mcp" }`. When a warm pool serves the image and region, the Gameye API ignores request labels (and env and args), so warm-pool sessions do not carry this label.
- **No token in game servers.** A launch is refused, with nothing sent, if any env value or name, arg, or label key or value contains this server's Gameye API token. Env values are never shown in results.
- **No token in results.** Every tool result, including errors, has this server's API token replaced with `***`, in case log output, labels or an error message echo it.
- **Explicit stops.** `gameye_stop_session` stops exactly one session by its exact ID. There is no bulk stop, and empty, wildcard or list IDs are refused.

## Telemetry/attribution

Every request to the Gameye API sends `User-Agent: gameye-mcp/<version>`, plus the MCP client's name once it has connected, e.g. `gameye-mcp/0.1.0 (claude-code)`, so Gameye can count MCP usage. Only this server's version and the client name are sent, nothing else: no token, env values, paths or other data. There is no other teleme