breakpoint-mcp 1.0.0

package/dist/tools/netcode.js

@@ -0,0 +1,411 @@
+import { z } from "zod";
+import { gate } from "../confirm.js";
+import { toFsPath, readFileText } from "../paths.js";
+/**
+ * Group M — Netcode & backend scaffolding (native multiplayer family, `mp_*`).
+ *
+ * Principle: host nothing, scaffold everything. Running a relay / leaderboard-DB
+ * / save-store is a hosted service, outside the scope of editor control — but
+ * generating the integration (nodes, scripts, config) is in scope. So this
+ * family adds only *authoring*:
+ *
+ *   Node authoring (undoable, over the editor bridge):
+ *     - mp_add_spawner       — a MultiplayerSpawner (spawn_path + spawnable scenes)
+ *     - mp_add_synchronizer  — a MultiplayerSynchronizer (+ a SceneReplicationConfig)
+ *     - mp_set_authority     — set_multiplayer_authority(peer_id, recursive)
+ *
+ *   Codegen (writes a `res://…gd`, elicitation-gated — the resource_create model):
+ *     - mp_setup_enet_peer   — an ENetMultiplayerPeer host/join helper script
+ *     - mp_setup_webrtc_peer — a WebRTCMultiplayerPeer mesh helper (feature-detected:
+ *                              degrades to "unsupported" when the WebRTC module is
+ *                              absent, never a dead call)
+ *     - mp_wire_rpc          — insert an `@rpc(...)` annotation on a function in an
+ *                              existing script (appends a stub if the func is absent)
+ *     - mp_scaffold_lobby    — a lobby controller script (host/join + peer tracking)
+ *
+ * The generated GDScript is built HOST-side (so the templates are unit-tested),
+ * then written by the editor's FileAccess through the `mp.write_script` bridge
+ * method (which also triggers a filesystem rescan). We host nothing: no relay, no
+ * leaderboard DB, no save storage — bring your own backend, we wire it for you.
+ */
+// ---- result envelopes (mirror tools/editor.ts + tools/assetgen.ts) ----
+function ok(obj) {
+    return {
+        content: [{ type: "text", text: JSON.stringify(obj, null, 2) }],
+        structuredContent: obj,
+    };
+}
+function fail(err) {
+    const be = err;
+    const code = be?.code ?? "error";
+    const message = be?.message ?? String(err);
+    return {
+        isError: true,
+        content: [{ type: "text", text: `Netcode scaffold error [${code}]: ${message}` }],
+    };
+}
+// ------------------------------------------------------------- codegen ----
+// Pure, exported for unit tests. GDScript is tab-indented (matches operations.gd).
+const GEN_HEADER = "## Generated by Breakpoint MCP";
+/** Optional `class_name X` line + `extends Base`, then the header comment. */
+function scriptPreamble(extendsType, className, note) {
+    const cn = className ? `class_name ${className}\n` : "";
+    return `${cn}extends ${extendsType}\n${GEN_HEADER} — ${note}\n`;
+}
+export function buildEnetScript(opts) {
+    return (scriptPreamble("Node", opts.className, "mp_setup_enet_peer") +
+        "## Attach to an autoload (or any Node), then call host_game() or join_game().\n\n" +
+        `const DEFAULT_PORT := ${opts.port}\n` +
+        `const MAX_CLIENTS := ${opts.maxClients}\n\n` +
+        "func host_game(port: int = DEFAULT_PORT) -> Error:\n" +
+        "\tvar peer := ENetMultiplayerPeer.new()\n" +
+        "\tvar err := peer.create_server(port, MAX_CLIENTS)\n" +
+        "\tif err != OK:\n" +
+        "\t\tpush_error(\"create_server failed: %d\" % err)\n" +
+        "\t\treturn err\n" +
+        "\tmultiplayer.multiplayer_peer = peer\n" +
+        "\treturn OK\n\n" +
+        "func join_game(address: String = \"127.0.0.1\", port: int = DEFAULT_PORT) -> Error:\n" +
+        "\tvar peer := ENetMultiplayerPeer.new()\n" +
+        "\tvar err := peer.create_client(address, port)\n" +
+        "\tif err != OK:\n" +
+        "\t\tpush_error(\"create_client failed: %d\" % err)\n" +
+        "\t\treturn err\n" +
+        "\tmultiplayer.multiplayer_peer = peer\n" +
+        "\treturn OK\n\n" +
+        "func close() -> void:\n" +
+        "\tmultiplayer.multiplayer_peer = null\n");
+}
+export function buildWebrtcScript(opts) {
+    return (scriptPreamble("Node", opts.className, "mp_setup_webrtc_peer") +
+        "## Requires the WebRTC module/extension. Signaling (SDP/ICE exchange) is\n" +
+        "## application-specific — wire create_offer/set_remote_description in your layer.\n\n" +
+        "func create_mesh(peer_id: int) -> WebRTCMultiplayerPeer:\n" +
+        "\tvar peer := WebRTCMultiplayerPeer.new()\n" +
+        "\tpeer.create_mesh(peer_id)\n" +
+        "\tmultiplayer.multiplayer_peer = peer\n" +
+        "\treturn peer\n\n" +
+        "func add_peer(peer: WebRTCMultiplayerPeer, connection: WebRTCPeerConnection, peer_id: int) -> void:\n" +
+        "\tpeer.add_peer(connection, peer_id)\n");
+}
+export function buildLobbyScript(opts) {
+    return (scriptPreamble("Node", opts.className, "mp_scaffold_lobby") +
+        "## A multiplayer lobby controller — tracks connected peers and exposes host/join.\n" +
+        "## Attach to your lobby scene root. Uses Godot's built-in ENet high-level multiplayer.\n\n" +
+        "signal player_joined(peer_id: int)\n" +
+        "signal player_left(peer_id: int)\n" +
+        "signal server_started\n" +
+        "signal join_succeeded\n" +
+        "signal join_failed\n\n" +
+        `const DEFAULT_PORT := ${opts.port}\n` +
+        `const MAX_PLAYERS := ${opts.maxPlayers}\n\n` +
+        "var players: Dictionary = {}\n\n" +
+        "func _ready() -> void:\n" +
+        "\tmultiplayer.peer_connected.connect(_on_peer_connected)\n" +
+        "\tmultiplayer.peer_disconnected.connect(_on_peer_disconnected)\n" +
+        "\tmultiplayer.connected_to_server.connect(func() -> void: join_succeeded.emit())\n" +
+        "\tmultiplayer.connection_failed.connect(func() -> void: join_failed.emit())\n\n" +
+        "func host_game(port: int = DEFAULT_PORT) -> Error:\n" +
+        "\tvar peer := ENetMultiplayerPeer.new()\n" +
+        "\tvar err := peer.create_server(port, MAX_PLAYERS)\n" +
+        "\tif err != OK:\n" +
+        "\t\treturn err\n" +
+        "\tmultiplayer.multiplayer_peer = peer\n" +
+        "\tplayers[multiplayer.get_unique_id()] = true\n" +
+        "\tserver_started.emit()\n" +
+        "\treturn OK\n\n" +
+        "func join_game(address: String = \"127.0.0.1\", port: int = DEFAULT_PORT) -> Error:\n" +
+        "\tvar peer := ENetMultiplayerPeer.new()\n" +
+        "\tvar err := peer.create_client(address, port)\n" +
+        "\tif err != OK:\n" +
+        "\t\treturn err\n" +
+        "\tmultiplayer.multiplayer_peer = peer\n" +
+        "\treturn OK\n\n" +
+        "func get_player_ids() -> Array:\n" +
+        "\treturn players.keys()\n\n" +
+        "func _on_peer_connected(id: int) -> void:\n" +
+        "\tplayers[id] = true\n" +
+        "\tplayer_joined.emit(id)\n\n" +
+        "func _on_peer_disconnected(id: int) -> void:\n" +
+        "\tplayers.erase(id)\n" +
+        "\tplayer_left.emit(id)\n");
+}
+const RPC_MODES = ["authority", "any_peer"];
+const RPC_TRANSFER = ["unreliable", "unreliable_ordered", "reliable"];
+/** Build an `@rpc("mode", "call_local|call_remote", "transfer", channel)` annotation. */
+export function rpcAnnotation(opts) {
+    const sync = opts.call_local ? "call_local" : "call_remote";
+    return `@rpc("${opts.mode}", "${sync}", "${opts.transfer_mode}", ${opts.channel})`;
+}
+function escapeRe(s) {
+    return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+/**
+ * Insert (or replace) an `@rpc(...)` annotation above `func <fn>(`. If the
+ * function is not found, append a stub carrying the annotation. Returns the new
+ * source and whether a stub was created. Pure — unit-tested.
+ */
+export function insertRpc(source, fn, annotation) {
+    const lines = source.split("\n");
+    const funcRe = new RegExp(`^(\\s*)func\\s+${escapeRe(fn)}\\s*\\(`);
+    for (let i = 0; i < lines.length; i++) {
+        const m = lines[i].match(funcRe);
+        if (!m)
+            continue;
+        const indent = m[1] ?? "";
+        // If the nearest preceding non-blank line is already an @rpc, replace it.
+        let prev = i - 1;
+        while (prev >= 0 && lines[prev].trim() === "")
+            prev--;
+        if (prev >= 0 && lines[prev].trim().startsWith("@rpc")) {
+            lines[prev] = indent + annotation;
+        }
+        else {
+            lines.splice(i, 0, indent + annotation);
+        }
+        return { content: lines.join("\n"), stub_created: false };
+    }
+    let content = source.length === 0 || source.endsWith("\n") ? source : source + "\n";
+    content += `\n${annotation}\nfunc ${fn}() -> void:\n\tpass\n`;
+    return { content, stub_created: true };
+}
+// ------------------------------------------------------------- registration ----
+export function registerNetcodeTools(server, bridge, config) {
+    const call = async (method, params = {}) => {
+        try {
+            return await bridge.request(method, params);
+        }
+        catch (err) {
+            throw err;
+        }
+    };
+    // Shared writer: pushes host-built GDScript through the editor's FileAccess.
+    // `require_class` (webrtc) makes the editor feature-detect before writing; an
+    // absent class comes back status:"unsupported" with nothing written.
+    async function writeScript(toPath, content, overwrite, requireClass) {
+        return (await call("mp.write_script", {
+            to_path: toPath,
+            content,
+            overwrite,
+            ...(requireClass ? { require_class: requireClass } : {}),
+        }));
+    }
+    // -------------------------------------------------------- mp_add_spawner ----
+    server.registerTool("mp_add_spawner", {
+        title: "Add MultiplayerSpawner",
+        description: "Add a MultiplayerSpawner node under a parent (undoable). Godot 4 high-level multiplayer replicates " +
+            "server-spawned nodes to clients: set spawn_path to the node whose children are auto-replicated, and " +
+            "register the scenes it may spawn. Pure node authoring — no service is started.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            name: z.string().optional().describe("Node name (default MultiplayerSpawner)"),
+            spawn_path: z.string().optional().describe("NodePath (relative to the spawner) whose children are auto-replicated"),
+            spawnable_scenes: z.array(z.string()).optional().describe("res:// scenes the spawner may instantiate (add_spawnable_scene)"),
+        },
+    }, async ({ parent_path, name, spawn_path, spawnable_scenes }) => {
+        try {
+            return ok(await call("mp.add_spawner", {
+                parent_path,
+                ...(name !== undefined ? { name } : {}),
+                ...(spawn_path !== undefined ? { spawn_path } : {}),
+                ...(spawnable_scenes !== undefined ? { spawnable_scenes } : {}),
+            }));
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    // --------------------------------------------------- mp_add_synchronizer ----
+    server.registerTool("mp_add_synchronizer", {
+        title: "Add MultiplayerSynchronizer",
+        description: "Add a MultiplayerSynchronizer node under a parent (undoable) and, if properties are given, build a " +
+            "SceneReplicationConfig that replicates them. root_path is the node the property NodePaths are relative " +
+            "to (default \"..\", the synchronizer's parent). Property paths look like \".:position\" or \"Sprite2D:rotation\". " +
+            "Pure node authoring — no service is started.",
+        inputSchema: {
+            parent_path: z.string().describe("Parent node path relative to the scene root; \".\" for the root"),
+            name: z.string().optional().describe("Node name (default MultiplayerSynchronizer)"),
+            root_path: z.string().optional().describe("NodePath the replicated property paths are relative to (default \"..\")"),
+            properties: z.array(z.string()).optional().describe("Property NodePaths to replicate, e.g. [\".:position\", \".:rotation\"]"),
+            replication_mode: z.enum(["always", "on_change", "never"]).optional().describe("Replication mode for the properties (default always)"),
+        },
+    }, async ({ parent_path, name, root_path, properties, replication_mode }) => {
+        try {
+            return ok(await call("mp.add_synchronizer", {
+                parent_path,
+                ...(name !== undefined ? { name } : {}),
+                ...(root_path !== undefined ? { root_path } : {}),
+                ...(properties !== undefined ? { properties } : {}),
+                ...(replication_mode !== undefined ? { replication_mode } : {}),
+            }));
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    // -------------------------------------------------------- mp_set_authority ----
+    server.registerTool("mp_set_authority", {
+        title: "Set multiplayer authority",
+        description: "Set a node's multiplayer authority (set_multiplayer_authority) to a peer id (undoable). The authority peer " +
+            "is the one allowed to push \"authority\"-mode RPCs and MultiplayerSynchronizer state for that node. peer_id 1 " +
+            "is the server. Pure node authoring.",
+        inputSchema: {
+            path: z.string().describe("Node path relative to the scene root"),
+            peer_id: z.number().int().describe("Peer id to grant authority (1 = server)"),
+            recursive: z.boolean().optional().describe("Also apply to descendants (default true)"),
+        },
+    }, async ({ path, peer_id, recursive }) => {
+        try {
+            return ok(await call("mp.set_authority", {
+                path,
+                peer_id,
+                ...(recursive !== undefined ? { recursive } : {}),
+            }));
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    // -------------------------------------------------------- mp_setup_enet_peer ----
+    server.registerTool("mp_setup_enet_peer", {
+        title: "Scaffold an ENet peer script",
+        description: "Generate a GDScript helper that sets up an ENetMultiplayerPeer (host_game / join_game / close) and assigns " +
+            "multiplayer.multiplayer_peer. Godot's default, always-available transport. DESTRUCTIVE (writes a .gd file) — " +
+            "gated by confirmation. No service is started; you call host_game()/join_game() at runtime.",
+        inputSchema: {
+            to_path: z.string().describe("Destination res:// .gd path, e.g. res://net/enet_peer.gd"),
+            port: z.number().int().positive().optional().describe("Default port baked into the script (default 24565)"),
+            max_clients: z.number().int().positive().optional().describe("Server max clients (default 32)"),
+            class_name: z.string().optional().describe("Optional class_name for the generated script"),
+            overwrite: z.boolean().optional().describe("Overwrite if the file already exists (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ to_path, port, max_clients, class_name, overwrite, confirm }) => {
+        if (!to_path.startsWith("res://") || !to_path.endsWith(".gd"))
+            return fail({ code: "bad_params", message: "'to_path' must be a res:// .gd path" });
+        const blocked = await gate(server, confirm, `Write ENet peer script to ${to_path}`);
+        if (blocked)
+            return blocked;
+        const content = buildEnetScript({ className: class_name, port: port ?? 24565, maxClients: max_clients ?? 32 });
+        try {
+            const r = await writeScript(to_path, content, overwrite ?? false);
+            return ok({ status: String(r.status ?? "written"), kind: "enet", path: r.path ?? to_path, bytes: r.bytes ?? content.length, created: r.created ?? true, message: `Wrote an ENetMultiplayerPeer helper to ${to_path}.` });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    // ------------------------------------------------------ mp_setup_webrtc_peer ----
+    server.registerTool("mp_setup_webrtc_peer", {
+        title: "Scaffold a WebRTC peer script",
+        description: "Generate a GDScript helper that sets up a WebRTCMultiplayerPeer mesh and assigns multiplayer.multiplayer_peer. " +
+            "FEATURE-DETECTED: if the WebRTC module/extension is absent from this Godot build, the tool degrades to a clear " +
+            "\"unsupported\" result and writes nothing (never a dead call). DESTRUCTIVE (writes a .gd file) — gated by confirmation.",
+        inputSchema: {
+            to_path: z.string().describe("Destination res:// .gd path, e.g. res://net/webrtc_peer.gd"),
+            class_name: z.string().optional().describe("Optional class_name for the generated script"),
+            overwrite: z.boolean().optional().describe("Overwrite if the file already exists (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ to_path, class_name, overwrite, confirm }) => {
+        if (!to_path.startsWith("res://") || !to_path.endsWith(".gd"))
+            return fail({ code: "bad_params", message: "'to_path' must be a res:// .gd path" });
+        const blocked = await gate(server, confirm, `Write WebRTC peer script to ${to_path}`);
+        if (blocked)
+            return blocked;
+        const content = buildWebrtcScript({ className: class_name });
+        try {
+            const r = await writeScript(to_path, content, overwrite ?? false, "WebRTCMultiplayerPeer");
+            if (r.status === "unsupported") {
+                return ok({
+                    status: "unsupported",
+                    kind: "webrtc",
+                    path: null,
+                    message: "WebRTCMultiplayerPeer is not available in this Godot build — enable the WebRTC module/extension, or use mp_setup_enet_peer.",
+                });
+            }
+            return ok({ status: String(r.status ?? "written"), kind: "webrtc", path: r.path ?? to_path, bytes: r.bytes ?? content.length, created: r.created ?? true, message: `Wrote a WebRTCMultiplayerPeer helper to ${to_path}.` });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    // ------------------------------------------------------------- mp_wire_rpc ----
+    server.registerTool("mp_wire_rpc", {
+        title: "Wire an @rpc annotation",
+        description: "Insert (or replace) an `@rpc(...)` annotation above a function in an existing GDScript, so it can be called " +
+            "across the network. If the function does not exist, a stub is appended carrying the annotation. Operates on the " +
+            "on-disk file (save the script in the editor first if it has unsaved changes). DESTRUCTIVE (rewrites the .gd file) — gated.",
+        inputSchema: {
+            path: z.string().describe("res:// .gd script to modify"),
+            function: z.string().describe("Function name to annotate (a stub is created if absent)"),
+            mode: z.enum(RPC_MODES).optional().describe("Who may call it: 'authority' (default) or 'any_peer'"),
+            transfer_mode: z.enum(RPC_TRANSFER).optional().describe("Transfer mode: 'unreliable' (default), 'unreliable_ordered', or 'reliable'"),
+            call_local: z.boolean().optional().describe("Also invoke locally on the caller (default false → call_remote)"),
+            channel: z.number().int().nonnegative().optional().describe("Transfer channel (default 0)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ path, function: fn, mode, transfer_mode, call_local, channel, confirm }) => {
+        if (!path.startsWith("res://") || !path.endsWith(".gd"))
+            return fail({ code: "bad_params", message: "'path' must be a res:// .gd path" });
+        const source = readFileText(toFsPath(path, config.projectPath));
+        if (source === "")
+            return fail({ code: "not_found", message: `Cannot read ${path} (does it exist?)` });
+        const annotation = rpcAnnotation({
+            mode: mode ?? "authority",
+            call_local: call_local ?? false,
+            transfer_mode: transfer_mode ?? "unreliable",
+            channel: channel ?? 0,
+        });
+        const { content, stub_created } = insertRpc(source, fn, annotation);
+        const blocked = await gate(server, confirm, `Wire ${annotation} onto ${fn}() in ${path}`);
+        if (blocked)
+            return blocked;
+        try {
+            const r = await writeScript(path, content, true);
+            return ok({
+                status: String(r.status ?? "written"),
+                kind: "rpc",
+                path: r.path ?? path,
+                function: fn,
+                annotation,
+                stub_created,
+                bytes: r.bytes ?? content.length,
+                message: `${stub_created ? "Appended a stub and wired" : "Wired"} ${annotation} onto ${fn}() in ${path}.`,
+            });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+    // -------------------------------------------------------- mp_scaffold_lobby ----
+    server.registerTool("mp_scaffold_lobby", {
+        title: "Scaffold a multiplayer lobby",
+        description: "Generate a lobby controller GDScript: host/join over ENet plus peer_connected/peer_disconnected tracking with " +
+            "player_joined / player_left / server_started / join_succeeded / join_failed signals. Attach it to your lobby " +
+            "scene root. DESTRUCTIVE (writes a .gd file) — gated by confirmation. No service is started.",
+        inputSchema: {
+            to_path: z.string().describe("Destination res:// .gd path, e.g. res://net/lobby.gd"),
+            port: z.number().int().positive().optional().describe("Default port baked into the script (default 24565)"),
+            max_players: z.number().int().positive().optional().describe("Server max players (default 8)"),
+            class_name: z.string().optional().describe("Optional class_name for the generated script"),
+            overwrite: z.boolean().optional().describe("Overwrite if the file already exists (default false)"),
+            confirm: z.boolean().optional().describe("Auto-approve this destructive action (skip the confirmation prompt)"),
+        },
+    }, async ({ to_path, port, max_players, class_name, overwrite, confirm }) => {
+        if (!to_path.startsWith("res://") || !to_path.endsWith(".gd"))
+            return fail({ code: "bad_params", message: "'to_path' must be a res:// .gd path" });
+        const blocked = await gate(server, confirm, `Write multiplayer lobby script to ${to_path}`);
+        if (blocked)
+            return blocked;
+        const content = buildLobbyScript({ className: class_name, port: port ?? 24565, maxPlayers: max_players ?? 8 });
+        try {
+            const r = await writeScript(to_path, content, overwrite ?? false);
+            return ok({ status: String(r.status ?? "written"), kind: "lobby", path: r.path ?? to_path, bytes: r.bytes ?? content.length, created: r.created ?? true, message: `Wrote a multiplayer lobby controller to ${to_path}.` });
+        }
+        catch (err) {
+            return fail(err);
+        }
+    });
+}
+//# sourceMappingURL=netcode.js.map

package/dist/tools/processes.js

@@ -0,0 +1,103 @@
+import { spawn } from "node:child_process";
+import { z } from "zod";
+import { log } from "../logger.js";
+import { ok } from "./lsp-common.js";
+const LINE_CAP = 5000;
+/**
+ * Runs Godot as a MANAGED child (piped stdio) so the host captures ALL stdout/
+ * stderr — including every `print()` and engine error — which the pure-GDScript
+ * runtime bridge cannot hook. Complements runtime_get_log with transparent,
+ * zero-instrumentation output capture.
+ */
+export class ProcessRegistry {
+    procs = new Map();
+    counter = 0;
+    run(cfg, extraArgs) {
+        const id = `godot-${++this.counter}`;
+        const child = spawn(cfg.godotBin, ["--path", cfg.projectPath, ...extraArgs], {
+            cwd: cfg.projectPath,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        const m = { id, child, lines: [], seq: 0, exited: false, exitCode: null };
+        const ingest = (stream) => (buf) => {
+            const text = typeof buf === "string" ? buf : buf.toString("utf8");
+            for (const line of text.split(/\r?\n/)) {
+                if (line.length === 0)
+                    continue;
+                m.seq += 1;
+                m.lines.push({ seq: m.seq, stream, text: line });
+                if (m.lines.length > LINE_CAP)
+                    m.lines.shift();
+            }
+        };
+        child.stdout?.on("data", ingest("stdout"));
+        child.stderr?.on("data", ingest("stderr"));
+        child.on("exit", (code) => {
+            m.exited = true;
+            m.exitCode = code;
+            log(`managed process ${id} exited (${code})`);
+        });
+        this.procs.set(id, m);
+        return m;
+    }
+    get(id) {
+        return this.procs.get(id);
+    }
+    killAll() {
+        for (const m of this.procs.values()) {
+            try {
+                m.child.kill();
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+}
+export function registerProcessTools(server, cfg) {
+    const registry = new ProcessRegistry();
+    server.registerTool("godot_run_managed", {
+        title: "Run project (managed, captured output)",
+        description: "Run the project as a managed child process with captured stdout/stderr, so godot_output can read ALL print()/error output. " +
+            "Returns a process id. Use this instead of godot_run_project when you want the game's console log.",
+        inputSchema: { scene: z.string().optional().describe("Optional res:// scene to run") },
+    }, async ({ scene }) => {
+        const m = registry.run(cfg, scene ? [scene] : []);
+        return ok({ id: m.id, pid: m.child.pid ?? null, running: true, scene: scene ?? null });
+    });
+    server.registerTool("godot_output", {
+        title: "Read managed process output",
+        description: "Read captured console output for a managed process (from godot_run_managed). Use since_seq for incremental reads.",
+        inputSchema: {
+            id: z.string().describe("Process id from godot_run_managed"),
+            since_seq: z.number().int().optional().describe("Only lines with seq greater than this (default 0)"),
+            stream: z.enum(["stdout", "stderr", "both"]).optional().describe("Filter by stream (default both)"),
+        },
+    }, async ({ id, since_seq, stream }) => {
+        const m = registry.get(id);
+        if (!m)
+            return { isError: true, content: [{ type: "text", text: `No managed process with id "${id}"` }] };
+        const since = since_seq ?? 0;
+        const want = stream ?? "both";
+        const lines = m.lines.filter((l) => l.seq > since && (want === "both" || l.stream === want));
+        return ok({ id, exited: m.exited, exit_code: m.exitCode, latest_seq: m.seq, lines });
+    });
+    server.registerTool("godot_stop", {
+        title: "Stop managed process",
+        description: "Terminate a managed process started by godot_run_managed.",
+        inputSchema: { id: z.string().describe("Process id from godot_run_managed") },
+    }, async ({ id }) => {
+        const m = registry.get(id);
+        if (!m)
+            return { isError: true, content: [{ type: "text", text: `No managed process with id "${id}"` }] };
+        try {
+            m.child.kill();
+        }
+        catch {
+            /* ignore */
+        }
+        return ok({ id, stopped: true });
+    });
+    return registry;
+}
+//# sourceMappingURL=processes.js.map

package/dist/tools/resources.js

@@ -0,0 +1,27 @@
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+/**
+ * MCP resources — read-mostly context the assistant can pull on demand (and clients can
+ * subscribe to). Each wraps a bridge call and degrades to an informative JSON
+ * note when the source (editor/game) isn't currently reachable, rather than
+ * failing the read.
+ */
+async function jsonResource(uriHref, fetcher) {
+    try {
+        const data = await fetcher();
+        return { contents: [{ uri: uriHref, mimeType: "application/json", text: JSON.stringify(data, null, 2) }] };
+    }
+    catch (err) {
+        const message = err?.message ?? String(err);
+        return {
+            contents: [{ uri: uriHref, mimeType: "application/json", text: JSON.stringify({ available: false, note: message }, null, 2) }],
+        };
+    }
+}
+export function registerResources(server, editor, runtime) {
+    server.registerResource("scene-tree", "godot://scene-tree", { title: "Edited scene tree", description: "Live node tree of the scene open in the editor.", mimeType: "application/json" }, async (uri) => jsonResource(uri.href, () => editor.request("scene.get_tree", {})));
+    server.registerResource("editor-state", "godot://editor-state", { title: "Editor state", description: "Currently edited scene, selection, and Godot version.", mimeType: "application/json" }, async (uri) => jsonResource(uri.href, () => editor.request("editor.get_state", {})));
+    server.registerResource("runtime-tree", "godot://runtime/tree", { title: "Runtime scene tree", description: "Live SceneTree of the running game.", mimeType: "application/json" }, async (uri) => jsonResource(uri.href, () => runtime.request("runtime.get_tree", {})));
+    server.registerResource("runtime-log", "godot://runtime/log", { title: "Runtime log", description: "Log ring buffer from the running game.", mimeType: "application/json" }, async (uri) => jsonResource(uri.href, () => runtime.request("runtime.get_log", { since_seq: 0, levels: [] })));
+    server.registerResource("class-doc", new ResourceTemplate("godot://class/{name}", { list: undefined }), { title: "ClassDB documentation", description: "Methods, properties, and signals of an engine class.", mimeType: "application/json" }, async (uri, vars) => jsonResource(uri.href, () => editor.request("classdb.get_class", { class_name: String(vars?.name ?? ""), include_inherited: false })));
+}
+//# sourceMappingURL=resources.js.map