@uemcp/server 0.3.0 → 0.4.0

package/README.md

@@ -137,6 +137,36 @@ This is intended to let an MCP client resolve the canonical Unreal project ident
 - Spawns `clang-tidy` (server-configured via `CLANG_TIDY_PATH`, else `PATH`) over the translation units and returns structured findings (file, line, column, check, severity, message)
 - Report only — does not apply fixes
 
+## MCP Resources
+
+Resources carry context a client can attach without spending a tool call and a model turn. Every one of them is served from in-memory state or the local filesystem: **a resource read never opens a bridge socket and never waits on the editor**, so an unreachable or absent editor produces a structured payload rather than a timeout.
+
+All resources use the `uemcp://` URI scheme, are `application/json`, and are capped at 64 KB (`MAX_RESOURCE_PAYLOAD_BYTES`). A read that hits the cap drops entries from the end of the list and sets `truncated: true` while `totalCount` stays authoritative — the same convention the paged tools use. The authority segment (`registry`, `engines`, `workspace`) is the type discriminator.
+
+| URI | Contents |
+| --- | --- |
+| `uemcp://registry` | Every registered Unreal Editor: `projectId`, `projectName`, `projectPath`, `port`, `pid`, `registeredAt`, `lastSeenAt`, plus `totalCount` and `truncated` |
+| `uemcp://registry/{projectId}` | One registration, addressed by canonical ProjectID. Enumerable — the template's `list` callback returns the current registry, and `projectId` offers completions from it |
+| `uemcp://engines` | Unreal installs found under `UE_INSTALLS_DIR`, ascending by version, each with `engineVersion`, `engineRoot`, and `unrealBuildToolResolved`. Source builds and GUID engine associations are excluded, matching `resolveEngine` |
+| `uemcp://workspace/project` | The Unreal project identity of the server's working directory, resolved from `Config/DefaultGame.ini` |
+
+`uemcp://registry/{projectId}` reports `found: false` with a `reason` for an unknown or malformed ProjectID, and `uemcp://engines` / `uemcp://workspace/project` report a `reason` when `UE_INSTALLS_DIR` is unset or the directory is not an Unreal project — none of them fail the read.
+
+Registering or deregistering an editor over the HTTP API emits `notifications/resources/list_changed`. There is no `resources/subscribe`: the MCP SDK's `McpServer` does not implement it, so the list-changed notification is the only change signal.
+
+## MCP Prompts
+
+Prompts ship the workflows this server knows about as discoverable entry points for any MCP client, not just ones that can read the repo's `.agents/skills/` runbooks. They are compiled into the bundle, reference only tools this server registers, and assume no shell, no checkout, and no particular client.
+
+| Prompt | Arguments | What it drives |
+| --- | --- | --- |
+| `diagnose_crash` | `projectId` | Registration check, `get_crash_callstack`, `get_editor_state`, then the output log around the crash |
+| `diagnose_bridge_disconnect` | `projectPath` (optional) | Which leg of the bridge is broken: registry state, `get_project_id` cross-check, `ping_project`, plugin-side log evidence |
+| `smoke_test_bridge` | `projectId` | Green-path proof: registration, `ping_project`, `get_editor_state`, and a full log subscribe-emit-drain cycle |
+| `add_gameplay_feature` | `projectId`, `className`, `parentClass`, `moduleName` (optional) | `create_cpp_class` → `wait_for_job` → implement → `trigger_live_compile` → `run_automation_tests` → `save_dirty_packages` |
+
+`diagnose_bridge_disconnect` and `smoke_test_bridge` are distilled from the same-named skills in `.agents/skills/`. Those files stay separate on purpose: they are maintainer runbooks that reference `just` recipes, `registry.json` paths, and pino module loggers, and the published package ships `dist` only, so they cannot be read at runtime. Each skill carries a pointer to its prompt counterpart so the two do not silently diverge.
+
 ## Configuration
 
 - Engine toolchain (`build_target`, `generate_project_files`, `clean_build`):

package/dist/index.mjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import os, { tmpdir } from "node:os";
 import path from "node:path";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { McpServer, ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { randomUUID } from "node:crypto";
 import { z } from "zod";
@@ -2429,6 +2429,13 @@ var RegistryWriteQueue = class {
 function createHttpApi(options) {
 	const app = Fastify({ logger: false });
 	const registryWriteQueue = options.registryWriteQueue ?? new RegistryWriteQueue();
+	const notifyRegistryChanged = () => {
+		try {
+			options.onRegistryChanged?.();
+		} catch (error) {
+			options.logger.warn({ error }, "Failed to notify listeners that the registry changed");
+		}
+	};
 	app.setErrorHandler((error, _request, reply) => {
 		if (error instanceof HttpError) {
 			reply.code(error.statusCode).send({
@@ -2513,6 +2520,7 @@ function createHttpApi(options) {
 			projectName: entry.projectName,
 			projectPath: entry.projectPath
 		}, "Upserted Unreal Editor project registration");
+		notifyRegistryChanged();
 		return {
 			projectId: entry.projectId,
 			stored: true
@@ -2543,6 +2551,7 @@ function createHttpApi(options) {
 			existed,
 			projectId
 		}, "Removed Unreal Editor project registration");
+		if (existed) notifyRegistryChanged();
 		return {
 			projectId,
 			removed: true
@@ -2972,144 +2981,6 @@ function isLogLevel(value) {
 	return value === "fatal" || value === "error" || value === "warn" || value === "info" || value === "debug" || value === "trace" || value === "silent";
 }
 //#endregion
-//#region src/buildDiagnostics.ts
-const CLANG_DIAGNOSTIC_PATTERN = /^(?<file>.+?):(?<line>\d+):(?:(?<column>\d+):)?\s+(?<severity>fatal error|error|warning):\s+(?<message>.*)$/u;
-const MSVC_DIAGNOSTIC_PATTERN = /^(?<file>.+?)\((?<line>\d+)(?:,\d+)?\):\s+(?<severity>fatal error|error|warning)\s+(?<code>[A-Z]+\d+):\s+(?<message>.*)$/u;
-const CLANG_TIDY_PATTERN = /^(?<file>.+?):(?<line>\d+):(?<column>\d+):\s+(?<severity>error|warning):\s+(?<message>.*?)(?:\s+\[(?<check>[^\]]+)\])?$/u;
-const COOK_LINE_PREFIX_PATTERN = /^(?:\[[^\]]*\]\s*)*(?:[A-Za-z]+Helper:\s*[^:]*:\s*)?/u;
-const COOK_DIAGNOSTIC_PATTERN = /^(?<category>[A-Za-z_][A-Za-z0-9_]*):\s+(?<severity>Error|Warning)(?::)?\s+(?<message>.+)$/u;
-const UAT_DIAGNOSTIC_PATTERN = /^(?<severity>ERROR|WARNING):\s+(?<message>.+)$/u;
-function diagnosticKey(diagnostic) {
-	return `${diagnostic.file ?? ""}|${diagnostic.line ?? ""}|${diagnostic.message}`;
-}
-function matchCookDiagnostic(rawLine) {
-	const line = rawLine.trim().replace(COOK_LINE_PREFIX_PATTERN, "").trim();
-	if (line.length === 0) return null;
-	const categoryMatch = COOK_DIAGNOSTIC_PATTERN.exec(line);
-	if (categoryMatch?.groups) {
-		const { category, message, severity } = categoryMatch.groups;
-		if (category === void 0 || message === void 0 || severity === void 0) return null;
-		return {
-			isError: severity === "Error",
-			message: `${category}: ${message.trim()}`
-		};
-	}
-	const uatMatch = UAT_DIAGNOSTIC_PATTERN.exec(line);
-	if (!uatMatch?.groups) return null;
-	const { message, severity } = uatMatch.groups;
-	if (message === void 0 || severity === void 0) return null;
-	return {
-		isError: severity === "ERROR",
-		message: message.trim()
-	};
-}
-var CookDiagnosticCollector = class {
-	maxEntriesPerSeverity;
-	errors = [];
-	warnings = [];
-	seenErrors = /* @__PURE__ */ new Set();
-	seenWarnings = /* @__PURE__ */ new Set();
-	pending = "";
-	truncatedFlag = false;
-	constructor(maxEntriesPerSeverity) {
-		this.maxEntriesPerSeverity = maxEntriesPerSeverity;
-	}
-	push(chunk) {
-		const lines = (this.pending + chunk).split(/\r?\n/u);
-		this.pending = lines.pop() ?? "";
-		for (const line of lines) this.pushLine(line);
-	}
-	flush() {
-		if (this.pending.length === 0) return;
-		const remaining = this.pending;
-		this.pending = "";
-		this.pushLine(remaining);
-	}
-	snapshot() {
-		return {
-			errorCount: this.errors.length,
-			errors: [...this.errors],
-			truncated: this.truncatedFlag,
-			warningCount: this.warnings.length,
-			warnings: [...this.warnings]
-		};
-	}
-	pushLine(rawLine) {
-		const matched = matchCookDiagnostic(rawLine);
-		if (!matched) return;
-		const diagnostic = { message: matched.message };
-		const target = matched.isError ? this.errors : this.warnings;
-		const seen = matched.isError ? this.seenErrors : this.seenWarnings;
-		const key = diagnosticKey(diagnostic);
-		if (seen.has(key)) return;
-		seen.add(key);
-		if (target.length >= this.maxEntriesPerSeverity) {
-			this.truncatedFlag = true;
-			return;
-		}
-		target.push(diagnostic);
-	}
-};
-function parseBuildDiagnostics(output) {
-	const errors = [];
-	const warnings = [];
-	const seenErrors = /* @__PURE__ */ new Set();
-	const seenWarnings = /* @__PURE__ */ new Set();
-	for (const rawLine of output.split(/\r?\n/u)) {
-		const line = rawLine.trim();
-		if (line.length === 0) continue;
-		const match = CLANG_DIAGNOSTIC_PATTERN.exec(line) ?? MSVC_DIAGNOSTIC_PATTERN.exec(line);
-		if (!match?.groups) continue;
-		const groups = match.groups;
-		const { file, line: lineText, message, severity } = groups;
-		if (file === void 0 || lineText === void 0 || message === void 0 || severity === void 0) continue;
-		const code = typeof groups.code === "string" ? `${groups.code}: ` : "";
-		const diagnostic = {
-			file,
-			line: Number.parseInt(lineText, 10),
-			message: `${code}${message}`.trim()
-		};
-		const isError = severity === "error" || severity === "fatal error";
-		const target = isError ? errors : warnings;
-		const seen = isError ? seenErrors : seenWarnings;
-		const key = diagnosticKey(diagnostic);
-		if (seen.has(key)) continue;
-		seen.add(key);
-		target.push(diagnostic);
-	}
-	return {
-		errorCount: errors.length,
-		errors,
-		warningCount: warnings.length,
-		warnings
-	};
-}
-function parseClangTidyFindings(output) {
-	const findings = [];
-	const seen = /* @__PURE__ */ new Set();
-	for (const rawLine of output.split(/\r?\n/u)) {
-		const match = CLANG_TIDY_PATTERN.exec(rawLine.trim());
-		if (!match?.groups) continue;
-		const groups = match.groups;
-		const { file, line, message } = groups;
-		if (file === void 0 || line === void 0 || message === void 0) continue;
-		const severity = groups.severity === "error" ? "error" : "warning";
-		const finding = {
-			check: groups.check ?? "unknown",
-			file,
-			line: Number.parseInt(line, 10),
-			message: message.trim(),
-			severity
-		};
-		if (typeof groups.column === "string") finding.column = Number.parseInt(groups.column, 10);
-		const key = `${finding.file}|${finding.line}|${finding.column ?? ""}|${finding.check}|${finding.message}`;
-		if (seen.has(key)) continue;
-		seen.add(key);
-		findings.push(finding);
-	}
-	return findings;
-}
-//#endregion
 //#region src/engineToolchain.ts
 const UNREAL_BUILD_CONFIGURATIONS = [
 	"Debug",
@@ -3140,6 +3011,7 @@ function cookCommandletTargetPlatform(platform) {
 const DEFAULT_PROCESS_TIMEOUT_MS = 18e5;
 const MAX_PROCESS_TIMEOUT_MS = 72e5;
 const DEFAULT_PACKAGE_TIMEOUT_MS = 54e5;
+const ENGINE_INSTALL_DIRECTORY_PATTERN = /^UE_(\d+(?:\.\d+)*)$/u;
 async function defaultFileExists(filePath) {
 	try {
 		await access(filePath);
@@ -3357,6 +3229,47 @@ async function resolveEngine(options) {
 		unrealBuildTool
 	};
 }
+async function listEngineInstalls(context) {
+	const ueInstallsDir = context.env.UE_INSTALLS_DIR?.trim();
+	if (!ueInstallsDir) throw new EngineToolchainError("UE_INSTALLS_DIR is not set; define it in .env (see .env.example).");
+	let entries;
+	try {
+		entries = await context.listDirectory(ueInstallsDir);
+	} catch (error) {
+		throw new EngineToolchainError(`Failed to read UE_INSTALLS_DIR ${ueInstallsDir}: ${error instanceof Error ? error.message : String(error)}`, { cause: error instanceof Error ? error : void 0 });
+	}
+	const installs = [];
+	for (const entry of entries) {
+		const engineVersion = ENGINE_INSTALL_DIRECTORY_PATTERN.exec(entry)?.[1];
+		if (engineVersion === void 0) continue;
+		const engineRoot = path.join(ueInstallsDir, entry);
+		installs.push({
+			engineRoot,
+			engineVersion,
+			unrealBuildToolResolved: await isUnrealBuildToolResolvable(engineRoot, context)
+		});
+	}
+	return installs.sort((left, right) => compareEngineVersions(left.engineVersion, right.engineVersion));
+}
+async function isUnrealBuildToolResolvable(engineRoot, context) {
+	try {
+		await resolveUnrealBuildTool(engineRoot, context);
+		return true;
+	} catch (error) {
+		if (error instanceof EngineToolchainError) return false;
+		throw error;
+	}
+}
+function compareEngineVersions(left, right) {
+	const leftSegments = left.split(".");
+	const rightSegments = right.split(".");
+	const segmentCount = Math.max(leftSegments.length, rightSegments.length);
+	for (let index = 0; index < segmentCount; index += 1) {
+		const difference = Number(leftSegments[index] ?? 0) - Number(rightSegments[index] ?? 0);
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
 async function resolveUnrealBuildTool(engineRoot, context) {
 	if (context.platform === "win32") {
 		const ubtExe = path.join(engineRoot, "Engine", "Binaries", "DotNET", "UnrealBuildTool", "UnrealBuildTool.exe");
@@ -3467,6 +3380,425 @@ function buildUnrealBuildToolInvocation(engine, extraArgs) {
 		command: engine.unrealBuildTool.command
 	};
 }
+const RESOURCE_MIME_TYPE = "application/json";
+const REGISTRY_RESOURCE_URI = "uemcp://registry";
+const REGISTRY_PROJECT_RESOURCE_URI_TEMPLATE = "uemcp://registry/{projectId}";
+const ENGINES_RESOURCE_URI = "uemcp://engines";
+const WORKSPACE_PROJECT_RESOURCE_URI = "uemcp://workspace/project";
+function readRegistryResource(dependencies) {
+	const entries = dependencies.registry.snapshot();
+	return clampResourceList(entries, (visibleEntries, truncated) => ({
+		entries: visibleEntries,
+		totalCount: entries.length,
+		truncated
+	}));
+}
+function readRegistryProjectResource(projectId, dependencies) {
+	const parsedProjectId = projectIdSchema.safeParse(projectId);
+	if (!parsedProjectId.success) return {
+		entry: null,
+		found: false,
+		projectId,
+		reason: "The requested projectId is not a canonical 32-character Unreal ProjectID.",
+		truncated: false
+	};
+	const entry = dependencies.registry.getProject(parsedProjectId.data);
+	if (!entry) return {
+		entry: null,
+		found: false,
+		projectId: parsedProjectId.data,
+		reason: "No Unreal Editor is registered with this server for that projectId.",
+		truncated: false
+	};
+	return clampResourcePayload({
+		entry,
+		found: true,
+		projectId: entry.projectId,
+		truncated: false
+	}, () => ({
+		entry: null,
+		found: true,
+		projectId: parsedProjectId.data,
+		reason: "The registry entry exceeded the resource payload budget.",
+		truncated: true
+	}));
+}
+async function readEnginesResource(dependencies) {
+	const context = dependencies.engineToolchainContext ?? createEngineToolchainContext();
+	const installsDirectory = context.env.UE_INSTALLS_DIR?.trim() ?? null;
+	let engineInstalls;
+	try {
+		engineInstalls = await listEngineInstalls(context);
+	} catch (error) {
+		if (!(error instanceof EngineToolchainError)) throw error;
+		dependencies.logger.warn({ error }, "Failed to enumerate installed Unreal engines for the engines resource");
+		return {
+			engineInstalls: [],
+			installsDirectory: installsDirectory && installsDirectory.length > 0 ? installsDirectory : null,
+			reason: error.message,
+			totalCount: 0,
+			truncated: false
+		};
+	}
+	return clampResourceList(engineInstalls, (visibleInstalls, truncated) => ({
+		engineInstalls: visibleInstalls,
+		installsDirectory: installsDirectory && installsDirectory.length > 0 ? installsDirectory : null,
+		totalCount: engineInstalls.length,
+		truncated
+	}));
+}
+async function readWorkspaceProjectResource(dependencies) {
+	const workingDirectory = dependencies.workingDirectory ?? process.cwd();
+	try {
+		const resolved = await dependencies.projectIdResolver.resolveProjectIdFromProjectPath(workingDirectory);
+		return clampResourcePayload({
+			configPath: resolved.configPath,
+			projectId: resolved.projectId,
+			projectPath: resolved.projectPath,
+			resolved: true,
+			truncated: false,
+			workingDirectory
+		}, () => ({
+			reason: "The resolved workspace project exceeded the resource payload budget.",
+			resolved: false,
+			truncated: true,
+			workingDirectory
+		}));
+	} catch (error) {
+		if (!(error instanceof ProjectIdResolutionError)) throw error;
+		return {
+			configPath: error.filePath,
+			reason: error.reason,
+			resolved: false,
+			truncated: false,
+			workingDirectory
+		};
+	}
+}
+function registerMcpResources(server, dependencies) {
+	server.registerResource("registry", REGISTRY_RESOURCE_URI, {
+		description: "Every Unreal Editor currently registered with this server, straight from the in-memory registry. Attach this instead of calling list_registered_projects when you only need to know which editors are live and which projectId to pass to the tools. Reads no files and never contacts an editor.",
+		mimeType: RESOURCE_MIME_TYPE,
+		title: "Registered Unreal Editors"
+	}, (uri) => buildResourceContents(uri, readRegistryResource(dependencies)));
+	server.registerResource("registry-project", new ResourceTemplate(REGISTRY_PROJECT_RESOURCE_URI_TEMPLATE, {
+		complete: { projectId: (value) => completeRegisteredProjectId(value, dependencies) },
+		list: () => listRegistryProjectResources(dependencies)
+	}), {
+		description: "The registration for a single Unreal Editor, addressed by canonical 32-character ProjectID. Reports found: false with a reason rather than failing when the projectId is unknown or malformed.",
+		mimeType: RESOURCE_MIME_TYPE,
+		title: "Registered Unreal Editor"
+	}, (uri, variables) => buildResourceContents(uri, readRegistryProjectResource(readTemplateVariable(variables.projectId), dependencies)));
+	server.registerResource("engines", ENGINES_RESOURCE_URI, {
+		description: "Unreal Engine installs discovered under UE_INSTALLS_DIR, each with its version, engine root, and whether UnrealBuildTool resolved inside it. Source builds and GUID engine associations are excluded because the build tools cannot resolve them either.",
+		mimeType: RESOURCE_MIME_TYPE,
+		title: "Installed Unreal Engines"
+	}, async (uri) => buildResourceContents(uri, await readEnginesResource(dependencies)));
+	server.registerResource("workspace-project", WORKSPACE_PROJECT_RESOURCE_URI, {
+		description: "The Unreal project identity of the server's working directory, resolved from Config/DefaultGame.ini. Reports resolved: false with a reason when the working directory is not an Unreal project.",
+		mimeType: RESOURCE_MIME_TYPE,
+		title: "Workspace Unreal Project"
+	}, async (uri) => buildResourceContents(uri, await readWorkspaceProjectResource(dependencies)));
+}
+function listRegistryProjectResources(dependencies) {
+	return { resources: dependencies.registry.snapshot().map((entry) => ({
+		description: `Registration for ${entry.projectName} at ${entry.projectPath}`,
+		mimeType: RESOURCE_MIME_TYPE,
+		name: entry.projectId,
+		title: entry.projectName,
+		uri: buildRegistryProjectUri(entry.projectId)
+	})) };
+}
+function completeRegisteredProjectId(value, dependencies) {
+	const prefix = value.trim().toLowerCase();
+	return dependencies.registry.snapshot().map((entry) => entry.projectId).filter((projectId) => projectId.startsWith(prefix));
+}
+function buildRegistryProjectUri(projectId) {
+	return `${REGISTRY_RESOURCE_URI}/${projectId}`;
+}
+function buildResourceContents(uri, payload) {
+	return { contents: [{
+		mimeType: RESOURCE_MIME_TYPE,
+		text: serializeResourcePayload(payload),
+		uri: uri.href
+	}] };
+}
+function readTemplateVariable(value) {
+	if (Array.isArray(value)) return value[0] ?? "";
+	return value ?? "";
+}
+function clampResourceList(items, build) {
+	const fullPayload = build(items, false);
+	if (measureResourcePayloadBytes(fullPayload) <= 65536) return fullPayload;
+	let smallestRejected = items.length;
+	let largestAccepted = 0;
+	while (largestAccepted + 1 < smallestRejected) {
+		const candidateCount = Math.floor((largestAccepted + smallestRejected) / 2);
+		if (measureResourcePayloadBytes(build(items.slice(0, candidateCount), true)) <= 65536) {
+			largestAccepted = candidateCount;
+			continue;
+		}
+		smallestRejected = candidateCount;
+	}
+	return build(items.slice(0, largestAccepted), true);
+}
+function clampResourcePayload(payload, buildMinimal) {
+	if (measureResourcePayloadBytes(payload) <= 65536) return payload;
+	return buildMinimal();
+}
+function measureResourcePayloadBytes(payload) {
+	return Buffer$1.byteLength(serializeResourcePayload(payload), "utf8");
+}
+function serializeResourcePayload(payload) {
+	return JSON.stringify(payload, null, 2);
+}
+//#endregion
+//#region src/mcpPrompts.ts
+const projectIdPromptArgument = projectIdSchema.describe("Canonical 32-character Unreal ProjectID of the target editor. Read uemcp://registry to find one.");
+const diagnoseCrashPromptArgs = { projectId: projectIdPromptArgument };
+const diagnoseBridgeDisconnectPromptArgs = { projectPath: z.string().trim().min(1).optional().describe("Filesystem path of the Unreal project directory or .uproject, when it is known.") };
+const smokeTestBridgePromptArgs = { projectId: projectIdPromptArgument };
+const addGameplayFeaturePromptArgs = {
+	className: bridgeCreateCppClassRequestSchema.shape.className.describe("Name of the C++ class to create, without the type prefix (for example PatrolComponent)."),
+	moduleName: bridgeCreateCppClassRequestSchema.shape.moduleName.describe("Target module for the new class. Omitted means the project’s primary game module."),
+	parentClass: bridgeCreateCppClassRequestSchema.shape.parentClass.describe("Parent class to derive from (for example Actor, ActorComponent, or a project class)."),
+	projectId: projectIdPromptArgument
+};
+function buildDiagnoseCrashPrompt(args) {
+	return buildPromptResult("Investigate the most recent Unreal Editor crash for a registered project.", [
+		`Investigate the most recent crash for Unreal project ${args.projectId}.`,
+		"",
+		"Work in this order and stop as soon as the cause is established:",
+		`1. Read ${buildRegistryProjectUri(args.projectId)}, then call ping_project. A registration that is present but unreachable is the signature of a crash: deregistration only runs on a clean shutdown, so a killed process leaves its entry behind. An absent entry proves nothing on its own — the editor may never have registered, or a prior health check may already have evicted it.`,
+		"2. Call get_crash_callstack for the project. Read the newest record first. Note the crash type, the assert or exception text, and the topmost project frames — engine frames below them are usually the victim, not the cause.",
+		"3. Call get_editor_state to see what the editor was doing (PIE state, loaded level, current selection). A crash during PIE and a crash while idle have different suspects.",
+		"4. Call stream_output_log with maxEvents around 50 and minVerbosity of warning. The first call establishes the subscription and returns no events; call it again with the returned cursor to drain. Look for the warnings immediately preceding the crash.",
+		"5. If the callstack names a Blueprint, call get_blueprint_compile_errors for it; if it names a C++ symbol, call get_compile_status to check whether the running binary matches the current source.",
+		"",
+		"Report the crash type, the failing frame, the evidence that supports it, and the smallest change that would address it. Say so plainly if the callstack is inconclusive rather than guessing."
+	].join("\n"));
+}
+function buildDiagnoseBridgeDisconnectPrompt(args) {
+	const projectPathStep = args.projectPath ? `2. Call get_project_id with projectPath ${args.projectPath} to get the canonical ProjectID, then compare it to the registry entries from step 1. A mismatch means the editor and this server are reading different Config/DefaultGame.ini files.` : "2. Ask for the project path if you need one, then call get_project_id with it and compare the result to the registry entries from step 1. A mismatch means the editor and this server are reading different Config/DefaultGame.ini files.";
+	return buildPromptResult("Diagnose why this server cannot reach a running Unreal Editor over the MCPBridge.", [
+		"The MCP server cannot reach a running Unreal Editor. Find which leg of the connection is broken before changing anything.",
+		"",
+		"The two processes meet in two places: the editor registers itself over this server’s HTTP API, and this server opens a TCP bridge socket to the port the editor recorded in that registration.",
+		"",
+		`1. Read ${REGISTRY_RESOURCE_URI}. No entry at all means registration never landed or was evicted. An entry with a stale lastSeenAt means registration landed but health checks are failing.`,
+		projectPathStep,
+		"3. Call ping_project with the registered projectId. reachable: false with registrationRemoved: true means the editor’s TCP listener is gone — the editor died, or the plugin lost its port. Note that this call evicts a stale registration, so read the registry resource before calling it, not after.",
+		"4. If the registration looks healthy but one specific tool fails, call stream_output_log and drain with the returned cursor. Plugin-side faults are logged under the LogMCPBridgeRuntime category: failures resolving the ProjectID, failures binding the bridge socket, and rejected registrations all name themselves there.",
+		"",
+		"Common causes, in rough order of likelihood: the editor was closed or crashed and the registration is stale; the editor is open on a different project than the one being asked about; the project directory was copied, so two directories share one ProjectID and fight over one registration; the plugin is pointed at a different server address.",
+		"",
+		"Report which leg is broken and the single smallest action that fixes it. Do not propose code changes until the diagnosis is complete — this failure is usually configuration, not a bug."
+	].join("\n"));
+}
+function buildSmokeTestBridgePrompt(args) {
+	return buildPromptResult("Prove the MCPBridge works end to end for a registered project.", [
+		`Verify the MCPBridge is healthy for Unreal project ${args.projectId}. This is green-path verification, not fault diagnosis.`,
+		"",
+		`1. Read ${buildRegistryProjectUri(args.projectId)}. Expect a registration whose lastSeenAt is recent and whose port is in the 7000-7100 range.`,
+		"2. Call ping_project. Expect reachable: true, registrationRemoved: false, and attemptsUsed: 1.",
+		"3. Call get_editor_state. Expect the loaded level and PIE state of the editor actually open in front of the user.",
+		"4. Exercise log streaming, which is the one path that covers subscribe, emit, drain, and unsubscribe together:",
+		"   a. Call stream_output_log with categoryAllow of [\"LogTemp\"], textContains of \"smoke-bridge-output\", and maxEvents of 10. The first call returns an empty events array and a cursor. That is correct — the subscription has nothing buffered yet.",
+		"   b. Call exec_console_command with the command: log LogTemp Warning smoke-bridge-output ping",
+		"   c. Call stream_output_log again with the same arguments plus the cursor from step 4a. Expect at least one event whose message contains smoke-bridge-output, and a nextCursor that has advanced.",
+		"",
+		"Report each step as pass or fail with the value that proves it. If any step fails, stop and say which one — the diagnose_bridge_disconnect prompt takes it from there. Treat an empty first drain as expected, never as a failure."
+	].join("\n"));
+}
+function buildAddGameplayFeaturePrompt(args) {
+	const moduleClause = args.moduleName ? ` in module ${args.moduleName}` : "";
+	return buildPromptResult("Add a C++ gameplay class to a live Unreal project and take it through compile and test.", [
+		`Add a C++ class ${args.className} deriving from ${args.parentClass}${moduleClause} to Unreal project ${args.projectId}, then get it compiling and tested.`,
+		"",
+		"Every step here is asynchronous. Each start returns a job id; do not assume success from the start call alone.",
+		"",
+		`1. Call create_cpp_class with className ${args.className}, parentClass ${args.parentClass}${args.moduleName ? `, moduleName ${args.moduleName}` : ""}. It returns a createClassJobId immediately.`,
+		"2. Wait for it with wait_for_job using kind create_class, or poll get_create_class_status. Do not edit the generated files until it reports completion — the editor is still writing them.",
+		"3. Read the generated header and source, then write the actual implementation. A generated class compiles but does nothing.",
+		"4. Call trigger_live_compile, then wait_for_job with kind compile. On failure, read the diagnostics from get_compile_status, fix the source, and compile again. Do not proceed past a failing compile.",
+		"5. Call list_automation_tests to find the tests covering this area, then run_automation_tests, then wait_for_job with kind test_run. Report which tests ran and which failed.",
+		"6. Call save_dirty_packages once the work is done so nothing is left unsaved in the editor.",
+		"",
+		"If the project has no automation tests covering the new class, say so rather than reporting the step as passed."
+	].join("\n"));
+}
+function registerMcpPrompts(server) {
+	server.registerPrompt("diagnose_crash", {
+		argsSchema: diagnoseCrashPromptArgs,
+		description: "Walk the most recent Unreal Editor crash for a project back to its cause using the crash callstack, editor state, and output log.",
+		title: "Diagnose Unreal Crash"
+	}, (args) => buildDiagnoseCrashPrompt(args));
+	server.registerPrompt("diagnose_bridge_disconnect", {
+		argsSchema: diagnoseBridgeDisconnectPromptArgs,
+		description: "Find which leg of the MCPBridge is broken when this server cannot reach a running Unreal Editor — missing registration, ProjectID mismatch, dead listener, or a plugin-side failure.",
+		title: "Diagnose Bridge Disconnect"
+	}, (args) => buildDiagnoseBridgeDisconnectPrompt(args));
+	server.registerPrompt("smoke_test_bridge", {
+		argsSchema: smokeTestBridgePromptArgs,
+		description: "Prove the MCPBridge round-trips end to end for a project: registration, ping, editor state, and a full log subscribe-emit-drain cycle.",
+		title: "Smoke-Test the Bridge"
+	}, (args) => buildSmokeTestBridgePrompt(args));
+	server.registerPrompt("add_gameplay_feature", {
+		argsSchema: addGameplayFeaturePromptArgs,
+		description: "Add a C++ gameplay class to a live Unreal project and drive it through class creation, implementation, live compile, and automation tests.",
+		title: "Add Gameplay Feature"
+	}, (args) => buildAddGameplayFeaturePrompt(args));
+}
+function buildPromptResult(description, text) {
+	return {
+		description,
+		messages: [{
+			content: {
+				text,
+				type: "text"
+			},
+			role: "user"
+		}]
+	};
+}
+//#endregion
+//#region src/buildDiagnostics.ts
+const CLANG_DIAGNOSTIC_PATTERN = /^(?<file>.+?):(?<line>\d+):(?:(?<column>\d+):)?\s+(?<severity>fatal error|error|warning):\s+(?<message>.*)$/u;
+const MSVC_DIAGNOSTIC_PATTERN = /^(?<file>.+?)\((?<line>\d+)(?:,\d+)?\):\s+(?<severity>fatal error|error|warning)\s+(?<code>[A-Z]+\d+):\s+(?<message>.*)$/u;
+const CLANG_TIDY_PATTERN = /^(?<file>.+?):(?<line>\d+):(?<column>\d+):\s+(?<severity>error|warning):\s+(?<message>.*?)(?:\s+\[(?<check>[^\]]+)\])?$/u;
+const COOK_LINE_PREFIX_PATTERN = /^(?:\[[^\]]*\]\s*)*(?:[A-Za-z]+Helper:\s*[^:]*:\s*)?/u;
+const COOK_DIAGNOSTIC_PATTERN = /^(?<category>[A-Za-z_][A-Za-z0-9_]*):\s+(?<severity>Error|Warning)(?::)?\s+(?<message>.+)$/u;
+const UAT_DIAGNOSTIC_PATTERN = /^(?<severity>ERROR|WARNING):\s+(?<message>.+)$/u;
+function diagnosticKey(diagnostic) {
+	return `${diagnostic.file ?? ""}|${diagnostic.line ?? ""}|${diagnostic.message}`;
+}
+function matchCookDiagnostic(rawLine) {
+	const line = rawLine.trim().replace(COOK_LINE_PREFIX_PATTERN, "").trim();
+	if (line.length === 0) return null;
+	const categoryMatch = COOK_DIAGNOSTIC_PATTERN.exec(line);
+	if (categoryMatch?.groups) {
+		const { category, message, severity } = categoryMatch.groups;
+		if (category === void 0 || message === void 0 || severity === void 0) return null;
+		return {
+			isError: severity === "Error",
+			message: `${category}: ${message.trim()}`
+		};
+	}
+	const uatMatch = UAT_DIAGNOSTIC_PATTERN.exec(line);
+	if (!uatMatch?.groups) return null;
+	const { message, severity } = uatMatch.groups;
+	if (message === void 0 || severity === void 0) return null;
+	return {
+		isError: severity === "ERROR",
+		message: message.trim()
+	};
+}
+var CookDiagnosticCollector = class {
+	maxEntriesPerSeverity;
+	errors = [];
+	warnings = [];
+	seenErrors = /* @__PURE__ */ new Set();
+	seenWarnings = /* @__PURE__ */ new Set();
+	pending = "";
+	truncatedFlag = false;
+	constructor(maxEntriesPerSeverity) {
+		this.maxEntriesPerSeverity = maxEntriesPerSeverity;
+	}
+	push(chunk) {
+		const lines = (this.pending + chunk).split(/\r?\n/u);
+		this.pending = lines.pop() ?? "";
+		for (const line of lines) this.pushLine(line);
+	}
+	flush() {
+		if (this.pending.length === 0) return;
+		const remaining = this.pending;
+		this.pending = "";
+		this.pushLine(remaining);
+	}
+	snapshot() {
+		return {
+			errorCount: this.errors.length,
+			errors: [...this.errors],
+			truncated: this.truncatedFlag,
+			warningCount: this.warnings.length,
+			warnings: [...this.warnings]
+		};
+	}
+	pushLine(rawLine) {
+		const matched = matchCookDiagnostic(rawLine);
+		if (!matched) return;
+		const diagnostic = { message: matched.message };
+		const target = matched.isError ? this.errors : this.warnings;
+		const seen = matched.isError ? this.seenErrors : this.seenWarnings;
+		const key = diagnosticKey(diagnostic);
+		if (seen.has(key)) return;
+		seen.add(key);
+		if (target.length >= this.maxEntriesPerSeverity) {
+			this.truncatedFlag = true;
+			return;
+		}
+		target.push(diagnostic);
+	}
+};
+function parseBuildDiagnostics(output) {
+	const errors = [];
+	const warnings = [];
+	const seenErrors = /* @__PURE__ */ new Set();
+	const seenWarnings = /* @__PURE__ */ new Set();
+	for (const rawLine of output.split(/\r?\n/u)) {
+		const line = rawLine.trim();
+		if (line.length === 0) continue;
+		const match = CLANG_DIAGNOSTIC_PATTERN.exec(line) ?? MSVC_DIAGNOSTIC_PATTERN.exec(line);
+		if (!match?.groups) continue;
+		const groups = match.groups;
+		const { file, line: lineText, message, severity } = groups;
+		if (file === void 0 || lineText === void 0 || message === void 0 || severity === void 0) continue;
+		const code = typeof groups.code === "string" ? `${groups.code}: ` : "";
+		const diagnostic = {
+			file,
+			line: Number.parseInt(lineText, 10),
+			message: `${code}${message}`.trim()
+		};
+		const isError = severity === "error" || severity === "fatal error";
+		const target = isError ? errors : warnings;
+		const seen = isError ? seenErrors : seenWarnings;
+		const key = diagnosticKey(diagnostic);
+		if (seen.has(key)) continue;
+		seen.add(key);
+		target.push(diagnostic);
+	}
+	return {
+		errorCount: errors.length,
+		errors,
+		warningCount: warnings.length,
+		warnings
+	};
+}
+function parseClangTidyFindings(output) {
+	const findings = [];
+	const seen = /* @__PURE__ */ new Set();
+	for (const rawLine of output.split(/\r?\n/u)) {
+		const match = CLANG_TIDY_PATTERN.exec(rawLine.trim());
+		if (!match?.groups) continue;
+		const groups = match.groups;
+		const { file, line, message } = groups;
+		if (file === void 0 || line === void 0 || message === void 0) continue;
+		const severity = groups.severity === "error" ? "error" : "warning";
+		const finding = {
+			check: groups.check ?? "unknown",
+			file,
+			line: Number.parseInt(line, 10),
+			message: message.trim(),
+			severity
+		};
+		if (typeof groups.column === "string") finding.column = Number.parseInt(groups.column, 10);
+		const key = `${finding.file}|${finding.line}|${finding.column ?? ""}|${finding.check}|${finding.message}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		findings.push(finding);
+	}
+	return findings;
+}
 //#endregion
 //#region src/moduleScaffold.ts
 const MODULE_DESCRIPTOR_TYPES = [
@@ -6882,7 +7214,7 @@ function isMissingFileError(error) {
 //#endregion
 //#region src/server.ts
 const SERVER_NAME = "ue-mcp-server";
-const SERVER_VERSION = "0.3.0";
+const SERVER_VERSION = "0.4.0";
 const logger = createModuleLogger("bootstrap");
 const enginePingLogger = createModuleLogger("engine-ping");
 const httpApiLogger = createModuleLogger("http-api");
@@ -6901,8 +7233,12 @@ async function startServer(options) {
 		readTimeoutMs: options.config.startupPingTimeoutMs
 	});
 	await pruneRegistryEntries(registry, store, options.config);
+	let notifyRegistryChanged = () => {};
 	const httpApi = createHttpApi({
 		logger: httpApiLogger,
+		onRegistryChanged: () => {
+			notifyRegistryChanged();
+		},
 		projectIdResolver,
 		registry,
 		registryWriteQueue,
@@ -6915,7 +7251,7 @@ async function startServer(options) {
 	const listeningHttpPort = getListeningHttpPort(httpApi, options.config.httpPort);
 	let mcpServer;
 	try {
-		mcpServer = createMcpServer({
+		const createdMcpServer = createMcpServer({
 			logger: mcpToolLogger,
 			logSessionManager,
 			pingTimeoutMs: options.config.startupPingTimeoutMs,
@@ -6924,6 +7260,10 @@ async function startServer(options) {
 			registryWriteQueue,
 			store
 		});
+		mcpServer = createdMcpServer;
+		notifyRegistryChanged = () => {
+			createdMcpServer.sendResourceListChanged();
+		};
 		if (options.connectMcpTransport !== false) await mcpServer.connect(new StdioServerTransport());
 	} catch (error) {
 		try {
@@ -6977,8 +7317,14 @@ function createMcpServer(dependencies) {
 	const server = new McpServer({
 		name: SERVER_NAME,
 		version: SERVER_VERSION
-	}, { capabilities: { tools: {} } });
+	}, { capabilities: {
+		prompts: {},
+		resources: {},
+		tools: {}
+	} });
 	registerMcpTools(server, dependencies);
+	registerMcpResources(server, dependencies);
+	registerMcpPrompts(server);
 	return server;
 }
 async function pruneRegistryEntries(registry, store, config) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@uemcp/server",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "MCP server for making Unreal Engine and C++ development easier",
   "type": "module",
   "main": "dist/index.mjs",