summer-engine 2.3.0 → 2.5.0

package/dist/commands/assets.js

@@ -1,189 +0,0 @@
-import { Command } from "commander";
-import { getAuthToken } from "../lib/auth.js";
-import { getClient } from "../lib/with-engine.js";
-import { outputResult, outputError, isJsonMode } from "../lib/format.js";
-const GATEWAY_URL = process.env.SUMMER_GATEWAY_URL || "https://www.summerengine.com";
-const KENNEY_URL_PATTERN = /\/kenney\/3d\/([^/]+)\//;
-function getPackSlugFromUrl(fileUrl) {
-    return fileUrl.match(KENNEY_URL_PATTERN)?.[1] ?? null;
-}
-function buildKenneyTextureUrl(fileUrl) {
-    const lastSlash = fileUrl.lastIndexOf("/");
-    const base = lastSlash >= 0 ? fileUrl.slice(0, lastSlash) : fileUrl;
-    return `${base}/Textures/colormap.png`;
-}
-async function textureExists(url) {
-    try {
-        const res = await fetch(url, {
-            method: "HEAD",
-            signal: AbortSignal.timeout(5000),
-        });
-        return res.ok;
-    }
-    catch {
-        return false;
-    }
-}
-async function buildKenneyImportEntries(fileUrl, packSlug, fileName) {
-    const textureUrl = buildKenneyTextureUrl(fileUrl);
-    const hasTexture = await textureExists(textureUrl);
-    if (!hasTexture) {
-        return [
-            {
-                url: fileUrl,
-                path: `res://assets/models/kenney/${packSlug}/${fileName}`,
-            },
-        ];
-    }
-    const glbPath = `res://assets/models/kenney/${packSlug}/${fileName}`;
-    const glbDir = glbPath.replace(/\/[^/]+$/, "");
-    const texturePath = `${glbDir}/Textures/colormap.png`;
-    return [
-        { url: textureUrl, path: texturePath },
-        { url: fileUrl, path: glbPath },
-    ];
-}
-async function searchAssetsApi(params) {
-    const token = await getAuthToken();
-    if (!token) {
-        return {
-            error: "Not logged in",
-            message: "Not signed in. Run: summer login\nOr open: https://www.summerengine.com/login\nAsset search requires a Summer Engine account (free to create).",
-        };
-    }
-    const searchParams = new URLSearchParams();
-    searchParams.set("query", params.query);
-    if (params.assetType && params.assetType !== "all") {
-        searchParams.set("assetType", params.assetType);
-    }
-    if (params.limit) {
-        searchParams.set("limit", String(params.limit));
-    }
-    const res = await fetch(`${GATEWAY_URL}/api/mcp/assets?${searchParams}`, {
-        headers: { Authorization: `Bearer ${token}` },
-        signal: AbortSignal.timeout(15000),
-    });
-    const data = (await res.json());
-    if (!res.ok) {
-        if (res.status === 402) {
-            return {
-                error: "upgrade_required",
-                message: (data.message || "Asset search requires a Pro subscription.") +
-                    "\nUpgrade at: https://www.summerengine.com/pricing",
-                plan: data.plan,
-            };
-        }
-        if (res.status === 401) {
-            return {
-                error: "unauthorized",
-                message: (data.message || "Auth token expired.") +
-                    " Run: summer login --force",
-            };
-        }
-        return {
-            error: data.error || "Search failed",
-            message: data.message || "Asset search failed",
-        };
-    }
-    return data;
-}
-export const assetsCommand = new Command("assets").description("Search and import assets from the Summer Engine library");
-assetsCommand
-    .command("search <query>")
-    .description('Search the asset library (e.g. summer assets search "low-poly tree")')
-    .option("--type <type>", "Filter: 2d_image, animation, 3d_model, audio, music, all", "all")
-    .option("--limit <n>", "Max results (1-20)", "10")
-    .action(async (query, opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const result = await searchAssetsApi({
-            query,
-            assetType: opts.type,
-            limit: Math.min(parseInt(opts.limit, 10), 20),
-        });
-        if (result.error) {
-            outputError(result.message || result.error, fmt);
-        }
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-assetsCommand
-    .command("import <query>")
-    .description("Search and import the best match into the project in one step")
-    .option("--parent <path>", "Parent node to add the asset under (e.g. ./World)")
-    .option("--type <type>", "Preferred type: 2d_image, animation, 3d_model, audio, music, all", "3d_model")
-    .action(async (query, opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const searchResult = await searchAssetsApi({
-            query,
-            assetType: opts.type,
-            limit: 5,
-        });
-        if (searchResult.error) {
-            outputError(searchResult.message || searchResult.error, fmt);
-        }
-        const assets = searchResult.assets || [];
-        if (assets.length === 0) {
-            outputError(`No assets found for "${query}". Try different keywords.`, fmt);
-        }
-        const best = assets[0];
-        const fileUrl = best.fileUrl;
-        if (!fileUrl) {
-            outputError("Asset has no download URL.", fmt);
-        }
-        const fileName = fileUrl.split("/").pop()?.split("?")[0] || "asset";
-        const packSlug = best.packSlug ?? getPackSlugFromUrl(fileUrl) ?? "misc";
-        let imports;
-        if (best.type === "3d_model" && fileUrl.includes("kenney/3d/")) {
-            imports = await buildKenneyImportEntries(fileUrl, packSlug, fileName);
-        }
-        else {
-            const path = best.type === "3d_model"
-                ? `res://assets/models/${fileName}`
-                : `res://assets/${fileName}`;
-            imports = [{ url: fileUrl, path }];
-        }
-        const importPath = imports[imports.length - 1].path;
-        const client = await getClient();
-        const importResult = imports.length === 1
-            ? await client.executeOps([
-                {
-                    op: "ImportFromUrl",
-                    url: imports[0].url,
-                    path: imports[0].path,
-                },
-            ])
-            : await client.executeOps([
-                { op: "ImportFromUrlBatch", imports },
-            ]);
-        const ok = importResult?.results?.[0]?.ok;
-        if (!ok) {
-            outputError(`Import failed for "${best.title}". Check engine logs.`, fmt);
-        }
-        if (opts.parent && best.type === "3d_model") {
-            await client.executeOps([
-                {
-                    op: "InstantiateScene",
-                    parent: opts.parent,
-                    scene: importPath,
-                    name: best.title.replace(/\s+/g, "_"),
-                },
-            ]);
-        }
-        outputResult({
-            success: true,
-            asset: best.title,
-            type: best.type,
-            importedTo: importPath,
-            addedToScene: !!opts.parent,
-            parent: opts.parent || null,
-        }, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});

package/dist/commands/debug.d.ts

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

package/dist/commands/debug.js

@@ -1,127 +0,0 @@
-import { Command } from "commander";
-import { withEngineClient } from "../lib/with-engine.js";
-import { outputResult, outputError, isJsonMode } from "../lib/format.js";
-export const debugCommand = new Command("debug").description("Debug and run commands (requires running engine)");
-debugCommand
-    .command("diagnostics")
-    .description("Quick overview of all errors and warnings from editor console and debugger")
-    .action(async (_opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const result = await withEngineClient((c) => c.getDiagnostics());
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-debugCommand
-    .command("play [scene]")
-    .description("Start running the game (optionally a specific scene)")
-    .action(async (scene, _opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const result = await withEngineClient((c) => c.play(scene));
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-debugCommand
-    .command("stop")
-    .description("Stop the running game")
-    .action(async (_opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const result = await withEngineClient((c) => c.stop());
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-debugCommand
-    .command("console")
-    .description("Read recent messages from the editor Output panel")
-    .option("--max-lines <n>", "Max lines to return", "100")
-    .option("--filter <string>", "Only return lines containing this string")
-    .option("--type <type>", "Filter by type: error, warning, std, editor")
-    .action(async (opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const op = {
-            op: "GetConsoleOutput",
-            max_lines: parseInt(opts.maxLines, 10),
-        };
-        if (opts.filter)
-            op.filter = opts.filter;
-        if (opts.type)
-            op.type = opts.type;
-        const result = await withEngineClient((c) => c.executeOps([op]));
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-debugCommand
-    .command("errors")
-    .description("Read runtime errors from the debugger")
-    .option("--max-errors <n>", "Max errors to return", "50")
-    .option("--stack", "Include stack traces")
-    .action(async (opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const op = {
-            op: "GetDebuggerErrors",
-            max_errors: parseInt(opts.maxErrors, 10),
-        };
-        if (opts.stack !== undefined)
-            op.include_stack = opts.stack;
-        const result = await withEngineClient((c) => c.executeOps([op]));
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-debugCommand
-    .command("script-errors <path>")
-    .description("Check a GDScript file for parse/compile errors (e.g. res://scripts/player.gd)")
-    .action(async (path, _opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const result = await withEngineClient((c) => c.getScriptErrors(path));
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-debugCommand
-    .command("clear")
-    .description("Clear the editor Output panel")
-    .action(async (_opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const result = await withEngineClient((c) => c.executeOps([{ op: "ClearConsoleOutput" }]));
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-debugCommand
-    .command("running")
-    .description("Check if the game is currently running")
-    .action(async (_opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const result = await withEngineClient((c) => c.executeOps([{ op: "IsGameRunning" }]));
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});

package/dist/commands/doctor.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/commands/doctor.test.js

@@ -1,29 +0,0 @@
-import { describe, expect, it } from "vitest";
-function summarize(checks) {
-    return {
-        ok: checks.filter((c) => c.status === "ok").length,
-        warnings: checks.filter((c) => c.status === "warning").length,
-        failures: checks.filter((c) => c.status === "fail").length,
-    };
-}
-describe("doctor summarization", () => {
-    it("counts mixed statuses", () => {
-        const summary = summarize([
-            { id: "a", label: "A", status: "ok", message: "" },
-            { id: "b", label: "B", status: "warning", message: "" },
-            { id: "c", label: "C", status: "fail", message: "" },
-            { id: "d", label: "D", status: "ok", message: "" },
-        ]);
-        expect(summary).toEqual({ ok: 2, warnings: 1, failures: 1 });
-    });
-    it("counts an all-ok run", () => {
-        const summary = summarize([
-            { id: "a", label: "A", status: "ok", message: "" },
-            { id: "b", label: "B", status: "ok", message: "" },
-        ]);
-        expect(summary).toEqual({ ok: 2, warnings: 0, failures: 0 });
-    });
-    it("counts an empty check list", () => {
-        expect(summarize([])).toEqual({ ok: 0, warnings: 0, failures: 0 });
-    });
-});

package/dist/commands/project.d.ts

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

package/dist/commands/project.js

@@ -1,170 +0,0 @@
-import { Command } from "commander";
-import { readFile } from "fs/promises";
-import { join } from "path";
-import { withEngineClient } from "../lib/with-engine.js";
-import { outputResult, outputError, parseValue, readJsonArg, isJsonMode, } from "../lib/format.js";
-async function readMainSceneFromProject(projectPath) {
-    if (!projectPath)
-        return null;
-    try {
-        const text = await readFile(join(projectPath, "project.godot"), "utf-8");
-        const match = text.match(/run\/main_scene="([^"]+)"/);
-        return match?.[1] ?? null;
-    }
-    catch {
-        return null;
-    }
-}
-export const projectCommand = new Command("project").description("Project context and settings (requires running engine)");
-projectCommand
-    .command("context")
-    .description("Get project context: health, current scene, main scene, project path")
-    .action(async (_opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const result = await withEngineClient(async (client) => {
-            const [health, projectState] = await Promise.all([
-                client.health(),
-                client.getProjectState(),
-            ]);
-            const healthObj = (health ?? {});
-            const mainScene = await readMainSceneFromProject(typeof healthObj.project_path === "string"
-                ? healthObj.project_path
-                : undefined);
-            return {
-                health,
-                project: projectState,
-                mainScene,
-                guidance: mainScene
-                    ? "Use `summer scene open` with mainScene if no scene is open."
-                    : "Main scene not found in project.godot. Open a known scene path explicitly.",
-            };
-        });
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-projectCommand
-    .command("open-main")
-    .description("Open the project's main scene from project.godot")
-    .action(async (_opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const result = await withEngineClient(async (client) => {
-            const health = (await client.health());
-            const projectPath = typeof health.project_path === "string"
-                ? health.project_path
-                : undefined;
-            const mainScene = await readMainSceneFromProject(projectPath);
-            if (!mainScene) {
-                throw new Error("Could not resolve main_scene from project.godot. Run `summer project context` and open a scene explicitly.");
-            }
-            return client.executeOps([{ op: "OpenScene", path: mainScene }]);
-        });
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-projectCommand
-    .command("setting <key> <value>")
-    .description('Set a project setting (e.g. summer project setting application/config/name "My Game")')
-    .action(async (key, value, _opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const result = await withEngineClient((c) => c.executeOps([
-            { op: "ProjectSetting", key, value: parseValue(value) },
-        ]));
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-projectCommand
-    .command("input-bind <name> <events>")
-    .description('Bind input events to an action (e.g. summer project input-bind jump \'[{"type":"key","key":"Space"}]\')')
-    .action(async (name, eventsJson, _opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const events = JSON.parse(eventsJson);
-        const result = await withEngineClient((c) => c.executeOps([
-            { op: "InputMapAddAction", name },
-            { op: "InputMapBind", name, events },
-        ]));
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-projectCommand
-    .command("import <url>")
-    .description("Download a file from a URL and import into the project")
-    .option("--path <path>", "Target path in project (auto-inferred from URL if omitted)")
-    .action(async (url, opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const op = { op: "ImportFromUrl", url };
-        if (opts.path)
-            op.path = opts.path;
-        const result = await withEngineClient((c) => c.executeOps([op]));
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-projectCommand
-    .command("import-batch <json>")
-    .description('Import multiple files. Pass JSON array of {url, path} or "-" for stdin')
-    .action(async (jsonArg, _opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    try {
-        const imports = (await readJsonArg(jsonArg));
-        const result = await withEngineClient((c) => c.executeOps([{ op: "ImportFromUrlBatch", imports }]));
-        outputResult(result, fmt);
-    }
-    catch (err) {
-        outputError(err instanceof Error ? err.message : String(err), fmt);
-    }
-});
-projectCommand
-    .command("playbook")
-    .description("Show the AI agent operating guide for Summer Engine")
-    .action(async (_opts, cmd) => {
-    const fmt = isJsonMode(cmd);
-    const playbook = {
-        startupChecklist: [
-            "Decide first: file edit or engine operation.",
-            "For normal code/content edits (.gd/.tscn/.tres/.ts), use host file-edit tools directly.",
-            "Call `summer project context` first.",
-            "If no scene is open, call `summer project open-main`.",
-            "Call `summer scene tree` before structural edits.",
-            "Call `summer scene save` after edits.",
-        ],
-        safeDefaults: [
-            "Never guess scene filenames (main.tscn/Main.tscn).",
-            "Do not route ordinary code edits through engine ops when direct file tools are available.",
-            "Never remove multiple top-level nodes unless user explicitly requests destructive edits.",
-            "Never write .tscn/.scn with file write tools; use scene commands.",
-        ],
-        preferredFlow: [
-            "summer project context",
-            "summer project open-main (if needed)",
-            "summer scene tree",
-            "edit via summer scene add / summer scene prop / summer scene rprop",
-            "summer scene save",
-            "summer debug diagnostics",
-        ],
-        recovery: [
-            "If you see 'no scene open': run summer project open-main.",
-            "If open fails: re-check mainScene from summer project context.",
-            "If save fails: verify scene is open and game is not running.",
-        ],
-    };
-    outputResult(playbook, fmt);
-});

package/dist/commands/scene.d.ts

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