godot-daedalus_backend 1.0.0

package/src/mcp/godot-paths.ts

@@ -0,0 +1,151 @@
+import * as path from "node:path";
+
+export const WRITABLE_EXTENSIONS: ReadonlySet<string> = new Set([
+	".gd",
+	".tres",
+	".tscn",
+	".json",
+	".md",
+	".txt"
+]);
+
+export type ResolvedGodotPath = {
+	originalPath: string;
+	absolutePath: string;
+	rootPath: string;
+	kind: "user" | "res" | "absolute" | "relative_user";
+};
+
+export type GodotPathContext = {
+	projectRoot: string;
+	appDataPath: string;
+	userProfilePath?: string | undefined;
+	projectName: string;
+};
+
+export function isPathInsideRoot(absolutePath: string, rootPath: string): boolean {
+	const relativePath: string = path.relative(path.resolve(rootPath), path.resolve(absolutePath));
+	return relativePath.length === 0 || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}
+
+export function normalizeDisplayPath(value: string): string {
+	return value.replaceAll("\\", "/");
+}
+
+export function sanitizeGodotUserDirName(value: string): string {
+	return value.replace(/[<>:"/\\|?*\x00-\x1F]/g, "_").trim() || "GodotProject";
+}
+
+export function getGodotUserDataDir(context: GodotPathContext): string {
+	return path.join(context.appDataPath, "Godot", "app_userdata", sanitizeGodotUserDirName(context.projectName));
+}
+
+export function resolveProjectPath(projectRoot: string, relativePath: string): string {
+	const cleanedPath: string = relativePath.trim();
+	const resolvedPath: string = path.resolve(projectRoot, cleanedPath.length > 0 ? cleanedPath : ".");
+
+	if (!isPathInsideRoot(resolvedPath, projectRoot)) {
+		throw new Error(`Path traversal denied: ${relativePath}`);
+	}
+
+	return resolvedPath;
+}
+
+export function resolveGodotPath(resourcePath: string, context: GodotPathContext): ResolvedGodotPath {
+	const trimmedPath: string = resourcePath.trim();
+	const userDataDir: string = getGodotUserDataDir(context);
+
+	if (trimmedPath.startsWith("user://")) {
+		const relativeUserPath: string = trimmedPath.slice("user://".length);
+		const absolutePath: string = path.resolve(userDataDir, relativeUserPath);
+		if (!isPathInsideRoot(absolutePath, userDataDir)) {
+			throw new Error(`user:// path traversal denied: ${resourcePath}`);
+		}
+		return { originalPath: resourcePath, absolutePath, rootPath: userDataDir, kind: "user" };
+	}
+
+	if (trimmedPath.startsWith("res://")) {
+		const relativeResPath: string = trimmedPath.slice("res://".length);
+		const absolutePath: string = path.resolve(context.projectRoot, relativeResPath);
+		if (!isPathInsideRoot(absolutePath, context.projectRoot)) {
+			throw new Error(`res:// path traversal denied: ${resourcePath}`);
+		}
+		return { originalPath: resourcePath, absolutePath, rootPath: context.projectRoot, kind: "res" };
+	}
+
+	if (path.isAbsolute(trimmedPath)) {
+		const absolutePath: string = path.resolve(trimmedPath);
+		if (isPathInsideRoot(absolutePath, context.projectRoot)) {
+			return { originalPath: resourcePath, absolutePath, rootPath: context.projectRoot, kind: "absolute" };
+		}
+		if (isPathInsideRoot(absolutePath, userDataDir)) {
+			return { originalPath: resourcePath, absolutePath, rootPath: userDataDir, kind: "absolute" };
+		}
+		throw new Error(`Absolute path is outside allowed Godot project/user data roots: ${resourcePath}`);
+	}
+
+	const absolutePath: string = path.resolve(userDataDir, trimmedPath);
+	if (!isPathInsideRoot(absolutePath, userDataDir)) {
+		throw new Error(`Relative user data path traversal denied: ${resourcePath}`);
+	}
+	return { originalPath: resourcePath, absolutePath, rootPath: userDataDir, kind: "relative_user" };
+}
+
+export function redactOnePath(value: string, context: GodotPathContext, raw: boolean): string {
+	if (raw) {
+		return normalizeDisplayPath(value);
+	}
+
+	const normalizedValue: string = normalizeDisplayPath(path.resolve(value));
+	const normalizedProjectRoot: string = normalizeDisplayPath(path.resolve(context.projectRoot));
+	if (normalizedValue === normalizedProjectRoot || normalizedValue.startsWith(`${normalizedProjectRoot}/`)) {
+		return normalizedValue;
+	}
+
+	if (context.userProfilePath !== undefined) {
+		const normalizedUserProfile: string = normalizeDisplayPath(path.resolve(context.userProfilePath));
+		if (normalizedValue === normalizedUserProfile || normalizedValue.startsWith(`${normalizedUserProfile}/`)) {
+			return normalizedValue.replace(normalizedUserProfile, "[user]");
+		}
+	}
+
+	return `[redacted]/${path.basename(normalizedValue)}`;
+}
+
+export function redactSensitivePaths(text: string, context: GodotPathContext, raw: boolean): string {
+	if (raw) {
+		return normalizeDisplayPath(text);
+	}
+
+	let redactedText: string = normalizeDisplayPath(text);
+	if (context.userProfilePath !== undefined) {
+		redactedText = redactedText.replaceAll(normalizeDisplayPath(context.userProfilePath), "[user]");
+	}
+	return redactedText.replace(/[A-Za-z]:\/[^"\s,)]+/g, (matchedPath: string): string => redactOnePath(matchedPath, context, false));
+}
+
+export function assertWritableProjectPath(projectRoot: string, relativePath: string): string {
+	const cleanedPath: string = relativePath.trim().replaceAll("\\", "/");
+	const resolvedPath: string = resolveProjectPath(projectRoot, cleanedPath);
+	const normalizedPath: string = path.relative(projectRoot, resolvedPath).replaceAll(path.sep, "/");
+	const segments: string[] = normalizedPath.split("/");
+
+	for (const segment of segments) {
+		if (segment.startsWith(".") && segment !== ".") {
+			throw new Error(`Path contains hidden directory: ${segment}`);
+		}
+	}
+
+	for (const prefix of [".godot", "addons"]) {
+		if (normalizedPath === prefix || normalizedPath.startsWith(`${prefix}/`)) {
+			throw new Error(`Writing to ${prefix}/ is not allowed`);
+		}
+	}
+
+	const extension: string = path.extname(resolvedPath);
+	if (!WRITABLE_EXTENSIONS.has(extension)) {
+		throw new Error(`Unsupported writable extension: ${extension || "(none)"}`);
+	}
+
+	return resolvedPath;
+}

package/src/mcp/godot-project-settings.ts

@@ -0,0 +1,233 @@
+export const MAX_PROJECT_SETTING_VALUE_CHARS: number = 16 * 1024;
+export const MAX_PROJECT_SETTING_VALUE_LINES: number = 240;
+
+export type ProjectSettingEntry = {
+	section: string;
+	name: string;
+	fullKey: string;
+	valueExpression: string;
+	lineStart: number;
+	lineEnd: number;
+};
+
+export type ProjectSettingsDocument = {
+	content: string;
+	lines: string[];
+	entries: ProjectSettingEntry[];
+	sectionLineIndexes: Map<string, number>;
+};
+
+export function normalizeConfigContent(content: string): string {
+	return content.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+}
+
+export function makeProjectSettingFullKey(section: string, name: string): string {
+	return `${section}/${name}`;
+}
+
+export function splitProjectSettingKey(fullKey: string): { section: string; name: string } {
+	const normalizedKey: string = fullKey.trim();
+	const slashIndex: number = normalizedKey.lastIndexOf("/");
+	if (slashIndex <= 0 || slashIndex === normalizedKey.length - 1) {
+		throw new Error(`Invalid project setting key: ${fullKey}`);
+	}
+
+	return {
+		section: normalizedKey.slice(0, slashIndex),
+		name: normalizedKey.slice(slashIndex + 1)
+	};
+}
+
+export function getExpressionBalance(text: string): number {
+	let balance: number = 0;
+	let inString: boolean = false;
+	let escaped: boolean = false;
+
+	for (const char of text) {
+		if (escaped) {
+			escaped = false;
+			continue;
+		}
+		if (char === "\\") {
+			escaped = true;
+			continue;
+		}
+		if (char === "\"") {
+			inString = !inString;
+			continue;
+		}
+		if (inString) {
+			continue;
+		}
+		if (char === "(" || char === "[" || char === "{") {
+			balance += 1;
+		} else if (char === ")" || char === "]" || char === "}") {
+			balance -= 1;
+		}
+	}
+
+	return balance;
+}
+
+export function normalizeProjectSettingValueExpression(valueExpression: string): string {
+	const normalizedValue: string = normalizeConfigContent(valueExpression).trim();
+	if (normalizedValue.length === 0) {
+		throw new Error("valueExpression must not be empty");
+	}
+	if (normalizedValue.length > MAX_PROJECT_SETTING_VALUE_CHARS) {
+		throw new Error(`valueExpression too large: ${normalizedValue.length} chars`);
+	}
+
+	const valueLines: string[] = normalizedValue.split("\n");
+	if (valueLines.length > MAX_PROJECT_SETTING_VALUE_LINES) {
+		throw new Error(`valueExpression has too many lines: ${valueLines.length}`);
+	}
+	for (const line of valueLines) {
+		if (/^\s*\[.+\]\s*$/.test(line)) {
+			throw new Error("valueExpression must not contain project.godot section headers");
+		}
+	}
+	if (getExpressionBalance(normalizedValue) !== 0) {
+		throw new Error("valueExpression has unbalanced braces, brackets, or parentheses");
+	}
+
+	return normalizedValue;
+}
+
+export function parseProjectSettings(content: string): ProjectSettingsDocument {
+	const normalizedContent: string = normalizeConfigContent(content);
+	const lines: string[] = normalizedContent.split("\n");
+	const entries: ProjectSettingEntry[] = [];
+	const sectionLineIndexes: Map<string, number> = new Map();
+	let currentSection: string = "";
+
+	for (let index = 0; index < lines.length; index += 1) {
+		const line: string = lines[index] ?? "";
+		const sectionMatch: RegExpMatchArray | null = line.match(/^\s*\[([^\]]+)\]\s*$/);
+		if (sectionMatch !== null) {
+			currentSection = sectionMatch[1] ?? "";
+			sectionLineIndexes.set(currentSection, index);
+			continue;
+		}
+
+		if (currentSection.length === 0 || line.trim().length === 0 || line.trimStart().startsWith(";")) {
+			continue;
+		}
+
+		const equalsIndex: number = line.indexOf("=");
+		if (equalsIndex <= 0) {
+			continue;
+		}
+
+		const name: string = line.slice(0, equalsIndex).trim();
+		let valueExpression: string = line.slice(equalsIndex + 1).trim();
+		const lineStart: number = index;
+		let lineEnd: number = index;
+
+		while (getExpressionBalance(valueExpression) > 0 && lineEnd + 1 < lines.length) {
+			lineEnd += 1;
+			valueExpression += `\n${lines[lineEnd] ?? ""}`;
+		}
+
+		entries.push({
+			section: currentSection,
+			name,
+			fullKey: makeProjectSettingFullKey(currentSection, name),
+			valueExpression,
+			lineStart,
+			lineEnd
+		});
+		index = lineEnd;
+	}
+
+	return { content: normalizedContent, lines, entries, sectionLineIndexes };
+}
+
+export function findProjectSettingEntry(document: ProjectSettingsDocument, fullKey: string): ProjectSettingEntry | undefined {
+	return document.entries.find((entry: ProjectSettingEntry): boolean => entry.fullKey === fullKey);
+}
+
+function findProjectSettingInsertIndex(document: ProjectSettingsDocument, section: string): number {
+	const sectionLineIndex: number | undefined = document.sectionLineIndexes.get(section);
+	if (sectionLineIndex === undefined) {
+		return document.lines.length;
+	}
+
+	let insertIndex: number = sectionLineIndex + 1;
+	for (const entry of document.entries) {
+		if (entry.section === section) {
+			insertIndex = Math.max(insertIndex, entry.lineEnd + 1);
+		}
+	}
+
+	return insertIndex;
+}
+
+function createProjectSettingAssignmentLines(name: string, valueExpression: string): string[] {
+	const valueLines: string[] = valueExpression.split("\n");
+	return valueLines.map((line: string, index: number): string => index === 0 ? `${name}=${line}` : line);
+}
+
+function finalizeProjectConfigContent(lines: string[]): string {
+	return `${lines.join("\n").replace(/\n+$/g, "")}\n`;
+}
+
+export function applyProjectSettingSetToContent(content: string, fullKey: string, valueExpression: string): string {
+	const { section, name } = splitProjectSettingKey(fullKey);
+	const normalizedValue: string = normalizeProjectSettingValueExpression(valueExpression);
+	const document: ProjectSettingsDocument = parseProjectSettings(content);
+	const entry: ProjectSettingEntry | undefined = findProjectSettingEntry(document, fullKey);
+	const lines: string[] = [...document.lines];
+
+	if (entry !== undefined) {
+		const existingAssignmentLines: string[] = createProjectSettingAssignmentLines(entry.name, normalizedValue);
+		lines.splice(entry.lineStart, entry.lineEnd - entry.lineStart + 1, ...existingAssignmentLines);
+		return finalizeProjectConfigContent(lines);
+	}
+
+	const assignmentLines: string[] = createProjectSettingAssignmentLines(name, normalizedValue);
+	if (!document.sectionLineIndexes.has(section)) {
+		if (lines.length > 0 && lines[lines.length - 1] !== "") {
+			lines.push("");
+		}
+		lines.push(`[${section}]`);
+		lines.push(...assignmentLines);
+		return finalizeProjectConfigContent(lines);
+	}
+
+	lines.splice(findProjectSettingInsertIndex(document, section), 0, ...assignmentLines);
+	return finalizeProjectConfigContent(lines);
+}
+
+export function applyProjectSettingUnsetToContent(content: string, fullKey: string): string {
+	const document: ProjectSettingsDocument = parseProjectSettings(content);
+	const entry: ProjectSettingEntry | undefined = findProjectSettingEntry(document, fullKey);
+	if (entry === undefined) {
+		return finalizeProjectConfigContent(document.lines);
+	}
+
+	const lines: string[] = [...document.lines];
+	lines.splice(entry.lineStart, entry.lineEnd - entry.lineStart + 1);
+	return finalizeProjectConfigContent(lines);
+}
+
+export function proposeProjectSettingSet(content: string, fullKey: string, valueExpression: string): Record<string, unknown> {
+	const nextContent: string = applyProjectSettingSetToContent(content, fullKey, valueExpression);
+	const document: ProjectSettingsDocument = parseProjectSettings(nextContent);
+	return {
+		valid: true,
+		key: fullKey,
+		entry: findProjectSettingEntry(document, fullKey) ?? null,
+		size: nextContent.length
+	};
+}
+
+export function proposeProjectSettingUnset(content: string, fullKey: string): Record<string, unknown> {
+	const nextContent: string = applyProjectSettingUnsetToContent(content, fullKey);
+	return {
+		valid: true,
+		key: fullKey,
+		removed: findProjectSettingEntry(parseProjectSettings(content), fullKey) !== undefined,
+		size: nextContent.length
+	};
+}

package/src/mcp/godot-tool-registration.ts

@@ -0,0 +1,46 @@
+export const GODOT_MCP_TOOL_NAMES: readonly string[] = [
+	"get_project_summary",
+	"list_project_files",
+	"list_scenes",
+	"list_scripts",
+	"read_text_file",
+	"search_text",
+	"get_project_log_config",
+	"list_project_logs",
+	"read_project_log",
+	"get_project_settings",
+	"get_editor_config_summary",
+	"get_editor_settings",
+	"list_editor_config_files",
+	"read_editor_config_file",
+	"get_editor_project_state",
+	"get_recent_projects",
+	"propose_set_project_setting",
+	"set_project_setting",
+	"propose_unset_project_setting",
+	"unset_project_setting",
+	"propose_create_text_file",
+	"create_text_file",
+	"propose_overwrite_text_file",
+	"overwrite_text_file",
+	"propose_replace_text_in_file",
+	"replace_text_in_file",
+	"delete_file",
+	"inspect_scene_tree",
+	"propose_create_scene",
+	"create_scene",
+	"propose_add_node_to_scene",
+	"add_node_to_scene",
+	"propose_attach_script_to_node",
+	"attach_script_to_node",
+	"propose_connect_signal_in_scene",
+	"connect_signal_in_scene",
+	"propose_apply_scene_patch",
+	"apply_scene_patch"
+];
+
+export const GODOT_MCP_RESOURCE_NAMES: readonly string[] = [
+	"project",
+	"scenes",
+	"scripts"
+];

package/src/mcp/mcp-config.ts

@@ -0,0 +1,48 @@
+import type { McpServerConfig } from "./types.js";
+import { getDefaultWorkspace } from "../workspace/registry.js";
+import type { WorkspaceConfig } from "../workspace/types.js";
+
+const defaultWs = getDefaultWorkspace();
+const DEFAULT_GODOT_PROJECT_PATH: string | undefined = process.env.GODOT_PROJECT_PATH ?? defaultWs?.rootPath;
+const DEFAULT_GODOT_EXECUTABLE_PATH: string | undefined = process.env.GODOT_EXECUTABLE_PATH ?? defaultWs?.godotExecutablePath;
+
+export function buildMcpServerConfigs(workspace?: WorkspaceConfig): McpServerConfig[] {
+	const projectPath: string | undefined = workspace?.rootPath ?? DEFAULT_GODOT_PROJECT_PATH;
+	const godotPath: string | undefined = workspace?.godotExecutablePath ?? DEFAULT_GODOT_EXECUTABLE_PATH;
+
+	if (!projectPath) {
+		return [];
+	}
+
+	const terminalEnv: Record<string, string> = {
+		BACKEND_DIR: process.cwd(),
+		GODOT_PROJECT_PATH: projectPath
+	};
+
+	if (godotPath) {
+		terminalEnv.GODOT_EXECUTABLE_PATH = godotPath;
+	}
+
+	return [
+		{
+			id: "godot",
+			name: "Godot Project MCP",
+			transport: "stdio",
+			command: "npx",
+			args: ["tsx", "src/mcp/godot-mcp-server.ts"],
+			env: {
+				GODOT_PROJECT_PATH: projectPath
+			}
+		},
+		{
+			id: "terminal",
+			name: "Terminal MCP",
+			transport: "stdio",
+			command: "npx",
+			args: ["tsx", "src/mcp/terminal-mcp-server.ts"],
+			env: terminalEnv
+		}
+	];
+}
+
+export const mcpServerConfigs: McpServerConfig[] = buildMcpServerConfigs();