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.

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.

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.

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).

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.

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.)

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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.

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/, or pass read:true to get the top page's markdown.

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.