# Gamealia (npm · gamealia-mcp)

Publish web games on Gamealia from your AI coding assistant: SDK, autotest, listing, upload.

- Trust score: 73/100 (medium)
- Registry status: active
- Liveness: live
- Owner verified: no
- Last scored: 2026-11-05

## Components

- npm · `gamealia-mcp`: 73/100 (this document), [markdown](https://verifymcp.io/servers/gamealia-gamealia-mcp/gamealia-mcp.md), [page](https://verifymcp.io/servers/gamealia-gamealia-mcp/gamealia-mcp)

## Channel facts

- Registry: `npm`
- Package: `gamealia-mcp`
- Version: `0.1.18`
- Transport: `stdio`

## Trust breakdown

How this component scores in each security and reliability category. Every signal is checked automatically from public evidence about the published package, including repeated runs of it in an isolated sandbox, and we only credit what we can confirm. Scores are 0–100 per category. Scoring method: https://verifymcp.io/docs/scoring (what has changed: https://verifymcp.io/docs/scoring/changelog)

Scored 2026-11-05.

- **Supply Chain Security**: 100/100
  - No malware found by supply-chain analysis.
  - No known CVEs affecting this package version or its production dependencies.
  - No install/post-install scripts declared.
  - 0 of 1 dependencies flagged as unhealthy.
- **Provenance & Transparency**: 45/100
  - Source repository is publicly reachable at the declared URL.
  - Provenance check failed: no build-provenance attestation is published.
  - Clear OSI-approved license (MIT).
  - Actively maintained (last published 0 days ago).
  - Disclosure check failed: no security disclosure policy was found in the source repository.
- **Schema Quality & AI Usability**: 87/100
  - 100% of prompts and resources have a non-trivial description (not blank, and not just the item's name).
  - AI-judged instruction clarity (excellent).
  - Tool/resource definitions use about 22237 tokens (~30/item across 734 items; 26 tools + 708 resources), lean.
  - Usage-examples check failed: none of the tools include examples.
- **Stability & Change Management**: 3/100
  - Stability observed for 1 of 30 days with no destabilising changes; credit accrues until the full window elapses.
- **Tool Coverage**: 100/100
  - 100% of tools have a non-trivial description (not blank, and not just the tool's name).
  - 100% of tool parameters carry a description.
  - Structured output schemas are declared (23% of tools); any adoption earns full credit.
- **Tool Safety**: 100/100
  - No prompt-injection markers were found in the server instructions, tool names or descriptions we captured.
  - We read all 26 captured tool definition(s), and no name or description among them implies an irreversible operation.
  - An AI judge read all 28 captured unit(s) of tool text and found none that tries to manipulate the model reading it.
- **Capabilities**: 100/100
  - Implements a supported MCP spec version (2025-11-25); the latest is 2026-07-28.

## Install

### How do I install the Gamealia MCP server?

Gamealia runs locally as an npm package, launched with npx -y gamealia-mcp. Ready-made configuration for Claude, Cursor, VS Code, Codex and 5 more is on this page, copied from each client's own documentation.

### Claude

```bash
claude mcp add gamealia-gamealia-mcp -- npx -y gamealia-mcp
```

### Cursor

```json
{
  "mcpServers": {
    "gamealia-gamealia-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "gamealia-mcp"
      ]
    }
  }
}
```

### VS Code

```json
{
  "servers": {
    "gamealia-gamealia-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "gamealia-mcp"
      ]
    }
  }
}
```

### Codex

```bash
codex mcp add gamealia-gamealia-mcp -- npx -y gamealia-mcp
```

### opencode

```json
{
  "$schema": "https://opencode.ai/config.json",
  "mcp": {
    "gamealia-gamealia-mcp": {
      "type": "local",
      "command": [
        "npx",
        "-y",
        "gamealia-mcp"
      ],
      "enabled": true
    }
  }
}
```

### OpenClaw

```bash
openclaw mcp add gamealia-gamealia-mcp --command npx --arg -y --arg gamealia-mcp
```

### Hermes

```yaml
mcp_servers:
  gamealia-gamealia-mcp:
    command: "npx"
    args: ["-y", "gamealia-mcp"]
```

### Netclaw

```json
{
  "McpServers": {
    "gamealia-gamealia-mcp": {
      "Transport": "stdio",
      "Command": "npx",
      "Arguments": [
        "-y",
        "gamealia-mcp"
      ]
    }
  }
}
```

### Vellum

```bash
assistant mcp add gamealia-gamealia-mcp -t stdio -c npx -a -y gamealia-mcp
```

### Other

```json
{
  "mcpServers": {
    "gamealia-gamealia-mcp": {
      "command": "npx",
      "args": [
        "-y",
        "gamealia-mcp"
      ]
    }
  }
}
```

## Changelog

Every change recorded for this component, newest first. Days that predate change tracking, or that we cannot explain, say so: "we were watching and nothing happened" and "we were not watching" are different claims.

### 2026-11-04 (score 73)

First indexed and scored.

## MCP tools (26)

### `gamealia_login` (~170 tokens)

Log in to Gamealia

Logs in to Gamealia with a device code; call it first, since every tool that talks to Gamealia needs it. Returns a URL and a code at once for the user to open and approve (Google, or email and password; creates the developer profile if needed), then polls in the background and stores the API key in ~/.config/gamealia/credentials.json (mode 600). Call again with wait:true to wait for the approval (up to 50 s per call; repeat while still pending). When already logged in it only returns the username, unless force:true.

Input parameters:

- `force` (boolean): Start a new login even when already logged in (cancels a pending one)
- `wait` (boolean): Wait up to 50 s for the user to approve a login started earlier

### `gamealia_whoami` (~97 tokens)

Who am I

Shows who is signed in: user id and username, whether a developer profile exists, the active developer account with the user's role, the API URL and where the key came from (environment or credentials file; never the key itself). Read-only. Use it to confirm the login before creating or publishing games; to list or switch accounts use gamealia_accounts. Fails with a hint to call gamealia_login when not logged in.

### `gamealia_logout` (~76 tokens)

Log out

Logs out on this machine: deletes the local credentials file (every stored account key) and cancels a pending login. Local only, the key is not revoked on the server; safe to repeat. If GAMEALIA_API_KEY is set in the environment, calls stay authenticated with it. To change account, use gamealia_accounts instead.

### `gamealia_accounts` (~179 tokens)

Developer accounts

Lists or switches the user's Gamealia developer accounts (their own and studios they joined). API keys are bound to one account and every other tool acts on the active one, so when the user has several, confirm the right one before creating or publishing games. action "list" (read-only) returns each account (id, name, individual/business, role: owner, admin, developer or finance), which is active and pending invites. action "switch" makes another account active with a stored key, or starts a device login bound to it (show the URL and code, then call gamealia_login with wait:true).

Input parameters:

- `account` (string): Required for switch: the account id or display name, as shown by action list
- `action` (string, required): list: show the accounts (changes nothing); switch: make the given account active

### `gamealia_analyze_project` (~160 tokens)

Analyze a game project

Inspects a local game folder (read-only, runs nothing, no login): engine (HTML5 + framework, Unity WebGL, Godot web, GameMaker, Construct), build command, output dir and entry html; existing CrazyGames/Poki SDK usage; policy problems (external ads, trackers, purchase UI, own login) with exact files and lines; localStorage keys; size; and the microphone/camera permissions to declare in the listing when the build calls getUserMedia. Call it first on an existing game (gamealia_create_project when there is none); the result names the next step, usually gamealia_integrate_sdk.

Input parameters:

- `dir` (string, required): Project folder (absolute, or relative to the server's working directory)

Output parameters:

- `buildCommand` (string|null)
- `dir` (string)
- `engine` (string)
- `entryHtml` (string|null)
- `localStorageKeys` (array)
- `next` (array)
- `outputDir` (string|null)
- `outputExists` (boolean)
- `permissions` (array)
- `policy` (array)
- `sdks` (object)
- `sizeBytes` (number)
- `warnings` (array)

### `gamealia_create_project` (~242 tokens)

Create a new game

Scaffolds a new minimal game, already integrated with the Gamealia SDK, into an empty or new folder (local files only, no login). Use it when there is no game yet, instead of gamealia_analyze_project + gamealia_integrate_sdk. Never overwrites: fails if the folder has any file. Returns the files written. Templates: vanilla (Canvas game in plain JavaScript; no build step, upload the folder as is.); phaser (Phaser 3 + Vite; `npm install && npm run build` -> dist/.); pixi (PixiJS 8 + Vite; `npm install && npm run build` -> dist/.); multiplayer (Room example (publish, invite link, join) with a BroadcastChannel stand-in for your server; no build step.)

Input parameters:

- `dir` (string, required): Project folder (absolute, or relative to the server's working directory)
- `template` (string): Starter template id (default vanilla: plain JavaScript, no build step); see the list in the description
- `title` (string, required): Game title written into the scaffold, 1-60 characters

### `gamealia_integrate_sdk` (~170 tokens)

Integrate the Gamealia SDK

Patches a local project to use the Gamealia SDK, after gamealia_analyze_project: adds the SDK script tag (or import) and a lifecycle adapter, swaps CrazyGames/Poki SDKs for the Gamealia shims, adds the Unity .jslib / Godot addon. Deterministic and idempotent. Dry run by default (returns a unified diff, changes nothing); write:true edits the project's files. Returns TODOs (file:line) for the calls only you can place: gameplayStart/Stop, happyTime and ad breaks; then run gamealia_check_integration.

Input parameters:

- `dir` (string, required): Project folder (absolute, or relative to the server's working directory)
- `write` (boolean): Apply the patch (default: dry run, diff only)

### `gamealia_check_integration` (~177 tokens)

Lint the SDK integration and policies

Fast static lint of a local project's source or build (read-only, no browser, no login): SDK loaded and called, loadingStop/gameplayStart present, portal language used (locale/localeChange), no external ads/trackers/miners, no purchase UI, no own login, build security rules, sizes. Use it after gamealia_integrate_sdk and before the slower gamealia_run_autotest. Returns ok plus each check as pass/warn/fail with a message (how to fix it) and file:line.

Input parameters:

- `backendHosts` (array): Your own servers the game may call, as in the listing, e.g. ["mp.example.com", "*.example.com"]; other external hosts are flagged
- `dir` (string, required): Project folder (absolute, or relative to the server's working directory)

Output parameters:

- `checks` (array)
- `next` (array)
- `ok` (boolean)

### `gamealia_build` (~123 tokens)

Build the project

Runs the project's detected build command locally (e.g. npm run build; may take minutes, sends progress notifications) and returns the output folder and the last lines of the log, or an error with the end of the build log on failure. With no build step it runs nothing and returns the folder to upload. Usually optional: gamealia_run_autotest, gamealia_preview and gamealia_upload_version build first by themselves; use it to debug a failing build.

Input parameters:

- `dir` (string, required): Project folder (absolute, or relative to the server's working directory)

### `gamealia_run_autotest` (~232 tokens)

Run the autotest locally

Builds (unless build:false) and runs the full Gamealia autotest locally in headless Chromium, desktop 1280x720 and mobile 390x844, the same checks as the server: SDK lifecycle, blank screen, input response, ads (mock), console errors, static security analysis. Run it before gamealia_upload_version, which repeats it on the server. No login; writes screenshots and report.json to a temp folder; takes a while (progress notifications). Returns pass/warn/fail, the failed checks with fixes, the screenshot paths and key screenshots as images.

Input parameters:

- `backendHosts` (array): Your own servers the game may call, as in the listing, e.g. ["mp.example.com"]; other external hosts are flagged
- `build` (boolean): Run the build command first when the project has one (default true)
- `dir` (string, required): Project folder (absolute, or relative to the server's working directory)
- `images` (integer): How many screenshots to return as images, 0-6 (default 3); all paths are listed anyway

Output parameters:

- `failedRequired` (array)
- `next` (array)
- `outputDir` (string)
- `problems` (array)
- `reportPath` (string)
- `screenshots` (array)
- `status` (string)

### `gamealia_preview` (~203 tokens)

Preview in a portal replica

Serves the build (built first unless build:false) inside a local replica of the Gamealia game page (the real portal frame plus mock ads) on 127.0.0.1 and returns the page URL and the bare game URL for the user (or you) to open. No login, nothing is uploaded. It keeps running until stop:true or the MCP server exits; calling it again for the same folder restarts it. For automated checks use gamealia_run_autotest; to play it yourself, gamealia_playtest.

Input parameters:

- `build` (boolean): Run the build command first when the project has one (default true)
- `dir` (string, required): Project folder (absolute, or relative to the server's working directory)
- `stop` (boolean): Stop the preview of this folder instead of starting one
- `title` (string): Title shown on the replica page (default: the build's index.html <title>, else "Preview")

### `gamealia_playtest` (~196 tokens)

Start a playtest (you play)

Starts the game (built first unless build:false) in headless Chromium inside the autotest harness so you can play it yourself, e.g. to check gameplay the automatic gamealia_run_autotest cannot judge. Returns a session id plus the first screenshot. Then call gamealia_playtest_act with one action at a time (click x,y | key | drag | wait) and end with gamealia_playtest_stop for the verdict. Up to 40 actions per session and 2 sessions at once; idle sessions close after a few minutes. Local, no login.

Input parameters:

- `build` (boolean): Run the build command first when the project has one (default true)
- `dir` (string, required): Project folder (absolute, or relative to the server's working directory)
- `profile` (string): desktop: 1280x720 with mouse (default); mobile: 390x844 with touch, clicks become taps

### `gamealia_playtest_act` (~181 tokens)

Playtest action

Performs one action (click, key, drag or wait) in a session started by gamealia_playtest; actions of one session run one at a time, in order. Returns the new screenshot, the step number and steps left, the SDK calls since the last step, new console errors, ad requests and how much the frame changed (0% often means the input did nothing). Fails if the session ended or expired; when steps run out, call gamealia_playtest_stop.

Input parameters:

- `action` (required): One action: {type:"click",x,y} | {type:"key",key,holdMs?} | {type:"drag",from:{x,y},to:{x,y}} | {type:"wait",ms}; coordinates in viewport pixels
- `sessionId` (string, required): Session id returned by gamealia_playtest

### `gamealia_playtest_stop` (~117 tokens)

Stop a playtest

Ends a session started by gamealia_playtest (waits for its pending action, then closes the browser page; the session id stops working) and returns the summary: verdict pass/warn/fail with a message, steps and how many got a response, whether gameplay started, happy times, ad requests and ads shown, console errors and whether it crashed. Call it when done playing, so the session does not hold a browser until it expires.

Input parameters:

- `sessionId` (string, required): Session id returned by gamealia_playtest

Output parameters:

- `adRequests` (number)
- `adsShown` (number)
- `crashed` (boolean)
- `errors` (array)
- `gameplayStarted` (boolean)
- `happyTimes` (number)
- `message` (string)
- `next` (array)
- `respondingSteps` (number)
- `steps` (number)
- `verdict` (string)

### `gamealia_create_game` (~686 tokens)

Create the game listing

Creates a new game listing in the active developer account (needs login; not idempotent: a taken slug fails): slug, title/description/controls in es and en, tags, orientation, multiplayer, ads on/off, backend hosts, permissions; optionally uploads a cover and thumbnail (make them with gamealia_generate_cover). The game stays a draft, not public, until a version is approved. Call it once per game, after gamealia_run_autotest passes; to change an existing listing use gamealia_update_listing. Returns the game (id, slug, status); next gamealia_upload_version.

Input parameters:

- `adsEnabled` (boolean): Show Gamealia ads in this game (revenue share)
- `backendHosts` (array): Your own servers the game talks to, e.g. mp.example.com or *.example.com
- `controls`: 0-500 characters. Prefer {es, en}; a plain string is used for both languages
- `coverPath` (string): Cover image file (PNG/JPEG/WebP, >= 1200x630, ~1.91:1, <= 2 MB)
- `description` (required): 20-2000 characters. Prefer {es, en}; a plain string is used for both languages
- `isolation` (string): coop-coep only for builds that need SharedArrayBuffer (threads)
- `multiplayer`: Players per room, or null for single player
- `orientation` (string): Screen orientation the game needs; landscape or portrait shows mobile players a rotate-device hint (default any)
- `permissions` (array): Browser permissions the game needs (microphone/camera), each with a justification; [] removes them. Replaces the current list and its justification (stored in the listing; the reviewer sees it). game…
- `slug` (string, required): URL slug and game host (<slug>.gamealia.app): a-z, 0-9 and -, 3-40 chars, starting and ending with a letter or digit, not reserved (www, api, cdn, ...); fixed once live
- `tags` (array, required): Tags, three kinds in one array: 1-6 categories (genres: what kind of game), up to 8 mechanics (how it plays: match-3, merge, physics, tower-defense…) and attributes (multiplayer, mobile…). Players br…
- `texts` (object): Developer-written listing text for one or many locales in one call, e.g. {fr:{title, description, controls}, de:{...}}. Limits (trimmed): title 2-60, description 20-2000 or "", controls <= 500 or "".…
- `thumbPath` (string): Thumbnail file (square, >= 512x512, <= 2 MB)
- `title` (required): 2-60 characters. Prefer {es, en}; a plain string is used for both languages

### `gamealia_update_listing` (~666 tokens)

Update the game listing

Edits an existing game's listing (needs login): only the fields given change and they replace the current values; coverPath/thumbPath upload a new cover or thumbnail. texts writes developer-authored title/description/controls for one or many locales in one call (validated against the limits; they always win over machine translation): translate the listing yourself (gamealia-translate-listing skill) and save every locale at once. A permissions change only takes effect with the next approved version. Returns the updated game and the permission changes.

Input parameters:

- `adsEnabled` (boolean): Show Gamealia ads in this game (revenue share)
- `backendHosts` (array): Your own servers the game talks to, e.g. mp.example.com or *.example.com
- `controls`: 0-500 characters. Prefer {es, en}; a plain string is used for both languages
- `coverPath` (string): Cover image file (PNG/JPEG/WebP, >= 1200x630, ~1.91:1, <= 2 MB)
- `description`: 20-2000 characters. Prefer {es, en}; a plain string is used for both languages
- `game` (string, required): Game slug or id, from gamealia_list_games (a game of the active account)
- `isolation` (string): coop-coep only for builds that need SharedArrayBuffer (threads)
- `multiplayer`: Players per room, or null for single player
- `orientation` (string): Screen orientation the game needs; landscape or portrait shows mobile players a rotate-device hint (default any)
- `permissions` (array): Browser permissions the game needs (microphone/camera), each with a justification; [] removes them. Replaces the current list and its justification (stored in the listing; the reviewer sees it). game…
- `slug` (string): New URL slug and game host (<slug>.gamealia.app), same rules as in gamealia_create_game; fixed once live
- `tags` (array): Tags, three kinds in one array: 1-6 categories (genres: what kind of game), up to 8 mechanics (how it plays: match-3, merge, physics, tower-defense…) and attributes (multiplayer, mobile…). Players br…
- `texts` (object): Developer-written listing text for one or many locales in one call, e.g. {fr:{title, description, controls}, de:{...}}. Limits (trimmed): title 2-60, description 20-2000 or "", controls <= 500 or "".…
- `thumbPath` (string): Thumbnail file (square, >= 512x512, <= 2 MB)
- `title`: 2-60 characters. Prefer {es, en}; a plain string is used for both languages

### `gamealia_generate_cover` (~206 tokens)

Generate cover and thumbnail

Makes a 1200x630 cover and a 512x512 thumbnail from a gameplay screenshot (e.g. desktop-input.png from gamealia_run_autotest): center-cropped with the title on a gradient. Writes cover and thumb files to outDir (refuses to replace existing ones unless overwrite:true) and returns their paths plus the cover as an image. Without game it is local only; with game (needs login) it also uploads both to that listing, replacing its current images. Otherwise pass the files to gamealia_create_game or gamealia_update_listing.

Input parameters:

- `game` (string): Upload them to this game's listing
- `outDir` (string): Where to write cover/thumb (default: the screenshot's folder)
- `overwrite` (boolean): Replace existing cover/thumb files in outDir
- `screenshot` (string, required): PNG/JPEG/WebP screenshot path
- `title` (string, required): Game title drawn on the images, 1-60 characters

### `gamealia_upload_version` (~265 tokens)

Upload a new version

Builds (unless noBuild), zips and uploads the local build as a new version of an existing game (needs login; multipart, retried), then waits for the server autotest and returns the version state and its report. Use it after gamealia_run_autotest passes locally and gamealia_create_game. Each call creates a new version; interrupted uploads that block it are aborted automatically. Can take minutes (progress notifications). submit:true also submits it for review when the autotest passes: only after the user confirmed; otherwise use gamealia_submit_for_review later.

Input parameters:

- `dir` (string, required): Project folder (absolute, or relative to the server's working directory)
- `game` (string, required): Game slug or id, from gamealia_list_games (a game of the active account)
- `noBuild` (boolean): Skip the build command and upload the current output folder as is (default false: build first)
- `notes` (string): Release notes for this version, up to 2000 characters (shown to the reviewer)
- `submit` (boolean): Also submit for review if the server autotest passes (only after the user confirms)
- `waitForPrevious` (boolean): If a previous version is still being tested, wait for it instead of failing

### `gamealia_submit_for_review` (~164 tokens)

Submit for review

Submits a game's newest version that passed the server autotest (state tested) for manual review by Gamealia, with release notes. Call it only after the user has confirmed they want to submit this version, and after gamealia_upload_version (skip it if that ran with submit:true). Needs login; fails if no version is tested, or if newly requested permissions lack a justification. Returns the version, normally awaiting_review; if permissions changed since its autotest the server re-tests it first. Then check gamealia_get_status later.

Input parameters:

- `game` (string, required): Game slug or id, from gamealia_list_games (a game of the active account)
- `notes` (string): Release notes for the reviewer, up to 2000 characters (default empty)

### `gamealia_get_status` (~165 tokens)

Game and version status

Shows where one game stands (read-only, needs login): listing status (draft, live, unlisted, banned), the live version, requested vs live permissions, the latest version's state, its server autotest report, the reviewer's reject reasons with how to fix each, and the previous versions' states. Use it after uploading or submitting, and to read a rejection. texts:true instead returns the listing text of every supported locale with its status (developer-written, machine-translated, missing), the source text to translate from and the field limits.

Input parameters:

- `game` (string, required): Game slug or id, from gamealia_list_games (a game of the active account)
- `texts` (boolean): Include the per-locale listing texts, their status and the limits

Output parameters:

- `game` (object)
- `latest`
- `listingTexts` (object)
- `next` (array)
- `versions` (array)

### `gamealia_list_games` (~86 tokens)

List my games

Lists every game of the active developer account (read-only, needs login): slug, title, status (draft, live, unlisted, banned), live version id and cover/thumbnail URLs. Use it to find the slug the other tools take, or to check that a game exists before gamealia_create_game; for one game's versions and review state use gamealia_get_status.

### `gamealia_list_versions` (~115 tokens)

List versions

Lists all versions of one game, newest first (read-only, needs login): number, state (uploading, testing, tested, test_failed, awaiting_review, approved, rejected, archived, ...), which one is live, release notes, size, autotest status, reject reasons with fixes and dates. For the latest version's full autotest report and the next step use gamealia_get_status.

Input parameters:

- `game` (string, required): Game slug or id, from gamealia_list_games (a game of the active account)

### `gamealia_get_stats` (~123 tokens)

Game stats

Returns one game's daily stats for the last N days plus totals (read-only, needs login): plays, players, playtime in seconds, mobile/desktop split, ad requests and ad impressions. Use it to see how a live game performs; for money use gamealia_get_earnings, for review state gamealia_get_status.

Input parameters:

- `days` (integer): How many days back to include, 1-365 (default 30)
- `game` (string, required): Game slug or id, from gamealia_list_games (a game of the active account)

### `gamealia_get_earnings` (~103 tokens)

Earnings

Returns the active developer account's earnings (read-only, needs login; a role-forbidden error means the user's role cannot see finances): balance, then per month the estimated and confirmed amounts, adjustments and revenue share %, and the payouts made (date, amount, method). Amounts are USD; structured values are in micro-dollars (balanceMicros). Account-wide, not per game; for plays and ad impressions per game use gamealia_get_stats.

### `gamealia_docs_search` (~194 tokens)

Search the Gamealia docs

Searches the Gamealia developer docs bundled with this server (SDK reference, publishing requirements, autotest checks, reject reasons, guides); local and read-only, no login needed. Use it before guessing an SDK call, a policy rule or how to fix a failed check. Searches the developer's locale when those pages exist, else English. Returns the best pages (slug, title, uri, snippet); read a whole page as the resource gamealia://docs/<slug>, or pass read:true to get the top page's markdown.

Input parameters:

- `locale` (string): Docs locale, e.g. en or es (default: the developer's locale, falling back to en)
- `query` (string, required): Free-text search words, e.g. "rewarded ad", "localeChange" or a failed autotest check id
- `read` (boolean): Also return the full markdown of the best match (default false)

Output parameters:

- `hits` (array)
- `next` (array)

### `gamealia_install_agent_kit` (~353 tokens)

Register Gamealia in coding agents

One-time setup, not part of publishing: registers this MCP server and installs the Gamealia skills/rules in coding agents (claude-code, claude-desktop, codex, gemini, cursor, vscode, windsurf, cline, zed, opencode, agents-md). Dry run by default (write:true applies); returns the planned file changes plus copy-paste snippets (claude mcp add, Codex TOML, Cursor/VS Code install links). Project scope writes agent config files into dir (.mcp.json, .claude/skills, .cursor/, .vscode/, .codex/, AGENTS.md/GEMINI.md blocks, ...); global scope edits the user's own agent configs (~/.claude.json, ~/.codex/config.toml, Claude Desktop, ...). Merges idempotently, backs up every changed file first and leaves unparsable files alone; `gamealia agents uninstall` reverts it.

Input parameters:

- `dir` (string): Project folder for project scope (default: the server's working directory)
- `scope` (string): project (default): config files inside dir; without targets sets up Claude Code, Cursor and VS Code plus the agents detected. global: the user's own agent configs; without targets only the detected a…
- `serverPath` (string): Path of the gamealia-mcp.mjs the agents should run (default: this running server's bundle)
- `targets` (array): Agents to set up, e.g. ["claude-code", "cursor"] (default: depends on scope, see scope)
- `write` (boolean): Apply the changes (default false: dry run, nothing is written)

## Diagnostics

Captured diagnostic sections: Provenance, Dependencies. The full working is on the page: https://verifymcp.io/servers/gamealia-gamealia-mcp/gamealia-mcp#diagnostics

## Score history

- 2026-11-05: 73
- 2026-11-04: 73

## Common questions

### What is the Gamealia MCP server?

Gamealia is an MCP server listed in the public MCP registry as io.github.gamealia/gamealia-mcp. Publish web games on Gamealia from your AI coding assistant: SDK, autotest, listing, upload. This page covers its npm package (gamealia-mcp).

### Is the Gamealia MCP server safe to use?

Gamealia scores 73 out of 100 on VerifyMCP. We found no known CVEs affecting it as of 5 November 2026. It declares no install or post-install scripts. That is a record of what we were able to check automatically, not an endorsement. The category breakdown on this page shows every signal behind the number, including the ones we could not confirm.

### What tools does the Gamealia MCP server expose?

Gamealia exposes 26 tools: gamealia_login, gamealia_whoami, gamealia_logout, gamealia_accounts, gamealia_analyze_project, and 21 more. Their descriptions and schemas cost roughly 5,449 tokens of context every time the server is loaded.

### Is the Gamealia MCP server still maintained?

Gamealia is still listed as active in the MCP registry. We last reached this channel on 5 November 2026. Those dates come from our own scans of the registry and the channel itself, not from anything the publisher announced.

### What licence is the Gamealia MCP server under?

Gamealia declares the MIT licence, which is OSI-approved. That covers the source only, and says nothing about the cost of any service it calls.

### What did VerifyMCP test on the Gamealia MCP server?

VerifyMCP ran 16 checks on Gamealia, covering Malware scan, Known CVEs, Install scripts, Dependency health and 12 more. Endpoint Security and Transport & Reachability do not apply to an npm package, so they were not tested. The score does not measure everything, and the scoring documentation lists what it leaves out.

## Links

- npm package: https://www.npmjs.com/package/gamealia-mcp
- Socket report: https://socket.dev/npm/package/gamealia-mcp
- Repository: https://github.com/gamealia/gamealia-mcp
- Website: https://gamealia.app/docs/publishing-with-ai
- Changelog RSS feed: https://verifymcp.io/servers/gamealia-gamealia-mcp/gamealia-mcp.xml
- Changelog JSON feed: https://verifymcp.io/servers/gamealia-gamealia-mcp/gamealia-mcp/changelog.json
- Trust report (JSON): https://verifymcp.io/servers/gamealia-gamealia-mcp/gamealia-mcp.json
- HTML version of this page: https://verifymcp.io/servers/gamealia-gamealia-mcp/gamealia-mcp