summer-engine 3.4.1 → 3.5.1

package/dist/installer/agent-config.js

@@ -73,6 +73,180 @@ export async function configureAgentMcp(options) {
         nextSteps: [`Updated ${target.path}.`, spec.restart],
     };
 }
+/** The Summer Games player MCP: friends, parties, messages and the player's
+ *  inbox, as the signed-in player. A remote server; the agent signs in to it
+ *  with OAuth in the browser, so setup writes no credential. */
+export const SUMMER_GAMES_MCP_SERVER_NAME = "summer-games";
+export const SUMMER_GAMES_MCP_URL = "https://mcp.summer.games/mcp";
+/**
+ * Adds the Summer Games MCP next to summer-engine in the same config file, in
+ * the agent's own entry shape (remoteMcp in agent-table.ts). An entry that
+ * already points at the same URL, under any name, counts as added and is left
+ * as it is. Returns null for agents without remoteMcp.
+ */
+export async function configureSummerGamesMcp(options) {
+    const spec = agentSpec(options.agent);
+    if (!spec.remoteMcp)
+        return null;
+    const env = options.env ?? process.env;
+    const target = resolveConfigTarget(spec, options.scope, resolve(options.cwd ?? process.cwd()), env);
+    const write = !options.dryRun;
+    const url = SUMMER_GAMES_MCP_URL;
+    const name = SUMMER_GAMES_MCP_SERVER_NAME;
+    const entry = spec.remoteMcp.entry(url);
+    const key = topLevelKey(spec.format);
+    let existing;
+    let changed = false;
+    switch (spec.format) {
+        case "toml":
+        case "toml-array": {
+            const current = await readTextFileIfExists(target.path);
+            existing = spec.format === "toml" ? findTomlServerByUrl(current, url) : findTomlArrayServerByUrl(current, url);
+            if (existing)
+                break;
+            const next = spec.format === "toml"
+                ? upsertTomlTable(current, renderTomlTable(`[mcp_servers.${name}]`, entry), name)
+                : upsertTomlArrayBlock(current, renderTomlTable("[[mcp_servers]]", entry), name);
+            changed = current !== next;
+            if (write && changed)
+                await writeTextFile(target.path, next);
+            break;
+        }
+        case "yaml-goose":
+        case "yaml-hermes": {
+            const current = await readTextFileIfExists(target.path);
+            const parsed = current.trim() === "" ? {} : parseDocument(current).toJS();
+            existing = isJsonObject(parsed) ? findServerByUrl([parsed[key]], url) : undefined;
+            if (existing)
+                break;
+            ({ changed } = await upsertYamlConfig(target.path, [key, name], entry, write));
+            break;
+        }
+        case "json-gemini":
+            throw new Error("The Gemini extension manifest has no Summer Games entry.");
+        default: {
+            const current = await readJsonConfig(target.path);
+            const maps = [current[key]];
+            // Claude Code's ~/.claude.json also keeps per-project servers (`claude
+            // mcp add` without --scope user) under projects.<dir>.mcpServers.
+            if (isJsonObject(current.projects)) {
+                for (const project of Object.values(current.projects)) {
+                    if (isJsonObject(project))
+                        maps.push(project.mcpServers);
+                }
+            }
+            existing = findServerByUrl(maps, url);
+            if (existing)
+                break;
+            const next = copyJsonObject(current);
+            next[key] = mergeNamedObject(next[key], name, entry, key);
+            const nextRendered = renderJsonFile(next);
+            changed = renderJsonFile(current) !== nextRendered;
+            if (write && changed)
+                await writeTextFile(target.path, nextRendered);
+        }
+    }
+    const serverName = existing ?? name;
+    return {
+        serverName,
+        url,
+        path: target.path,
+        changed,
+        wrote: write && changed,
+        ...(existing && existing !== name ? { existingName: existing } : {}),
+        signIn: spec.remoteMcp.signIn(serverName),
+    };
+}
+function sameMcpUrl(a, b) {
+    if (typeof a !== "string")
+        return false;
+    const normalize = (value) => {
+        try {
+            const parsed = new URL(value.trim());
+            return `${parsed.protocol}//${parsed.host}${parsed.pathname.replace(/\/+$/, "")}`.toLowerCase();
+        }
+        catch {
+            return value.trim().toLowerCase();
+        }
+    };
+    return normalize(a) === normalize(b);
+}
+/** Agents name a remote server's address url, serverUrl (Windsurf,
+ *  Antigravity), httpUrl (Qwen Code) or uri (Goose). */
+const REMOTE_URL_FIELDS = ["url", "serverUrl", "httpUrl", "uri"];
+/** The name of a server with this URL in any of these name -> entry maps. */
+function findServerByUrl(maps, url) {
+    for (const map of maps) {
+        if (!isJsonObject(map))
+            continue;
+        for (const [name, entry] of Object.entries(map)) {
+            if (isJsonObject(entry) && REMOTE_URL_FIELDS.some((field) => sameMcpUrl(entry[field], url)))
+                return name;
+        }
+    }
+    return undefined;
+}
+/** The name of a [[mcp_servers]] block (Mistral Vibe) whose url is this URL. */
+function findTomlArrayServerByUrl(content, url) {
+    let block;
+    const done = () => (block?.matches ? block.name : undefined);
+    for (const line of content.split(/\r?\n/)) {
+        if (/^\s*\[/.test(line)) {
+            if (done())
+                return done();
+            block = /^\s*\[\[mcp_servers\]\]\s*(?:#.*)?$/.test(line) ? { matches: false } : undefined;
+            continue;
+        }
+        if (!block)
+            continue;
+        const field = /^\s*(name|url)\s*=\s*(?:"([^"]*)"|'([^']*)')/.exec(line);
+        if (!field)
+            continue;
+        const value = field[2] ?? field[3];
+        if (field[1] === "name")
+            block.name = value;
+        else if (sameMcpUrl(value, url))
+            block.matches = true;
+    }
+    return done();
+}
+/** A TOML table: the header line, then key = value for each entry field. */
+function renderTomlTable(header, entry) {
+    return `${[header, ...Object.entries(entry).map(([field, value]) => `${field} = ${tomlValue(value)}`)].join("\n")}\n`;
+}
+function tomlValue(value) {
+    if (typeof value === "string")
+        return tomlString(value);
+    if (typeof value === "number" || typeof value === "boolean")
+        return String(value);
+    if (Array.isArray(value))
+        return `[${value.map(tomlValue).join(", ")}]`;
+    if (isJsonObject(value)) {
+        const fields = Object.entries(value).map(([field, inner]) => `${field} = ${tomlValue(inner)}`);
+        return fields.length === 0 ? "{}" : `{ ${fields.join(", ")} }`;
+    }
+    throw new Error(`Cannot write ${JSON.stringify(value)} as TOML.`);
+}
+/** The name of a [mcp_servers.<name>] table whose url is this URL. */
+function findTomlServerByUrl(content, url) {
+    let table;
+    for (const line of content.split(/\r?\n/)) {
+        const header = /^\s*\[([^\[\]]+)\]\s*(?:#.*)?$/.exec(line);
+        if (header) {
+            const server = /^mcp_servers\.(?:"([^"]+)"|([A-Za-z0-9_-]+))$/.exec(header[1].trim());
+            table = server ? (server[1] ?? server[2]) : undefined;
+            continue;
+        }
+        if (/^\s*\[/.test(line)) {
+            table = undefined;
+            continue;
+        }
+        const value = /^\s*url\s*=\s*(?:"([^"]*)"|'([^']*)')/.exec(line);
+        if (table && value && sameMcpUrl(value[1] ?? value[2], url))
+            return table;
+    }
+    return undefined;
+}
 async function upsertConfig(format, path, server, write) {
     switch (format) {
         case "toml":
@@ -320,10 +494,10 @@ async function upsertTomlArrayConfig(path, server, write) {
     }
     return { changed };
 }
-export function upsertTomlArrayBlock(content, block) {
+export function upsertTomlArrayBlock(content, block, name = SUMMER_MCP_SERVER_NAME) {
     const lines = content.split(/\r?\n/);
     const header = /^\s*\[\[mcp_servers\]\]\s*(?:#.*)?$/;
-    const nameLine = new RegExp(`^\\s*name\\s*=\\s*"${SUMMER_MCP_SERVER_NAME}"\\s*(?:#.*)?$`);
+    const nameLine = new RegExp(`^\\s*name\\s*=\\s*"${name}"\\s*(?:#.*)?$`);
     let start = -1;
     let end = lines.length;
     for (let index = 0; index < lines.length; index += 1) {
@@ -470,10 +644,11 @@ async function readTextFileIfExists(path) {
         throw new Error(`Could not read ${path}: ${formatError(error)}`);
     }
 }
-function upsertTomlTable(content, table) {
+function upsertTomlTable(content, table, name = SUMMER_MCP_SERVER_NAME) {
     const lines = content.split(/\r?\n/);
-    const serverHeader = /^\s*\[mcp_servers\.(?:"summer-engine"|summer-engine)(?:\.|\])/;
-    const start = lines.findIndex((line) => /^\s*\[mcp_servers\.(?:"summer-engine"|summer-engine)\]\s*(?:#.*)?$/.test(line));
+    const key = name.replace(/[.*+?^${}()|[\]\\-]/g, "\\$&");
+    const serverHeader = new RegExp(`^\\s*\\[mcp_servers\\.(?:"${key}"|${key})(?:\\.|\\])`);
+    const start = lines.findIndex((line) => new RegExp(`^\\s*\\[mcp_servers\\.(?:"${key}"|${key})\\]\\s*(?:#.*)?$`).test(line));
     if (start === -1) {
         const trimmed = content.endsWith("\n") || content === "" ? content : `${content}\n`;
         return `${trimmed}${trimmed === "" ? "" : "\n"}${table}`;

package/dist/installer/agent-table.d.ts

@@ -70,6 +70,19 @@ export interface AgentSpec {
     /** Env var that overrides the MCP config path (tests, unusual installs). */
     envOverride: string;
     format: McpFormat;
+    /**
+     * The Summer Games player MCP (a remote server that signs in with OAuth on
+     * its own) in this agent's file, under the same key as summer-engine.
+     * entry is the server's value; for TOML it is written as key = value lines.
+     * signIn tells the person how to sign in once, for the entry's name.
+     * Absent: setup links the engine only (no OAuth sign-in for remote servers,
+     * no file entry for them, or a sign-in api.summer.games has not been checked
+     * to accept).
+     */
+    remoteMcp?: {
+        entry: (url: string) => Record<string, unknown>;
+        signIn: (name: string) => string;
+    };
     mcp: {
         /** null: user-level servers are managed in the app's UI; a user request writes the project file with a warning. */
         user: ((ctx: PathContext) => string) | null;

package/dist/installer/agent-table.js

@@ -108,6 +108,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_CLAUDE_CONFIG_FILE",
         format: "json-stdio",
+        remoteMcp: {
+            entry: (url) => ({ type: "http", url }),
+            signIn: (name) => `In Claude Code, run /mcp, choose ${name} and sign in.`,
+        },
         mcp: { user: home(".claude.json"), project: project(".mcp.json") },
         restart: "Restart Claude Code or run /mcp in a new session.",
         skills: skillDirs(home(".claude", "skills"), project(".claude", "skills")),
@@ -119,6 +123,7 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_CLAUDE_DESKTOP_CONFIG_FILE",
         format: "json",
+        // No Summer Games entry: Claude Desktop's file takes local servers only; remote ones are added as Connectors in its settings.
         mcp: {
             user: (ctx) => join(appConfigRoot(ctx), "Claude", "claude_desktop_config.json"),
             project: null,
@@ -134,6 +139,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_CODEX_CONFIG_FILE",
         format: "toml",
+        remoteMcp: {
+            entry: (url) => ({ url }),
+            signIn: (name) => `In Codex, run /mcp login ${name} (or \`codex mcp login ${name}\` in a terminal) and sign in.`,
+        },
         mcp: {
             user: home(".codex", "config.toml"),
             project: project(".codex", "config.toml"),
@@ -149,6 +158,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_CURSOR_MCP_CONFIG_FILE",
         format: "json-stdio",
+        remoteMcp: {
+            entry: (url) => ({ url }),
+            signIn: (name) => `In Cursor Settings, open MCP and click Connect (or Authenticate) next to ${name}.`,
+        },
         mcp: { user: home(".cursor", "mcp.json"), project: project(".cursor", "mcp.json") },
         restart: "Restart Cursor and enable the summer-engine MCP server if prompted.",
         skills: sharedSkills({
@@ -164,6 +177,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_WINDSURF_MCP_CONFIG_FILE",
         format: "json",
+        remoteMcp: {
+            entry: (url) => ({ serverUrl: url }),
+            signIn: (name) => `Devin Desktop opens summer.games in your browser the first time ${name} connects; sign in there.`,
+        },
         mcp: {
             user: home(".codeium", "windsurf", "mcp_config.json"),
             project: null,
@@ -178,6 +195,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_ANTIGRAVITY_CONFIG_FILE",
         format: "json",
+        remoteMcp: {
+            entry: (url) => ({ serverUrl: url }),
+            signIn: (name) => `In Antigravity, open Settings > Customizations, choose Authenticate next to ${name}, sign in on summer.games, then paste the code back and choose Submit.`,
+        },
         mcp: {
             user: home(".gemini", "config", "mcp_config.json"),
             project: project(".agents", "mcp_config.json"),
@@ -193,6 +214,7 @@ const SPECS = [
         legacyNote: "Gemini CLI was retired for individual accounts on 2026-06-18 and replaced by Antigravity. Use `summer setup antigravity` unless you are on a Workspace/enterprise Gemini CLI.",
         envOverride: "SUMMER_GEMINI_CONFIG_FILE",
         format: "json-gemini",
+        // No Summer Games entry: legacy target; use antigravity.
         mcp: {
             user: home(".gemini", "extensions", "summer-engine", "gemini-extension.json"),
             project: null,
@@ -207,6 +229,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_CLINE_CONFIG_FILE",
         format: "json",
+        remoteMcp: {
+            entry: (url) => ({ type: "streamableHttp", url }),
+            signIn: (name) => `In Cline, open MCP Servers and click Authenticate next to ${name}.`,
+        },
         mcp: {
             user: (ctx) => vsCodeGlobalStorage(ctx, "saoudrizwan.claude-dev", "cline_mcp_settings.json"),
             project: null,
@@ -221,6 +247,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_CLINE_CLI_CONFIG_FILE",
         format: "json",
+        remoteMcp: {
+            entry: (url) => ({ type: "streamableHttp", url }),
+            signIn: (name) => `Run \`cline mcp\`, pick ${name} and choose Authorize OAuth.`,
+        },
         mcp: { user: home(".cline", "data", "settings", "cline_mcp_settings.json"), project: null },
         restart: "Restart the Cline CLI so it reloads its MCP settings.",
         skills: skillDirs(home(".cline", "skills"), project(".cline", "skills")),
@@ -233,6 +263,7 @@ const SPECS = [
         legacyNote: "Roo Code shut down on 2026-05-15. The extension may still run, but it is no longer maintained; consider Cline or Kilo Code.",
         envOverride: "SUMMER_ROO_CODE_CONFIG_FILE",
         format: "json",
+        // No Summer Games entry: Roo Code has no OAuth sign-in for remote MCP servers.
         mcp: {
             user: (ctx) => vsCodeGlobalStorage(ctx, "rooveterinaryinc.roo-cline", "cline_mcp_settings.json"),
             project: null,
@@ -252,6 +283,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_KILO_CODE_CONFIG_FILE",
         format: "json-opencode",
+        remoteMcp: {
+            entry: (url) => ({ type: "remote", url }),
+            signIn: (name) => `In Kilo, click the sign-in notice for ${name} (Kilo CLI: \`kilo mcp auth ${name}\`).`,
+        },
         mcp: {
             user: (ctx) => join(xdgOrAppData(ctx), "kilo", "kilo.json"),
             project: project("kilo.json"),
@@ -266,6 +301,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_GITHUB_COPILOT_CONFIG_FILE",
         format: "json-copilot",
+        remoteMcp: {
+            entry: (url) => ({ type: "http", url, tools: ["*"] }),
+            signIn: (name) => `Copilot CLI opens summer.games to sign in when ${name} first connects; /mcp signs in again.`,
+        },
         mcp: { user: home(".copilot", "mcp-config.json"), project: project(".mcp.json") },
         restart: "Restart Copilot CLI, or run /mcp reload and /skills reload in the active session.",
         skills: skillDirs(home(".copilot", "skills"), project(".github", "skills")),
@@ -277,6 +316,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_VSCODE_COPILOT_CONFIG_FILE",
         format: "json-vscode",
+        remoteMcp: {
+            entry: (url) => ({ type: "http", url }),
+            signIn: (name) => `In VS Code, click Allow when ${name} asks to authenticate, then sign in on summer.games.`,
+        },
         mcp: { user: (ctx) => join(vsCodeUserDir(ctx), "mcp.json"), project: project(".vscode", "mcp.json") },
         restart: "Restart VS Code or run MCP: List Servers, then start summer-engine in Copilot Agent mode.",
         skills: sharedSkills({ legacyDirs: { user: home(".copilot", "skills"), project: project(".github", "skills") } }),
@@ -288,6 +331,7 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_VISUAL_STUDIO_CONFIG_FILE",
         format: "json-vscode",
+        // No Summer Games entry: Visual Studio's OAuth redirect for MCP is not documented; not checked against api.summer.games.
         mcp: { user: home(".mcp.json"), project: project(".mcp.json") },
         restart: "Restart Visual Studio, open Copilot Chat in Agent mode, and enable summer-engine in the tools picker.",
         skills: null,
@@ -300,6 +344,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_COPILOT_JETBRAINS_CONFIG_FILE",
         format: "json-servers",
+        remoteMcp: {
+            entry: (url) => ({ url }),
+            signIn: (name) => `In your JetBrains IDE, click OK when ${name} asks to authenticate, then sign in on summer.games.`,
+        },
         mcp: {
             user: (ctx) => join(xdgOrAppData(ctx), "github-copilot", "intellij", "mcp.json"),
             project: null,
@@ -315,6 +363,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_OPENCODE_CONFIG_FILE",
         format: "json-opencode",
+        remoteMcp: {
+            entry: (url) => ({ type: "remote", url }),
+            signIn: (name) => `Run \`opencode mcp auth ${name}\`; it opens summer.games to sign in.`,
+        },
         mcp: {
             user: (ctx) => join(xdgOrAppData(ctx), "opencode", "opencode.json"),
             project: project("opencode.json"),
@@ -333,6 +385,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_ZED_CONFIG_FILE",
         format: "json-zed",
+        remoteMcp: {
+            entry: (url) => ({ url }),
+            signIn: (name) => `In Zed, open the agent settings and click Authenticate next to ${name}.`,
+        },
         mcp: {
             user: (ctx) => join(xdgOrAppData(ctx), "zed", "settings.json"),
             project: null,
@@ -347,6 +403,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_KIRO_CONFIG_FILE",
         format: "json",
+        remoteMcp: {
+            entry: (url) => ({ url }),
+            signIn: (name) => `Kiro opens summer.games to sign in when ${name} connects (Kiro CLI: /mcp auth).`,
+        },
         mcp: { user: home(".kiro", "settings", "mcp.json"), project: project(".kiro", "settings", "mcp.json") },
         restart: "Kiro reloads MCP config on save; open the MCP Servers view to confirm summer-engine is connected.",
         skills: skillDirs(home(".kiro", "skills"), project(".kiro", "skills")),
@@ -358,6 +418,19 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_GOOSE_CONFIG_FILE",
         format: "yaml-goose",
+        remoteMcp: {
+            entry: (url) => ({
+                type: "streamable_http",
+                name: "summer-games",
+                description: "Summer Games: friends, parties and messages as you",
+                uri: url,
+                enabled: true,
+                timeout: 300,
+                env_keys: [],
+                envs: {},
+            }),
+            signIn: (name) => `Goose opens summer.games to sign in when the ${name} extension starts.`,
+        },
         mcp: {
             user: (ctx) => ctx.os === "win32"
                 ? join(appData(ctx), "Block", "goose", "config", "config.yaml")
@@ -374,6 +447,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_HERMES_CONFIG_FILE",
         format: "yaml-hermes",
+        remoteMcp: {
+            entry: (url) => ({ url, auth: "oauth" }),
+            signIn: (name) => `Run \`hermes mcp login ${name}\`, or sign in on summer.games when Hermes first connects.`,
+        },
         mcp: { user: home(".hermes", "config.yaml"), project: null },
         restart: "Run /reload-mcp in Hermes Agent (or restart it).",
         skills: skillDirs(home(".hermes", "skills"), SHARED_SKILLS_PROJECT, {
@@ -388,6 +465,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_TRAE_CONFIG_FILE",
         format: "json",
+        remoteMcp: {
+            entry: (url) => ({ url }),
+            signIn: (name) => `Trae opens summer.games to sign in when ${name} connects.`,
+        },
         mcp: {
             user: null,
             project: project(".trae", "mcp.json"),
@@ -404,6 +485,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_QWEN_CODE_CONFIG_FILE",
         format: "json",
+        remoteMcp: {
+            entry: (url) => ({ httpUrl: url }),
+            signIn: (name) => `In Qwen Code, run /mcp auth ${name} and sign in.`,
+        },
         mcp: { user: home(".qwen", "settings.json"), project: project(".qwen", "settings.json") },
         restart: "Restart Qwen Code or run /mcp in a new session.",
         skills: skillDirs(home(".qwen", "skills"), project(".qwen", "skills")),
@@ -415,6 +500,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_KIMI_CODE_CONFIG_FILE",
         format: "json",
+        remoteMcp: {
+            entry: (url) => ({ url, auth: "oauth" }),
+            signIn: (name) => `Run \`kimi mcp auth ${name}\`; it opens summer.games to sign in.`,
+        },
         mcp: { user: home(".kimi-code", "mcp.json"), project: project(".kimi-code", "mcp.json") },
         restart: "Restart Kimi Code CLI so it reconnects its MCP servers.",
         skills: sharedSkills({ legacyDirs: { user: home(".kimi-code", "skills"), project: project(".kimi-code", "skills") } }),
@@ -426,6 +515,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_CRUSH_CONFIG_FILE",
         format: "json-crush",
+        remoteMcp: {
+            entry: (url) => ({ type: "http", url, oauth: true }),
+            signIn: (name) => `Crush opens summer.games to sign in when ${name} connects.`,
+        },
         mcp: {
             user: home(".config", "crush", "crushrc"),
             project: project(".crushrc"),
@@ -440,6 +533,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_AMP_CONFIG_FILE",
         format: "json-amp",
+        remoteMcp: {
+            entry: (url) => ({ url }),
+            signIn: (name) => `Amp opens summer.games to sign in for ${name} when it starts.`,
+        },
         mcp: { user: (ctx) => join(xdgOrAppData(ctx), "amp", "settings.json"), project: null },
         restart: "Restart Amp so it reloads settings.json.",
         skills: sharedSkills({ legacyDirs: { user: (ctx) => join(xdgOrAppData(ctx), "amp", "skills"), project: null } }),
@@ -451,6 +548,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_FACTORY_CONFIG_FILE",
         format: "json-stdio",
+        remoteMcp: {
+            entry: (url) => ({ type: "http", url }),
+            signIn: (name) => `In Droid, run /mcp, choose ${name} and Authenticate.`,
+        },
         mcp: { user: home(".factory", "mcp.json"), project: project(".factory", "mcp.json") },
         restart: "Restart droid or run /mcp in the active session.",
         skills: sharedSkills({ legacyDirs: { user: home(".factory", "skills"), project: project(".factory", "skills") } }),
@@ -462,6 +563,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_JUNIE_CONFIG_FILE",
         format: "json",
+        remoteMcp: {
+            entry: (url) => ({ url }),
+            signIn: (name) => `In Junie, run /mcp, open ${name} and choose Authorize.`,
+        },
         mcp: { user: home(".junie", "mcp", "mcp.json"), project: project(".junie", "mcp", "mcp.json") },
         restart: "Restart the JetBrains IDE so Junie reloads its MCP config.",
         skills: null,
@@ -474,6 +579,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_WARP_CONFIG_FILE",
         format: "json",
+        remoteMcp: {
+            entry: (url) => ({ url }),
+            signIn: (name) => `Warp opens summer.games to sign in when ${name} starts.`,
+        },
         mcp: { user: home(".warp", ".mcp.json"), project: project(".warp", ".mcp.json") },
         restart: "Warp detects the file and spawns the server; check Settings > AI > MCP servers.",
         skills: sharedSkills({ legacyDirs: { user: home(".warp", "skills"), project: project(".warp", "skills") } }),
@@ -485,6 +594,7 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_ROVO_DEV_CONFIG_FILE",
         format: "json-transport",
+        // No Summer Games entry: Rovo Dev CLI has no OAuth sign-in for remote MCP servers (headers only).
         mcp: { user: home(".rovodev", "mcp.json"), project: null },
         restart: "Restart Rovo Dev CLI so it reconnects its MCP servers.",
         skills: sharedSkills({ legacyDirs: { user: home(".rovodev", "skills"), project: project(".rovodev", "skills") } }),
@@ -496,6 +606,7 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_QODER_CONFIG_FILE",
         format: "json",
+        // No Summer Games entry: Qoder's remote-server fields in settings.json are not documented.
         mcp: { user: home(".qoder", "settings.json"), project: project(".mcp.json") },
         restart: "Restart Qoder CLI so it reloads its MCP settings (the Qoder IDE manages servers in its UI).",
         skills: skillDirs(home(".qoder", "skills"), project(".qoder", "skills")),
@@ -507,6 +618,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_GROK_BUILD_CONFIG_FILE",
         format: "toml",
+        remoteMcp: {
+            entry: (url) => ({ url }),
+            signIn: (name) => `In Grok Build, run /mcps, select ${name} and press i to sign in.`,
+        },
         mcp: { user: home(".grok", "config.toml"), project: project(".grok", "config.toml") },
         restart: "Restart Grok Build so it reloads config.toml (it also reads ~/.claude.json and .cursor/mcp.json).",
         skills: sharedSkills({ legacyDirs: { user: home(".grok", "skills"), project: project(".grok", "skills") } }),
@@ -518,6 +633,10 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_MISTRAL_VIBE_CONFIG_FILE",
         format: "toml-array",
+        remoteMcp: {
+            entry: (url) => ({ name: "summer-games", transport: "streamable-http", url, auth: { type: "oauth", scopes: [] } }),
+            signIn: (name) => `In Vibe, run /mcp login ${name}.`,
+        },
         mcp: { user: home(".vibe", "config.toml"), project: project(".vibe", "config.toml") },
         restart: "Restart Vibe so it reloads config.toml.",
         skills: skillDirs(home(".vibe", "skills"), SHARED_SKILLS_PROJECT, { legacyDirs: { user: home(".vibe", "skills"), project: project(".vibe", "skills") } }),
@@ -529,6 +648,7 @@ const SPECS = [
         status: "active",
         envOverride: "SUMMER_LM_STUDIO_CONFIG_FILE",
         format: "json",
+        // No Summer Games entry: LM Studio's MCP client registration is closed and unverified.
         mcp: { user: home(".lmstudio", "mcp.json"), project: null },
         restart: "Open LM Studio, toggle on the summer-engine MCP server in the Program tab, and raise the loaded model's context length to 32k or higher.",
         skills: null,

package/dist/mcp/tools/creator-tools.js

@@ -40,7 +40,7 @@ async function creatorResult(operation) {
     }
 }
 export function registerCreatorTools(server) {
-    server.tool("summer_export_game", "Export the game in the exact file the Summer Games store takes, with the installed Summer Engine headless (no window). format \"bundle\" (default): the summer.games .zip the Summer apps run on iPhone, Android, macOS and Windows; targets picks the platforms (a game without a server: ios and android only); upload it with summer_publish_build. format \"download\" with one target: web (an HTML5 .zip on Summer's WebGPU Forward+ web template, played on summer.games), macos (.app zip, macos-universal) or windows (.exe zip, windows-x64); these need the export template from summer_export_templates and are uploaded as store versions. Needs Summer Engine 0.7.0 or newer: an older engine is refused before anything is written (code engine_too_old). Works without the editor running. Returns path, sha256, size, the manifest or store platform, and warnings.", {
+    server.tool("summer_export_game", "Export the game in the exact file the Summer Games store takes, with the installed Summer Engine headless (no window). format \"bundle\" (default): the summer.games .zip the Summer apps run on iPhone, Android, macOS and Windows; targets picks the platforms (a game without a server: ios and android only); upload it with summer_publish_build. format \"download\" with one target: web (an HTML5 .zip on Summer's WebGPU Forward+ web template, played on summer.games), macos (.app zip, macos-universal) or windows (.exe zip, windows-x64); these need the export template from summer_export_templates and are uploaded as store versions. Needs Summer Engine 0.7.0 or newer: an older engine is refused before anything is written (code engine_too_old). A target the installed engine cannot build (android needs 0.7.1) is left out: the other targets export, and skippedTargets plus a warning name it. A game with a server declares its platforms in summer.build.json; when they differ from the exported targets a warning says so (summer_publish_build would be refused), and alignDeclaration:true aligns them. Works without the editor running. Returns path, sha256, size, the manifest or store platform, and warnings.", {
         project: z.string().optional().describe("Project folder with project.godot. Defaults to the MCP's bound project, then the working directory."),
         out: z.string().optional().describe("Output .zip path. Defaults to <project>/.summer/exports/."),
         targets: z
@@ -53,7 +53,11 @@ export function registerCreatorTools(server) {
             .describe("bundle (default): the summer.games store build. download: a web build or native download; the default when targets is [\"web\"]."),
         debug: z.boolean().default(false).describe("Export a debug build (--export-debug)."),
         timeoutSeconds: z.number().int().min(10).max(7200).optional().describe("Stop the engine after this many seconds (default 900; a first export imports every asset)."),
-    }, async ({ project, out, targets, format, debug, timeoutSeconds }) => creatorResult(() => exportGame({ project, out, targets, format, debug, ...(timeoutSeconds ? { timeoutMs: timeoutSeconds * 1000 } : {}) })));
+        alignDeclaration: z
+            .boolean()
+            .optional()
+            .describe("A game with a server: set summer.build.json targetPlatforms to targets before exporting. The store refuses an upload whose declaration differs from the exported platforms (declaration_mismatch) and that spends the version."),
+    }, async ({ project, out, targets, format, debug, timeoutSeconds, alignDeclaration }) => creatorResult(() => exportGame({ project, out, targets, format, debug, alignDeclaration, ...(timeoutSeconds ? { timeoutMs: timeoutSeconds * 1000 } : {}) })));
     server.tool("summer_export_templates", "List, download and install Summer Engine export templates from Summer's CDN into the folder the installed engine reads, checking each file's sha256. Needed only for summer_export_game format \"download\": web (Summer's WebGPU Forward+ template), macos, windows. Store bundles (format \"bundle\") need no template. action list shows what is installed and published; action install fetches the platforms asked (default web).", {
         action: z.enum(["list", "install"]).describe("list: installed and published templates. install: download and install."),
         platforms: z
@@ -66,7 +70,7 @@ export function registerCreatorTools(server) {
             .optional()
             .describe("The installed Summer Engine version (Help > About, e.g. 0.7.1). Read automatically on macOS; needed on Windows and Linux."),
     }, async ({ action, platforms, includeDebug, summerVersion }) => creatorResult(() => exportTemplates({ action, platforms, includeDebug, summerVersion })));
-    server.tool("summer_capture_gameplay", "Capture real gameplay frames without a running editor: starts the game in Summer Engine's offscreen verify instance (a real renderer, a window parked offscreen with no focus, never on screen), lets it run waitSeconds, and saves PNG frames of what the game draws, HUD included. Use for store screenshots (1920x1080 landscape or 1080x1920 portrait). With an editor open, summer_screenshot target game also works. Returns each frame's path, width and height; look at them before using them.", {
+    server.tool("summer_capture_gameplay", "Capture real gameplay frames without a running editor: starts the game in Summer Engine's offscreen verify instance (--summer-offscreen: a real renderer, a window parked offscreen with no focus, never on screen), lets it run waitSeconds, runs steps, and saves PNG frames of what the game draws, HUD included. Use for store screenshots (1920x1080 landscape or 1080x1920 portrait). The main scene is often a title menu: pass the game's own flags in args (after \"--\", e.g. [\"--autostart\"]), a gameplay scene, or steps that play like a player: [{press:\"Play\"}, {wait:3000}, {key:\"Space\"}, {action:\"jump\"}, {click:[960,540]}, {drag:{from:[400,800],to:[1400,800]}}, {shot:true}]. With a shot step, only shot steps save frames; without one, frames are saved after the steps. A step that cannot run (no such button, key or action) becomes a warning. With an editor open, summer_screenshot target game also works. Returns each frame's path, width and height; look at them before using them.", {
         project: z.string().optional().describe("Project folder with project.godot. Defaults to the MCP's bound project, then the working directory."),
         scene: z.string().optional().describe("Scene to start (res://... or uid://...). Default: the project's main scene, which is often a title menu; pass the gameplay scene for gameplay frames."),
         resolution: z.string().optional().describe("Window size WIDTHxHEIGHT (default 1920x1080; 1080x1920 for portrait)."),
@@ -74,6 +78,31 @@ export function registerCreatorTools(server) {
         waitSeconds: z.number().min(0).max(120).optional().describe("Seconds the game runs before the first frame (default 3)."),
         intervalSeconds: z.number().min(0.1).max(60).optional().describe("Seconds between frames (default 1)."),
         out: z.string().optional().describe("Output folder. Defaults to <project>/.summer/captures/<time>/ (ignored by git)."),
+        args: z
+            .array(z.string())
+            .max(32)
+            .optional()
+            .describe('The game\'s own command-line flags, passed after "--" (OS.get_cmdline_user_args()), e.g. ["--autostart", "--solo"] to skip the title screen.'),
+        steps: z
+            .array(z
+            .object({
+            press: z.string().optional().describe("Press the visible button with this text (or node name); waits up to timeoutSeconds (default 10) for it."),
+            timeoutSeconds: z.number().min(0).max(60).optional(),
+            key: z.string().optional().describe("Press a key by Godot name: Space, Enter, Escape, A, Up."),
+            action: z.string().optional().describe("Press an input action from the project's InputMap, e.g. jump."),
+            holdMs: z.number().min(0).max(10000).optional().describe("How long key or action is held (default 100)."),
+            click: z.tuple([z.number(), z.number()]).optional().describe("Left-click at [x, y] in frame pixels."),
+            drag: z
+                .object({ from: z.tuple([z.number(), z.number()]), to: z.tuple([z.number(), z.number()]), ms: z.number().min(0).max(10000).optional() })
+                .optional()
+                .describe("Drag with the left button from [x, y] to [x, y] over ms (default 300)."),
+            wait: z.number().min(0).max(60000).optional().describe("Wait this many milliseconds."),
+            shot: z.boolean().optional().describe("true: save a frame now."),
+        })
+            .strict())
+            .max(50)
+            .optional()
+            .describe("What to do after waitSeconds, in order; exactly one of press, key, action, click, drag, wait, shot per step."),
     }, async (args) => creatorResult(() => captureGameplay(args)));
     server.tool("summer_publish_build", "Upload an export from summer_export_game to the creator's game on summer.games, through the same store upload Studio uses, straight from disk. A store bundle (format bundle): declare, upload parts, seal, wait until Summer makes the Build, name its client pack, and with publish=true approve it. A web build or native download (format download): upload it as the game's store version for its platform (web, macos-universal, windows-x64, linux-x64; read from the last export) and wait until Summer has checked it. First call with confirm=false: it checks that the game exists for this account and warns when its store page does not list the export's platforms, then returns the target (game name and id, file, digest, size, version) to show the user; set confirm only after they approve. Needs \"summer login --store\". A retry with the same file and clientVersion continues the same upload. Nothing here makes a game live: the owner approves publishing (summer_store_submit).", {
         gameId: z.string().optional().describe("The store game id (from summer_store_list_games, or the Studio store page URL). Without it the call fails with game_required and lists your store games, or says why the store did not list them."),