gameye-mcp 0.3.2 → 0.5.0

package/dist/tools/register.js

@@ -9,6 +9,9 @@ import { registerTokenTools } from "./tokens.js";
 import { registerLogTools } from "./logs.js";
 import { registerArtifactTools } from "./artifacts.js";
 import { registerSkillsTools } from "./skills.js";
+import { registerBundledSkillsTools } from "./bundled-skills.js";
+import { registerDockerfileCheckTool } from "./dockerfile-check.js";
+import { registerTemplateTools } from "./templates.js";
 /** Register every tool. */
 export function registerAllTools(server, client, ctx) {
     registerContextTool(server, ctx);
@@ -22,4 +25,7 @@ export function registerAllTools(server, client, ctx) {
     registerArtifactTools(server, client, ctx);
     registerTokenTools(server, client, ctx);
     registerSkillsTools(server, ctx);
+    registerBundledSkillsTools(server, ctx);
+    registerTemplateTools(server, ctx);
+    registerDockerfileCheckTool(server, ctx);
 }

package/dist/tools/sessions.js

@@ -1,18 +1,23 @@
 import { z } from "zod";
-import { GameyeClient } from "../client.js";
-import { AGENT_LABEL_KEY, AGENT_LABEL_VALUE, DEFAULT_SESSION_TTL, applyLaunchDefaults, assertExplicitSessionId, assertNoTokenInLaunch, describeTtl, formatDryRun, } from "../guards.js";
+import { GameyeClient, GameyeError } from "../client.js";
+import { AGENT_LABEL_KEY, AGENT_LABEL_VALUE, DEFAULT_SESSION_TTL, applyLaunchDefaults, assertExplicitSessionId, assertNoTokenInLaunch, describeTtl, formatDryRun, GuardError, } from "../guards.js";
+import { SessionLimiter } from "../limits.js";
 import { defineTool, dryRunInput, formatLabels } from "./common.js";
 function formatPorts(ports) {
     return (ports ?? []).map((p) => `${p.host}:${p.container}/${p.type}`).join(", ");
 }
 export function registerSessionTools(server, client, ctx) {
+    const limiter = new SessionLimiter(ctx.limits, client);
+    const { maxSessions, maxTtl, maxLaunches, stopOwnOnly } = ctx.limits;
     // ─── Launch Session ──────────────────────────────────────────────────────────
     defineTool(server, ctx, "gameye_launch_session", {
         title: "Launch session",
         description: "Start a containerized game server session on the Gameye platform. Returns the session ID, host and ports. Starts a billable session in the environment shown in the result prefix. " +
             `When no ttl is given, a ${DEFAULT_SESSION_TTL} TTL is applied and reported. The label ${AGENT_LABEL_KEY}=${AGENT_LABEL_VALUE} is always sent and replaces any ${AGENT_LABEL_KEY} value you pass; ` +
             "if a warm pool serves the image and region, the server ignores request labels (and env and args), so warm-pool sessions do not carry it. " +
-            "The launch is refused, with nothing sent, if any env value, arg or label contains this server's Gameye API token. Pass dryRun=true to preview the request.",
+            "The launch is refused, with nothing sent, if any env value, arg or label contains this server's Gameye API token. " +
+            `It is also refused if the ttl is above ${maxTtl}, if ${maxSessions} sessions started by this server are already running, or after ${maxLaunches} launches by this server process; ` +
+            "these limits are set by the user when the server starts, and a refusal says which one applied. Pass dryRun=true to preview the request.",
         inputSchema: {
             location: z.string().describe("Region/datacenter to host the session (e.g. 'europe', 'us-east')"),
             image: z.string().describe("Docker image name to run (e.g. 'csgo', 'tf2')"),
@@ -25,18 +30,30 @@ export function registerSessionTools(server, client, ctx) {
             ttl: z
                 .string()
                 .optional()
-                .describe(`Session time-to-live, e.g. '1h', '30m'. Session auto-stops after this duration. Defaults to ${DEFAULT_SESSION_TTL}`),
+                .describe(`Session time-to-live, e.g. '1h', '30m'. Session auto-stops after this duration. Defaults to ${DEFAULT_SESSION_TTL}; at most ${maxTtl}`),
             dryRun: dryRunInput,
         },
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: false, openWorldHint: true },
     }, async ({ dryRun, ...input }) => {
         assertNoTokenInLaunch(input, client);
         const { request, defaultTtlApplied } = applyLaunchDefaults(input);
-        const ttlLine = `  TTL:        ${describeTtl(request.ttl ?? DEFAULT_SESSION_TTL, defaultTtlApplied)}`;
+        const ttl = request.ttl ?? DEFAULT_SESSION_TTL;
+        const ttlMs = limiter.checkTtl(ttl);
+        const ttlLine = `  TTL:        ${describeTtl(ttl, defaultTtlApplied)}`;
         if (dryRun) {
             return `${formatDryRun(ctx, GameyeClient.launchSessionRequest(request), client)}\n\n${ttlLine.trim()}`;
         }
-        const result = await client.launchSession(request);
+        const slot = await limiter.reserve(ttlMs);
+        let result;
+        try {
+            result = await client.launchSession(request);
+        }
+        catch (err) {
+            // A 4xx means nothing started. A 5xx, timeout or network error may have started one.
+            slot.failed(!(err instanceof GameyeError && err.statusCode < 500));
+            throw err;
+        }
+        slot.started(result.id);
         const lines = [`Session launched successfully.`, `  Session ID: ${result.id}`, ttlLine];
         if (result.host)
             lines.push(`  Host:       ${result.host}`);
@@ -123,7 +140,9 @@ export function registerSessionTools(server, client, ctx) {
     defineTool(server, ctx, "gameye_stop_session", {
         title: "Stop session",
         description: "Terminate one Gameye session by its exact ID (sends SIGTERM to the container). Any players connected to it are disconnected. The session transitions to 'draining' then 'shuttingdown' then 'exited'. " +
-            "There is no bulk or implicit stop: an empty, wildcard or list ID is refused. Pass dryRun=true to preview the request.",
+            "There is no bulk or implicit stop: an empty, wildcard or list ID is refused. " +
+            (stopOwnOnly ? "This server only stops sessions it launched itself (GAMEYE_STOP_OWN_ONLY=1). " : "") +
+            "Pass dryRun=true to preview the request.",
         inputSchema: {
             id: z.string().min(1).describe("Exact ID of the one session to stop"),
             dryRun: dryRunInput,
@@ -131,9 +150,14 @@ export function registerSessionTools(server, client, ctx) {
         annotations: { readOnlyHint: false, destructiveHint: true, idempotentHint: true, openWorldHint: true },
     }, async ({ id: rawId, dryRun }) => {
         const id = assertExplicitSessionId(rawId);
+        if (stopOwnOnly && !limiter.isOwn(id)) {
+            throw new GuardError(`Stop refused: session ${id} was not launched by this server, and it only stops its own sessions (GAMEYE_STOP_OWN_ONLY=1). ` +
+                "Ask the user to stop it in the Admin Panel or from another tool. No request was sent.");
+        }
         if (dryRun)
             return formatDryRun(ctx, GameyeClient.stopSessionRequest(id), client);
         await client.stopSession(id);
+        limiter.stopped(id);
         return `Session ${id} stop signal sent. The session is now draining.\n\nUse gameye_describe_session to monitor shutdown progress.`;
     });
 }

package/dist/tools/skills.js

@@ -1,6 +1,7 @@
 import { z } from "zod";
 import { defineTool } from "./common.js";
 import { compareVersions, defaultSkillsEnv, describeInstall, ENABLE_UPDATE_ENV, fetchLatestPackVersion, findSkillsInstalls, isOutdated, updateCommands, } from "../skills.js";
+import { BUNDLED_SKILLS_PACK_VERSION } from "../generated/skills.js";
 const RELOAD_NOTE = "The running session keeps the skills it already loaded. Start a new session (in Claude Code, /reload-plugins also works for the plugin) to use the update.";
 export function registerSkillsTools(server, ctx, env = defaultSkillsEnv()) {
     defineTool(server, ctx, "gameye_update_skills", {
@@ -10,7 +11,9 @@ export function registerSkillsTools(server, ctx, env = defaultSkillsEnv()) {
             "Without apply it only checks and changes nothing. With apply=true it runs each outdated install's own updater " +
             "(npx skills update for the Gameye skills only, or claude plugin update) when the operator set " +
             `${ENABLE_UPDATE_ENV}=1; otherwise it lists the commands for the user to run. Ask the user before applying. ` +
-            "Updates come only through those package managers; this tool never downloads or follows skill text itself.",
+            `Also reports the skills pack bundled with this server (${BUNDLED_SKILLS_PACK_VERSION}). ` +
+            "Updates come only through those package managers. This server ships a pinned copy of the skills reviewed at build time; " +
+            "the skill and template tools never fetch skill text at runtime, and only gameye_update_skills reaches GitHub, when called.",
         inputSchema: {
             apply: z
                 .boolean()
@@ -23,8 +26,10 @@ export function registerSkillsTools(server, ctx, env = defaultSkillsEnv()) {
                 .describe("The `Pack version:` from the gameye skill you have loaded, used when no install is found on disk"),
         },
         annotations: { readOnlyHint: false, destructiveHint: false, idempotentHint: true, openWorldHint: true },
+        requiresToken: false,
     }, async ({ apply, installedVersion }) => {
         const installs = await findSkillsInstalls(env);
+        const bundled = `Bundled with this server: pack ${BUNDLED_SKILLS_PACK_VERSION} (read it with gameye_list_skills and gameye_get_skill)`;
         let latest;
         try {
             latest = await fetchLatestPackVersion(env);
@@ -33,12 +38,13 @@ export function registerSkillsTools(server, ctx, env = defaultSkillsEnv()) {
             const lines = [
                 `Could not read the latest Gameye skills pack version from GitHub: ${err instanceof Error ? err.message : String(err)}`,
                 "Nothing was updated.",
+                bundled,
             ];
             for (const install of installs)
                 lines.push(`• ${describeInstall(install)}`);
             return { text: lines.join("\n"), isError: true };
         }
-        const lines = [`Latest Gameye skills pack: ${latest}`];
+        const lines = [`Latest Gameye skills pack: ${latest}`, bundled];
         if (installs.length === 0) {
             lines.push("No skills CLI or Claude Code plugin install of the Gameye skills was found.");
             if (installedVersion) {

package/dist/tools/templates.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { type ServerContext } from "./common.js";
+export declare function registerTemplateTools(server: McpServer, ctx: ServerContext): void;

package/dist/tools/templates.js

@@ -0,0 +1,40 @@
+import { z } from "zod";
+import { defineTool } from "./common.js";
+import { BUNDLED_HEADER } from "./bundled-skills.js";
+import { BUNDLED_TEMPLATES, TEMPLATE_ENGINES, TEMPLATE_KINDS } from "../generated/skills.js";
+/** A fence of backticks longer than any backtick run in the code, so the block cannot close early. */
+function fenceFor(code) {
+    const longest = Math.max(0, ...[...code.matchAll(/`+/g)].map((m) => m[0].length));
+    return "`".repeat(Math.max(3, longest + 1));
+}
+function formatTemplate(t) {
+    const fence = fenceFor(t.code);
+    return [
+        BUNDLED_HEADER,
+        `Template: ${t.engine}/${t.kind}, from the ${t.skill} skill, section "${t.section}".`,
+        ...(t.note ? ["", `Note: ${t.note}`] : []),
+        "",
+        `${fence}${t.language}\n${t.code}${fence}`,
+        "",
+        `Read the rest of the skill with gameye_get_skill (name: "${t.skill}") before adapting this template.`,
+    ].join("\n");
+}
+export function registerTemplateTools(server, ctx) {
+    defineTool(server, ctx, "gameye_get_template", {
+        title: "Get an engine's Dockerfile or shutdown-hook template",
+        description: "Get the Dockerfile or the shutdown-hook template for an Unreal, Unity, Godot or web game server, word for word as published in the bundled Gameye engine skill, with the skill and section it came from. " +
+            "Works offline. Read the rest of the skill with gameye_get_skill. If an installed copy of the Gameye skills is newer, it wins.",
+        inputSchema: {
+            engine: z.enum(TEMPLATE_ENGINES).describe("Game server engine: unreal, unity, godot or web"),
+            kind: z.enum(TEMPLATE_KINDS).describe("Template: dockerfile or shutdown-hook"),
+        },
+        annotations: { readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
+        requiresToken: false,
+    }, async ({ engine, kind }) => {
+        const template = BUNDLED_TEMPLATES.find((t) => t.engine === engine && t.kind === kind);
+        // The bundler fails the build unless every engine and kind is present.
+        if (!template)
+            throw new Error(`No bundled ${engine}/${kind} template`);
+        return formatTemplate(template);
+    });
+}

package/dist/types.d.ts

@@ -156,6 +156,7 @@ export interface CreateTokenRequest {
     expires_after?: string;
 }
 export interface GameyeClientConfig {
+    /** API token; empty in no-token mode, where the tool gate keeps every request from being sent. */
     token: string;
     baseUrl: string;
     /** Default per-request timeout in milliseconds. Logs and artifacts get at least 60s and 120s. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gameye-mcp",
-  "version": "0.3.2",
+  "version": "0.5.0",
   "mcpName": "io.github.Gameye/gameye-mcp",
   "description": "MCP server for the Gameye game server orchestration API: launch and inspect sessions, check image tags, fetch logs and artifacts from any MCP client",
   "main": "dist/index.js",
@@ -24,6 +24,8 @@
     "test:smoke": "vitest run --config vitest.smoke.config.ts",
     "sync-spec": "node scripts/sync-spec.mjs",
     "check-spec": "node scripts/sync-spec.mjs --check",
+    "sync-skills": "node scripts/sync-skills.mjs",
+    "check-skills": "node scripts/sync-skills.mjs --check",
     "prepublishOnly": "npm run build"
   },
   "keywords": [