summer-engine 0.0.1 → 1.0.0

package/dist/commands/run.js

@@ -0,0 +1,69 @@
+import { Command } from "commander";
+import { spawn } from "child_process";
+import { existsSync } from "fs";
+import { platform } from "os";
+import { getApiPort, checkEngineHealth } from "../lib/engine.js";
+const MAC_PATHS = [
+    "/Applications/Summer.app/Contents/MacOS/Summer",
+    `${process.env.HOME}/Applications/Summer.app/Contents/MacOS/Summer`,
+];
+const WIN_PATHS = [
+    `${process.env.LOCALAPPDATA}\\Programs\\Summer Engine\\Summer.exe`,
+    `${process.env.PROGRAMFILES}\\Summer Engine\\Summer.exe`,
+];
+function findEngineBinary() {
+    const paths = platform() === "darwin" ? MAC_PATHS : WIN_PATHS;
+    for (const p of paths) {
+        if (existsSync(p))
+            return p;
+    }
+    return null;
+}
+export const runCommand = new Command("run")
+    .description("Launch Summer Engine, optionally opening a project")
+    .argument("[path]", "Path to a project directory (must contain project.godot)")
+    .action(async (projectPath) => {
+    const port = await getApiPort();
+    const health = await checkEngineHealth(port);
+    if (health && !projectPath) {
+        console.log(`Summer Engine is already running (v${health.version}) on port ${port}`);
+        if (health.project_name) {
+            console.log(`  Project: ${health.project_name}`);
+        }
+        return;
+    }
+    const binary = findEngineBinary();
+    if (!binary) {
+        console.error("Summer Engine not found. Install it first:\n" +
+            "  summer install\n" +
+            "  or download from https://summerengine.com/download");
+        process.exit(1);
+    }
+    const args = ["--editor"];
+    if (projectPath) {
+        args.unshift("--path", projectPath);
+    }
+    console.log("Launching Summer Engine...");
+    const child = spawn(binary, args, { detached: true, stdio: "ignore" });
+    child.unref();
+    // Wait for engine to start responding
+    const startTime = Date.now();
+    const timeout = 20000;
+    while (Date.now() - startTime < timeout) {
+        await sleep(500);
+        const newPort = await getApiPort();
+        const h = await checkEngineHealth(newPort);
+        if (h) {
+            console.log(`Summer Engine running (v${h.version}) on port ${newPort}`);
+            if (h.project_name) {
+                console.log(`  Project: ${h.project_name}`);
+            }
+            return;
+        }
+    }
+    console.log("Summer Engine launched but API not responding yet.\n" +
+        "It may still be loading. Run 'summer status' to check.");
+});
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

package/dist/commands/skills.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const skillsCommand: Command;

package/dist/commands/skills.js

@@ -0,0 +1,187 @@
+import { Command } from "commander";
+import { existsSync, mkdirSync, readdirSync, readFileSync, cpSync, } from "fs";
+import { join, dirname } from "path";
+import { fileURLToPath } from "url";
+import { homedir } from "os";
+const __dirname = dirname(fileURLToPath(import.meta.url));
+// Resolve skills dir: from dist/commands/skills.js -> ../../skills
+const skillsDir = join(__dirname, "..", "..", "skills");
+function getBuiltinSkills() {
+    if (!existsSync(skillsDir))
+        return [];
+    const entries = readdirSync(skillsDir, { withFileTypes: true });
+    const skills = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const skillPath = join(skillsDir, entry.name, "SKILL.md");
+        if (!existsSync(skillPath))
+            continue;
+        const meta = parseSkillFrontmatter(skillPath);
+        if (meta)
+            skills.push(meta);
+    }
+    return skills;
+}
+function parseSkillFrontmatter(skillPath) {
+    try {
+        const content = readFileSync(skillPath, "utf-8");
+        const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+        if (!match)
+            return null;
+        const front = match[1];
+        const name = front.match(/^name:\s*(.+)$/m)?.[1]?.trim();
+        const description = front.match(/^description:\s*(.+)$/m)?.[1]?.trim();
+        if (!name || !description)
+            return null;
+        return { name, description };
+    }
+    catch {
+        return null;
+    }
+}
+function getSkillPath(name) {
+    const path = join(skillsDir, name);
+    if (!existsSync(path) || !existsSync(join(path, "SKILL.md")))
+        return null;
+    return path;
+}
+export const skillsCommand = new Command("skills")
+    .description("Install and manage best-practice guides for AI agents building games")
+    .action(() => {
+    skillsCommand.outputHelp();
+});
+skillsCommand
+    .command("list")
+    .description("List available skills")
+    .action(() => {
+    const skills = getBuiltinSkills();
+    if (skills.length === 0) {
+        console.log("No skills found.");
+        return;
+    }
+    console.log("Available skills:\n");
+    for (const s of skills) {
+        console.log(`  ${s.name.padEnd(20)} ${s.description}`);
+    }
+    console.log("\nInstall: summer skills install <name>");
+});
+function resolveInstallDir(target) {
+    if (process.env.SUMMER_SKILLS_DIR) {
+        return process.env.SUMMER_SKILLS_DIR;
+    }
+    if (target === "claude") {
+        return join(homedir(), ".claude", "skills");
+    }
+    if (target === "cursor") {
+        return join(homedir(), ".cursor", "skills");
+    }
+    return join(homedir(), ".summer", "skills");
+}
+function getTargetFromOpts(opts) {
+    if (opts.asClaudeSkill)
+        return "claude";
+    if (opts.asCursorSkill)
+        return "cursor";
+    return "summer";
+}
+skillsCommand
+    .command("install [name]")
+    .description("Install a skill to ~/.summer/skills/ (or use --as-claude-skill / --as-cursor-skill)")
+    .option("--all", "Install all available skills")
+    .option("--as-claude-skill", "Install to ~/.claude/skills/ for Claude Code auto-discovery")
+    .option("--as-cursor-skill", "Install to ~/.cursor/skills/ for Cursor auto-discovery")
+    .action((name, opts) => {
+    const { all } = opts;
+    const target = getTargetFromOpts(opts);
+    const targetDir = resolveInstallDir(target);
+    if (all) {
+        const skills = getBuiltinSkills();
+        if (skills.length === 0) {
+            console.log("No skills found.");
+            return;
+        }
+        if (!existsSync(targetDir)) {
+            mkdirSync(targetDir, { recursive: true });
+        }
+        for (const s of skills) {
+            const src = getSkillPath(s.name);
+            if (src) {
+                const dest = join(targetDir, s.name);
+                cpSync(src, dest, { recursive: true });
+                console.log(`  Installed ${s.name}`);
+            }
+        }
+        console.log(`\nInstalled ${skills.length} skills to ${targetDir}`);
+        if (target === "claude") {
+            console.log("Claude Code will auto-discover these skills.");
+        }
+        else if (target === "cursor") {
+            console.log("Cursor will auto-discover these skills.");
+        }
+        else {
+            console.log("AI agents can read: <dir>/<name>/SKILL.md");
+        }
+        return;
+    }
+    if (!name) {
+        console.error("Specify a skill name or use --all to install all skills.");
+        console.log("\nAvailable skills:");
+        for (const s of getBuiltinSkills()) {
+            console.log(`  ${s.name}`);
+        }
+        process.exit(1);
+    }
+    const src = getSkillPath(name);
+    if (!src) {
+        console.error(`Unknown skill: ${name}`);
+        const skills = getBuiltinSkills();
+        if (skills.length > 0) {
+            console.log("\nAvailable skills:");
+            for (const s of skills) {
+                console.log(`  ${s.name}`);
+            }
+        }
+        process.exit(1);
+    }
+    if (!existsSync(targetDir)) {
+        mkdirSync(targetDir, { recursive: true });
+    }
+    const dest = join(targetDir, name);
+    cpSync(src, dest, { recursive: true });
+    console.log(`Installed ${name} to ${dest}`);
+    if (target === "claude") {
+        console.log("Claude Code will auto-discover this skill.");
+    }
+    else if (target === "cursor") {
+        console.log("Cursor will auto-discover this skill.");
+    }
+    else {
+        console.log(`\nAI agents can read: ${dest}/SKILL.md`);
+    }
+});
+skillsCommand
+    .command("info <name>")
+    .description("Show skill description and preview")
+    .action((name) => {
+    const src = getSkillPath(name);
+    if (!src) {
+        console.error(`Unknown skill: ${name}`);
+        process.exit(1);
+    }
+    const skillPath = join(src, "SKILL.md");
+    const content = readFileSync(skillPath, "utf-8");
+    const meta = parseSkillFrontmatter(skillPath);
+    if (meta) {
+        console.log(`\n${meta.name}`);
+        console.log("─".repeat(40));
+        console.log(meta.description);
+        console.log("\n" + "─".repeat(40));
+    }
+    const body = content.replace(/^---\s*\n[\s\S]*?\n---\s*\n/, "");
+    const preview = body.split("\n").slice(0, 30).join("\n");
+    console.log(preview);
+    if (body.split("\n").length > 30) {
+        console.log("\n...");
+    }
+});

package/dist/commands/status.d.ts

@@ -0,0 +1,2 @@
+import { Command } from "commander";
+export declare const statusCommand: Command;

package/dist/commands/status.js

@@ -0,0 +1,43 @@
+import { Command } from "commander";
+import { getAuthToken, getUserInfo } from "../lib/auth.js";
+import { getApiToken, getApiPort, checkEngineHealth } from "../lib/engine.js";
+export const statusCommand = new Command("status")
+    .description("Check Summer Engine status, connection, and auth state")
+    .action(async () => {
+    console.log("Summer Engine Status\n");
+    const authToken = await getAuthToken();
+    const userInfo = await getUserInfo();
+    if (authToken) {
+        console.log(`  Auth: Logged in${userInfo ? ` as ${userInfo.email}` : ""}`);
+    }
+    else {
+        console.log("  Auth: Not logged in");
+        console.log("        Run: npx summer-engine login");
+        console.log("        Or: https://www.summerengine.com/login");
+    }
+    const apiToken = await getApiToken();
+    const port = await getApiPort();
+    if (!apiToken) {
+        console.log("  Engine: Not running (no api-token found)");
+        console.log("\n  To start: summer run");
+        return;
+    }
+    console.log(`  API Token: Found (~/.summer/api-token)`);
+    console.log(`  Port: ${port}`);
+    const health = await checkEngineHealth(port);
+    if (!health) {
+        console.log("  Engine: Not responding (may have closed since last launch)");
+        console.log("\n  To start: summer run");
+        return;
+    }
+    console.log(`  Engine: Running (v${health.version})`);
+    if (health.project_name) {
+        console.log(`  Project: ${health.project_name}`);
+    }
+    if (health.project_path) {
+        console.log(`  Path: ${health.project_path}`);
+    }
+    if (health.scene) {
+        console.log(`  Scene: ${health.scene}`);
+    }
+});

package/dist/lib/api-client.d.ts

@@ -0,0 +1,17 @@
+export declare class EngineApiClient {
+    private port;
+    private token;
+    constructor(port: number, token: string);
+    static connect(): Promise<EngineApiClient>;
+    private request;
+    health(): Promise<unknown>;
+    executeOps(ops: Record<string, unknown>[], options?: Record<string, unknown>): Promise<unknown>;
+    getSceneState(): Promise<unknown>;
+    getProjectState(): Promise<unknown>;
+    getDiagnostics(): Promise<unknown>;
+    inspectNode(path: string): Promise<unknown>;
+    inspectResource(path: string): Promise<unknown>;
+    getScriptErrors(path: string): Promise<unknown>;
+    play(scene?: string): Promise<unknown>;
+    stop(): Promise<unknown>;
+}

package/dist/lib/api-client.js

@@ -0,0 +1,69 @@
+import { getApiToken, getApiPort, checkEngineHealth } from "./engine.js";
+export class EngineApiClient {
+    port;
+    token;
+    constructor(port, token) {
+        this.port = port;
+        this.token = token;
+    }
+    static async connect() {
+        const port = await getApiPort();
+        const token = await getApiToken();
+        if (!token) {
+            throw new Error("Summer Engine is not running (no api-token found). Open Summer Engine first.");
+        }
+        const health = await checkEngineHealth(port);
+        if (!health) {
+            throw new Error(`Summer Engine is not responding on port ${port}. Make sure it's open.`);
+        }
+        return new EngineApiClient(port, token);
+    }
+    async request(method, path, body) {
+        const url = `http://127.0.0.1:${this.port}${path}`;
+        const headers = {
+            Authorization: `Bearer ${this.token}`,
+            "Content-Type": "application/json",
+        };
+        const res = await fetch(url, {
+            method,
+            headers,
+            body: body ? JSON.stringify(body) : undefined,
+            signal: AbortSignal.timeout(30000),
+        });
+        if (!res.ok) {
+            const text = await res.text().catch(() => "");
+            throw new Error(`Engine API error ${res.status}: ${text.slice(0, 200)}`);
+        }
+        return res.json();
+    }
+    async health() {
+        return this.request("GET", "/api/health");
+    }
+    async executeOps(ops, options) {
+        return this.request("POST", "/api/ops", { ops, options });
+    }
+    async getSceneState() {
+        return this.request("GET", "/api/state/scene");
+    }
+    async getProjectState() {
+        return this.request("GET", "/api/state/project");
+    }
+    async getDiagnostics() {
+        return this.request("GET", "/api/state/diagnostics");
+    }
+    async inspectNode(path) {
+        return this.request("GET", `/api/state/inspector?path=${encodeURIComponent(path)}`);
+    }
+    async inspectResource(path) {
+        return this.request("GET", `/api/state/resource?path=${encodeURIComponent(path)}`);
+    }
+    async getScriptErrors(path) {
+        return this.request("GET", `/api/state/script-errors?path=${encodeURIComponent(path)}`);
+    }
+    async play(scene) {
+        return this.request("POST", "/api/play", scene ? { scene } : {});
+    }
+    async stop() {
+        return this.request("POST", "/api/stop");
+    }
+}

package/dist/lib/auth.d.ts

@@ -0,0 +1,13 @@
+export declare function getSummerDir(): string;
+export declare function getAuthToken(): Promise<string | null>;
+export declare function saveAuthToken(token: string): Promise<void>;
+export declare function getUserInfo(): Promise<{
+    id: string;
+    email: string;
+    name?: string;
+} | null>;
+export declare function saveUserInfo(info: {
+    id: string;
+    email: string;
+    name?: string;
+}): Promise<void>;

package/dist/lib/auth.js

@@ -0,0 +1,39 @@
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+const SUMMER_DIR = join(homedir(), ".summer");
+export function getSummerDir() {
+    return SUMMER_DIR;
+}
+async function ensureSummerDir() {
+    if (!existsSync(SUMMER_DIR)) {
+        await mkdir(SUMMER_DIR, { recursive: true, mode: 0o700 });
+    }
+}
+export async function getAuthToken() {
+    try {
+        const token = await readFile(join(SUMMER_DIR, "auth-token"), "utf-8");
+        return token.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveAuthToken(token) {
+    await ensureSummerDir();
+    await writeFile(join(SUMMER_DIR, "auth-token"), token, { encoding: "utf-8", mode: 0o600 });
+}
+export async function getUserInfo() {
+    try {
+        const data = await readFile(join(SUMMER_DIR, "user.json"), "utf-8");
+        return JSON.parse(data);
+    }
+    catch {
+        return null;
+    }
+}
+export async function saveUserInfo(info) {
+    await ensureSummerDir();
+    await writeFile(join(SUMMER_DIR, "user.json"), JSON.stringify(info, null, 2), { encoding: "utf-8", mode: 0o600 });
+}

package/dist/lib/banner.d.ts

@@ -0,0 +1,4 @@
+export declare function getBanner(version?: string): string;
+export declare function getWelcome(version: string): string;
+export declare function printBanner(version?: string): void;
+export declare function printWelcome(version: string): void;

package/dist/lib/banner.js

@@ -0,0 +1,122 @@
+export function getBanner(version) {
+    const reset = "\x1b[0m";
+    // Vertical gradient for SUMMER ENGINE
+    const colors = [
+        "\x1b[38;2;255;223;137m", // row 1
+        "\x1b[38;2;255;203;107m", // row 2
+        "\x1b[38;2;255;183;78m", // row 3
+        "\x1b[38;2;255;163;49m", // row 4
+        "\x1b[38;2;255;143;23m", // row 5
+        "\x1b[38;2;255;123;0m", // row 6
+        "\x1b[38;2;242;104;0m", // row 7
+        "\x1b[38;2;229;85;0m", // row 8
+        "\x1b[38;2;215;67;0m", // row 9
+        "\x1b[38;2;201;50;0m", // row 10
+        "\x1b[38;2;187;34;0m", // row 11
+        "\x1b[38;2;173;20;0m", // row 12
+    ];
+    const headerLines = [
+        "      ██████╗ ██╗   ██╗███╗   ███╗███╗   ███╗███████╗██████╗ ",
+        "     ██╔════╝ ██║   ██║████╗ ████║████╗ ████║██╔════╝██╔══██╗",
+        "     ███████╗ ██║   ██║██╔████╔██║██╔████╔██║█████╗  ██████╔╝",
+        "     ╚════██║ ██║   ██║██║╚██╔╝██║██║╚██╔╝██║██╔══╝  ██╔══██╗",
+        "     ███████║ ╚██████╔╝██║ ╚═╝ ██║██║ ╚═╝ ██║███████╗██║  ██║",
+        "     ╚══════╝  ╚═════╝ ╚═╝     ╚═╝╚═╝     ╚═╝╚══════╝╚═╝  ╚═╝",
+        "      ███████╗███╗   ██╗ ██████╗ ██╗███╗   ██╗███████╗       ",
+        "      ██╔════╝████╗  ██║██╔════╝ ██║████╗  ██║██╔════╝       ",
+        "      █████╗  ██╔██╗ ██║██║  ███╗██║██╔██╗ ██║█████╗         ",
+        "      ██╔══╝  ██║╚██╗██║██║   ██║██║██║╚██╗██║██╔══╝         ",
+        "      ███████╗██║ ╚████║╚██████╔╝██║██║ ╚████║███████╗       ",
+        "      ╚══════╝╚═╝  ╚═══╝ ╚═════╝ ╚═╝╚═╝  ╚═══╝╚══════╝       ",
+    ];
+    return headerLines.map((line, i) => `${colors[i]}${line}${reset}`).join("\n");
+}
+export function getWelcome(version) {
+    const reset = "\x1b[0m";
+    const dim = "\x1b[2m";
+    const bold = "\x1b[1m";
+    const sunC1 = "\x1b[38;2;255;223;137m"; // Light yellow
+    const sunC2 = "\x1b[38;2;255;163;49m"; // Orange
+    const sunC3 = "\x1b[38;2;229;85;0m"; // Red-orange
+    function stripAnsi(str) {
+        return str.replace(/\x1b\[[0-9;]*m/g, '');
+    }
+    function pad(str, target) {
+        const visLen = stripAnsi(str).length;
+        return str + " ".repeat(Math.max(0, target - visLen));
+    }
+    const sessionId = Date.now().toString().slice(-6).padEnd(6, ' ');
+    // Left column (Sun) fixed 27 width
+    const left = [
+        pad("", 27),
+        pad(`             ${sunC2}|${reset}`, 27),
+        pad(`        ${sunC1}\\${reset}    ${sunC2}|${reset}    ${sunC1}/${reset}`, 27),
+        pad(`     ${sunC1}.${reset}    ${sunC2}..::.:..${reset}    ${sunC1}.${reset}`, 27),
+        pad(`        ${sunC2}.:::"""":::.${reset}`, 27),
+        pad(`    ${sunC3}---:::${sunC2}'      '${sunC3}:::---${reset}`, 27),
+        pad(`       ${sunC3}:::        :::${reset}`, 27),
+        pad(`    ${sunC3}---:::.      .:::---${reset}`, 27),
+        pad(`        ${sunC3}':::....:::'${reset}`, 27),
+        pad(`     ${sunC1}'${reset}    ${sunC3}''::::''${reset}    ${sunC1}'${reset}`, 27),
+        pad(`        ${sunC1}/${reset}    ${sunC3}|${reset}    ${sunC1}\\${reset}`, 27),
+        pad(`             ${sunC3}|${reset}`, 27),
+        pad("", 27),
+        pad("", 27),
+        pad("", 27)
+    ];
+    // Right column fixed 42 width
+    const right = [
+        pad("", 42),
+        pad(`${bold}Available Commands${reset}`, 42),
+        pad(`${dim}summer install:${reset} Download the engine`, 42),
+        pad(`${dim}summer login:${reset}   Sign in to your account`, 42),
+        pad(`${dim}summer create:${reset}  Create a new project`, 42),
+        pad(`${dim}summer mcp:${reset}     Start MCP server`, 42),
+        pad("", 42),
+        pad(`${bold}Available Skills${reset}`, 42),
+        pad(`cloud: ${dim}animation, texturing${reset}`, 42),
+        pad(`local: ${dim}debugging, 2d, scene${reset}`, 42),
+        pad("", 42),
+        pad(`${bold}Connected Engine${reset}`, 42),
+        pad(`Status:  ${dim}Ready${reset}`, 42),
+        pad(`Version: ${dim}Summer Engine v${version}${reset}`, 42),
+        pad(`Session: ${dim}summer_${sessionId}${reset}`, 42)
+    ];
+    const footerLines = [
+        pad("", 69),
+        pad(`  ${sunC2}summer-engine-cli${reset} · ${dim}local${reset}`, 69),
+        pad(`  ${dim}Docs: https://summerengine.com/docs/mcp${reset}`, 69)
+    ];
+    const title = ` Summer Engine CLI v${version} `;
+    const titleLen = stripAnsi(title).length;
+    const totalDashes = 69 - titleLen;
+    const leftDashes = Math.floor(totalDashes / 2);
+    const rightDashes = totalDashes - leftDashes;
+    const boxTop = `${dim}┌${"─".repeat(leftDashes)}${title}${"─".repeat(rightDashes)}┐${reset}`;
+    const boxBottom = `${dim}└${"─".repeat(69)}┘${reset}`;
+    const bodyLines = [
+        ...left.map((l, i) => `${dim}│${reset}${l}${right[i]}${dim}│${reset}`),
+        ...footerLines.map(f => `${dim}│${reset}${f}${dim}│${reset}`)
+    ];
+    return [
+        "",
+        getBanner(),
+        "",
+        boxTop,
+        ...bodyLines,
+        boxBottom,
+        "",
+        `⚠️  ${dim}Some tools disabled (missing engine connection):${reset}`,
+        `• Scene Operations ${dim}(needs running editor instance)${reset}`,
+        `Run '${bold}summer mcp${reset}' to connect.`,
+        "",
+        `Welcome to Summer CLI! Type your message or /help for commands.`,
+        ""
+    ].join("\n");
+}
+export function printBanner(version) {
+    console.log(getBanner(version));
+}
+export function printWelcome(version) {
+    console.log(getWelcome(version));
+}

package/dist/lib/engine.d.ts

@@ -0,0 +1,12 @@
+export declare function getApiToken(): Promise<string | null>;
+export declare function getApiPort(): Promise<number>;
+export interface EngineHealth {
+    ok: boolean;
+    engine: string;
+    version: string;
+    port: number;
+    project_name?: string;
+    project_path?: string;
+    scene?: string;
+}
+export declare function checkEngineHealth(port: number): Promise<EngineHealth | null>;

package/dist/lib/engine.js

@@ -0,0 +1,36 @@
+import { readFile } from "fs/promises";
+import { join } from "path";
+import { getSummerDir } from "./auth.js";
+const DEFAULT_PORT = 6550;
+export async function getApiToken() {
+    try {
+        const token = await readFile(join(getSummerDir(), "api-token"), "utf-8");
+        return token.trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+export async function getApiPort() {
+    try {
+        const port = await readFile(join(getSummerDir(), "api-port"), "utf-8");
+        const parsed = parseInt(port.trim(), 10);
+        return isNaN(parsed) ? DEFAULT_PORT : parsed;
+    }
+    catch {
+        return DEFAULT_PORT;
+    }
+}
+export async function checkEngineHealth(port) {
+    try {
+        const res = await fetch(`http://127.0.0.1:${port}/api/health`, {
+            signal: AbortSignal.timeout(2000),
+        });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+}

package/dist/mcp/server.d.ts

@@ -0,0 +1,4 @@
+import { EngineApiClient } from "../lib/api-client.js";
+export declare function getClient(): Promise<EngineApiClient>;
+export declare function resetClient(): void;
+export declare function startMcpServer(): Promise<void>;

package/dist/mcp/server.js

@@ -0,0 +1,40 @@
+import { createRequire } from "node:module";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { EngineApiClient } from "../lib/api-client.js";
+import { registerSceneTools } from "./tools/scene-tools.js";
+import { registerDebugTools } from "./tools/debug-tools.js";
+import { registerProjectTools } from "./tools/project-tools.js";
+import { registerAssetTools } from "./tools/asset-tools.js";
+const require = createRequire(import.meta.url);
+const { version } = require("../../package.json");
+let cachedClient = null;
+export async function getClient() {
+    if (cachedClient) {
+        return cachedClient;
+    }
+    try {
+        cachedClient = await EngineApiClient.connect();
+        return cachedClient;
+    }
+    catch {
+        cachedClient = null;
+        throw new Error("Summer Engine is not running. Open it first, or run: npx summer-engine run");
+    }
+}
+export function resetClient() {
+    cachedClient = null;
+}
+export async function startMcpServer() {
+    const server = new McpServer({
+        name: "summer-engine",
+        version,
+    });
+    registerSceneTools(server);
+    registerDebugTools(server);
+    registerProjectTools(server);
+    registerAssetTools(server);
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    process.stderr.write(`[summer-mcp] MCP server running v${version}. 28 tools available.\n`);
+}