summer-engine 1.0.1 → 1.2.0

package/dist/bin/summer.js

@@ -11,6 +11,7 @@ import { installCommand } from "../commands/install.js";
 import { createCommand } from "../commands/create.js";
 import { listCommand } from "../commands/list.js";
 import { skillsCommand } from "../commands/skills.js";
+import { orchestratorCommand } from "../commands/orchestrator.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../../package.json");
 const program = new Command();
@@ -28,6 +29,7 @@ program.addCommand(createCommand);
 program.addCommand(listCommand);
 program.addCommand(skillsCommand);
 program.addCommand(mcpCommand);
+program.addCommand(orchestratorCommand);
 program.parseAsync().catch((err) => {
     console.error(err instanceof Error ? err.message : String(err));
     process.exit(1);

package/dist/commands/orchestrator.d.ts

@@ -0,0 +1,8 @@
+/**
+ * CLI command: summer agent
+ * Launches the web app locally with direct engine execution enabled.
+ * The web app handles all AI logic (prompts, tools, RAG, billing).
+ * This command just starts it with LOCAL_ENGINE_PORT set.
+ */
+import { Command } from "commander";
+export declare const orchestratorCommand: Command;

package/dist/commands/orchestrator.js

@@ -0,0 +1,143 @@
+/**
+ * CLI command: summer agent
+ * Launches the web app locally with direct engine execution enabled.
+ * The web app handles all AI logic (prompts, tools, RAG, billing).
+ * This command just starts it with LOCAL_ENGINE_PORT set.
+ */
+import { Command } from "commander";
+import { spawn } from "node:child_process";
+import { readFile, access, writeFile } from "node:fs/promises";
+import { join, resolve, dirname } from "node:path";
+import { homedir } from "node:os";
+import { getApiToken, getApiPort, checkEngineHealth } from "../lib/engine.js";
+import { getSummerDir } from "../lib/auth.js";
+async function findWebAppPath() {
+    // 1. Check env var
+    if (process.env.SUMMER_WEB_APP_PATH) {
+        return process.env.SUMMER_WEB_APP_PATH;
+    }
+    // 2. Check ~/.summer/web-app-path
+    try {
+        const stored = (await readFile(join(getSummerDir(), "web-app-path"), "utf-8")).trim();
+        if (stored) {
+            await access(join(stored, "package.json"));
+            return stored;
+        }
+    }
+    catch {
+        // Not stored yet
+    }
+    // 3. Search common sibling locations
+    const cliDir = dirname(dirname(dirname(new URL(import.meta.url).pathname)));
+    const searchPaths = [
+        resolve(cliDir, "../../publicsummerengine"), // sibling in development/
+        resolve(cliDir, "../../../publicsummerengine"), // one level up
+        resolve(homedir(), "development/publicsummerengine"),
+    ];
+    for (const candidate of searchPaths) {
+        try {
+            await access(join(candidate, "package.json"));
+            const pkg = JSON.parse(await readFile(join(candidate, "package.json"), "utf-8"));
+            if (pkg.name && pkg.name.includes("summer")) {
+                // Store for future use
+                try {
+                    await writeFile(join(getSummerDir(), "web-app-path"), candidate, "utf-8");
+                }
+                catch {
+                    // Non-critical
+                }
+                return candidate;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    return null;
+}
+async function loadEnvFile() {
+    const envVars = {};
+    try {
+        const envPath = join(getSummerDir(), "env");
+        const content = await readFile(envPath, "utf-8");
+        for (const line of content.split("\n")) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith("#"))
+                continue;
+            const eqIdx = trimmed.indexOf("=");
+            if (eqIdx > 0) {
+                envVars[trimmed.slice(0, eqIdx)] = trimmed.slice(eqIdx + 1);
+            }
+        }
+    }
+    catch {
+        // No env file — user will need to have env vars set
+    }
+    return envVars;
+}
+export const orchestratorCommand = new Command("agent")
+    .description("Start the web app locally with direct engine execution. " +
+    "Tools call localhost:6550 instead of the Redis bridge.")
+    .option("-p, --port <number>", "Web app port", "3000")
+    .option("--web-path <path>", "Path to publicsummerengine (auto-detected if not set)")
+    .option("--dev", "Run in dev mode (pnpm dev) instead of production")
+    .action(async (opts) => {
+    const port = parseInt(opts.port, 10);
+    // 1. Verify engine is running
+    const enginePort = await getApiPort();
+    const engineToken = await getApiToken();
+    const health = await checkEngineHealth(enginePort);
+    if (!health) {
+        console.error("Summer Engine is not running. Open Summer Engine first.");
+        process.exit(1);
+    }
+    console.log(`Engine running on port ${enginePort} | project: ${health.project_name ?? "unknown"}`);
+    // 2. Find web app
+    const webAppPath = opts.webPath ?? (await findWebAppPath());
+    if (!webAppPath) {
+        console.error("Could not find publicsummerengine. Set --web-path or SUMMER_WEB_APP_PATH.");
+        process.exit(1);
+    }
+    console.log(`Web app: ${webAppPath}`);
+    // 3. Load env vars from ~/.summer/env
+    const storedEnv = await loadEnvFile();
+    // 4. Build env for the web app
+    const childEnv = {
+        ...process.env,
+        ...storedEnv,
+        LOCAL_ENGINE_PORT: String(enginePort),
+        LOCAL_ENGINE_TOKEN: engineToken ?? "",
+        PORT: String(port),
+    };
+    // 5. Start the web app
+    const cmd = opts.dev ? "pnpm" : "pnpm";
+    const args = opts.dev ? ["dev", "--port", String(port)] : ["start", "--port", String(port)];
+    console.log(`\nStarting web app (${opts.dev ? "dev" : "production"} mode) on port ${port}...`);
+    console.log(`  LOCAL_ENGINE_PORT=${enginePort}`);
+    console.log(`  Tools will execute via localhost:${enginePort} (direct, no bridge)\n`);
+    const child = spawn(cmd, args, {
+        cwd: webAppPath,
+        env: childEnv,
+        stdio: "inherit",
+    });
+    // Write agent port for engine to discover
+    try {
+        await writeFile(join(getSummerDir(), "agent-port"), String(port), "utf-8");
+    }
+    catch {
+        // Non-critical
+    }
+    child.on("error", (err) => {
+        console.error("Failed to start web app:", err.message);
+        process.exit(1);
+    });
+    child.on("exit", (code) => {
+        process.exit(code ?? 0);
+    });
+    // Graceful shutdown
+    const shutdown = () => {
+        child.kill("SIGTERM");
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+});

package/dist/commands/run.js

@@ -8,6 +8,7 @@ const MAC_PATHS = [
     `${process.env.HOME}/Applications/Summer.app/Contents/MacOS/Summer`,
 ];
 const WIN_PATHS = [
+    `${process.env.LOCALAPPDATA}\\SummerEngine\\current\\Summer.exe`,
     `${process.env.LOCALAPPDATA}\\Programs\\Summer Engine\\Summer.exe`,
     `${process.env.PROGRAMFILES}\\Summer Engine\\Summer.exe`,
 ];

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

@@ -14,4 +14,10 @@ export declare class EngineApiClient {
     getScriptErrors(path: string): Promise<unknown>;
     play(scene?: string): Promise<unknown>;
     stop(): Promise<unknown>;
+    readFile(path: string, maxBytes?: number): Promise<unknown>;
+    getFsTree(root?: string, limit?: number): Promise<unknown>;
+    getSelection(): Promise<unknown>;
+    viewportSnapshot(): Promise<Buffer>;
+    gameSnapshot(): Promise<Buffer>;
+    getPort(): number;
 }

package/dist/lib/api-client.js

@@ -66,4 +66,43 @@ export class EngineApiClient {
     async stop() {
         return this.request("POST", "/api/stop");
     }
+    async readFile(path, maxBytes) {
+        const params = new URLSearchParams({ path });
+        if (maxBytes)
+            params.set("maxBytes", String(maxBytes));
+        return this.request("GET", `/api/state/read-file?${params}`);
+    }
+    async getFsTree(root = "res://", limit = 2000) {
+        const params = new URLSearchParams({
+            root,
+            limit: String(limit),
+        });
+        return this.request("GET", `/api/state/fs-tree?${params}`);
+    }
+    async getSelection() {
+        return this.request("GET", "/api/state/selection");
+    }
+    async viewportSnapshot() {
+        const url = `http://127.0.0.1:${this.port}/api/snapshot/viewport`;
+        const res = await fetch(url, {
+            headers: { Authorization: `Bearer ${this.token}` },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!res.ok)
+            throw new Error(`Viewport snapshot failed: ${res.status}`);
+        return Buffer.from(await res.arrayBuffer());
+    }
+    async gameSnapshot() {
+        const url = `http://127.0.0.1:${this.port}/api/snapshot/game`;
+        const res = await fetch(url, {
+            headers: { Authorization: `Bearer ${this.token}` },
+            signal: AbortSignal.timeout(15000),
+        });
+        if (!res.ok)
+            throw new Error(`Game snapshot failed: ${res.status}`);
+        return Buffer.from(await res.arrayBuffer());
+    }
+    getPort() {
+        return this.port;
+    }
 }

package/dist/mcp/server.js

@@ -6,6 +6,7 @@ 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";
+import { registerGenerateTools } from "./tools/generate-tools.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../../package.json");
 let cachedClient = null;
@@ -34,6 +35,7 @@ export async function startMcpServer() {
     registerDebugTools(server);
     registerProjectTools(server);
     registerAssetTools(server);
+    registerGenerateTools(server);
     const transport = new StdioServerTransport();
     await server.connect(transport);
     process.stderr.write(`[summer-mcp] MCP server running v${version}.\n`);

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

@@ -56,6 +56,9 @@ async function searchAssetsApi(params) {
     if (params.limit) {
         searchParams.set("limit", String(params.limit));
     }
+    if (params.source) {
+        searchParams.set("source", params.source);
+    }
     const res = await fetch(`${GATEWAY_URL}/api/mcp/assets?${searchParams}`, {
         headers: { Authorization: `Bearer ${token}` },
         signal: AbortSignal.timeout(15000),
@@ -85,17 +88,23 @@ async function searchAssetsApi(params) {
     return data;
 }
 export function registerAssetTools(server) {
-    server.tool("summer_search_assets", `Search the Summer Engine asset library (25k+ game assets) by description.
+    server.tool("summer_search_assets", `Search for game assets in the Summer Engine ecosystem.
+
+Sources:
+  - "library" (default) — Public asset library (25k+ community assets). Requires Pro plan.
+  - "my_assets" — Your own generated/uploaded assets. Free for all users. Query is optional.
+  - "all" — Search both library and your assets.
 
 Uses hybrid search: keywords + semantic similarity. Finds assets by name AND by meaning.
 Returns asset names, types, preview URLs, and import-ready file URLs.
 
-Requires authentication. If the user gets an auth error, they need to run 'npx summer-engine login' in their terminal first.`, {
-        query: z.string().describe("Natural language search, e.g. 'low-poly tree', 'sci-fi weapon', 'wooden crate'"),
+Requires authentication: run 'npx summer-engine login' first.`, {
+        query: z.string().describe("Natural language search, e.g. 'low-poly tree', 'sci-fi weapon'. For my_assets, can be empty to list recent."),
         assetType: z.enum(["2d_image", "animation", "3d_model", "audio", "music", "all"]).default("all").describe("Filter by asset type"),
         limit: z.number().default(10).describe("Max results (1-20)"),
-    }, async ({ query, assetType, limit }) => {
-        const result = await searchAssetsApi({ query, assetType, limit: Math.min(limit, 20) });
+        source: z.enum(["library", "my_assets", "all"]).default("library").describe("Where to search: library (public 25k+), my_assets (your generated assets), all"),
+    }, async ({ query, assetType, limit, source }) => {
+        const result = await searchAssetsApi({ query, assetType, limit: Math.min(limit, 20), source });
         if (result.error) {
             return {
                 content: [

package/dist/mcp/tools/generate-tools.d.ts

@@ -0,0 +1,2 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+export declare function registerGenerateTools(server: McpServer): void;