auvrynt 1.0.1

package/dist/godot-project-settings.js

@@ -0,0 +1,223 @@
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+import { join, relative } from "node:path";
+export async function getProjectSettings(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const godotFile = join(registry.resolvePath(workspace, input.projectPath), "project.godot");
+    const content = await readFile(godotFile, "utf8");
+    const settings = {};
+    const lines = content.split(/\r?\n/);
+    let currentSection = "";
+    for (const line of lines) {
+        const sectionMatch = line.match(/^\[(\w+)\]$/);
+        if (sectionMatch) {
+            currentSection = sectionMatch[1];
+            continue;
+        }
+        const kvMatch = line.match(/^(\S+)\s*=\s*(.+)$/);
+        if (kvMatch) {
+            const key = currentSection ? `${currentSection}/${kvMatch[1]}` : kvMatch[1];
+            settings[key] = kvMatch[2].trim();
+        }
+    }
+    return settings;
+}
+export async function setProjectSetting(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const godotFile = join(registry.resolvePath(workspace, input.projectPath), "project.godot");
+    let content = await readFile(godotFile, "utf8");
+    const newValueStr = JSON.stringify(input.value);
+    const keyParts = input.settingKey.split("/");
+    const [section, ...keyRest] = keyParts;
+    const key = keyRest.join("/");
+    const keyRegex = new RegExp(`^(${key}\\s*=\\s*)(.+)$`, "m");
+    const prev = keyRegex.exec(content)?.[2];
+    if (keyRegex.test(content)) {
+        content = content.replace(keyRegex, `$1${newValueStr}`);
+    }
+    else {
+        const sectionRegex = new RegExp(`\\[${section}\\]`, "m");
+        if (sectionRegex.test(content)) {
+            content = content.replace(sectionRegex, `[${section}]\n${key}=${newValueStr}`);
+        }
+        else {
+            content += `\n[${section}]\n${key}=${newValueStr}\n`;
+        }
+    }
+    await writeFile(godotFile, content, "utf8");
+    return { previousValue: prev, newValue: newValueStr };
+}
+export async function getInputMap(registry, input) {
+    const settings = await getProjectSettings(registry, input);
+    const inputActions = {};
+    for (const [key, value] of Object.entries(settings)) {
+        if (key.startsWith("input/")) {
+            const actionName = key.replace("input/", "");
+            inputActions[actionName] = [value];
+        }
+    }
+    return inputActions;
+}
+export async function getAutoloads(registry, input) {
+    const settings = await getProjectSettings(registry, input);
+    const autoloads = {};
+    for (const [key, value] of Object.entries(settings)) {
+        if (key.startsWith("autoload/")) {
+            const name = key.replace("autoload/", "");
+            autoloads[name] = value;
+        }
+    }
+    return autoloads;
+}
+export async function applyPixelArtImportPreset(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const changed = [];
+    const errors = [];
+    for (const texturePath of input.paths) {
+        try {
+            const absPath = registry.resolvePath(workspace, texturePath);
+            const importPath = absPath + ".import";
+            let importContent;
+            try {
+                importContent = await readFile(importPath, "utf8");
+            }
+            catch {
+                // Create a minimal .import file
+                importContent = `[remap]\n\nimporter="texture"\n`;
+            }
+            // Apply pixel art import settings
+            const pixelArtSettings = [
+                ["process/fix_alpha_border", "false"],
+                ["process/premult_alpha", "false"],
+                ["compress/mode", "0"], // Lossless
+                ["compress/high_quality", "false"],
+                ["flags/repeat", "0"],
+                ["flags/filter", "false"], // nearest neighbour
+                ["flags/mipmaps", "false"],
+                ["flags/anisotropic", "false"],
+                ["flags/srgb", "2"],
+            ];
+            for (const [key, val] of pixelArtSettings) {
+                const keyRegex = new RegExp(`^(${key}\\s*=\\s*)(.*)$`, "m");
+                if (keyRegex.test(importContent)) {
+                    importContent = importContent.replace(keyRegex, `$1${val}`);
+                }
+            }
+            await writeFile(importPath, importContent, "utf8");
+            changed.push(texturePath);
+        }
+        catch (err) {
+            errors.push(`${texturePath}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    return { changed, errors };
+}
+// ─── VS Code Configuration Generator ────────────────────────────────────────
+export async function generateVscodeConfig(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const targetDir = registry.resolvePath(workspace, input.projectPath);
+    const vscodeDir = join(targetDir, ".vscode");
+    await mkdir(vscodeDir, { recursive: true });
+    const generated = [];
+    const skipped = [];
+    const godotExe = input.godotExecutable ?? "${env:GODOT_DOTNET_EXECUTABLE}";
+    // tasks.json
+    const tasksPath = join(vscodeDir, "tasks.json");
+    let tasksContent = { version: "2.0.0", tasks: [] };
+    try {
+        tasksContent = JSON.parse(await readFile(tasksPath, "utf8"));
+    }
+    catch { }
+    const godotTasks = [
+        {
+            label: "Godot: Build C#",
+            type: "shell",
+            command: "dotnet build",
+            args: ["${workspaceFolder}"],
+            group: "build",
+        },
+        {
+            label: "Godot: Restore NuGet",
+            type: "shell",
+            command: "dotnet restore",
+            args: ["${workspaceFolder}"],
+        },
+        {
+            label: "Godot: Run Project",
+            type: "shell",
+            command: godotExe,
+            args: ["--path", "${workspaceFolder}", "-d"],
+        },
+        {
+            label: "Godot: Headless Validate",
+            type: "shell",
+            command: godotExe,
+            args: ["--headless", "--path", "${workspaceFolder}", "--editor", "--quit"],
+        },
+    ];
+    const existingLabels = new Set((tasksContent.tasks ?? []).map((t) => t.label));
+    for (const task of godotTasks) {
+        if (!existingLabels.has(task.label)) {
+            tasksContent.tasks.push(task);
+        }
+    }
+    await writeFile(tasksPath, JSON.stringify(tasksContent, null, 2), "utf8");
+    generated.push(relative(workspace.root, tasksPath).replace(/\\/g, "/"));
+    // launch.json
+    const launchPath = join(vscodeDir, "launch.json");
+    let launchContent = { version: "0.2.0", configurations: [] };
+    try {
+        launchContent = JSON.parse(await readFile(launchPath, "utf8"));
+    }
+    catch { }
+    const existingNames = new Set((launchContent.configurations ?? []).map((c) => c.name));
+    if (!existingNames.has("Godot C# Debug")) {
+        launchContent.configurations.push({
+            name: "Godot C# Debug",
+            type: "coreclr",
+            request: "attach",
+            processId: "${command:pickProcess}",
+            program: "${workspaceFolder}/bin/Debug/net8.0/${workspaceFolderBasename}.dll",
+        });
+        await writeFile(launchPath, JSON.stringify(launchContent, null, 2), "utf8");
+        generated.push(relative(workspace.root, launchPath).replace(/\\/g, "/"));
+    }
+    else {
+        skipped.push(relative(workspace.root, launchPath).replace(/\\/g, "/"));
+    }
+    return { generated, skipped };
+}
+export async function listExportPresets(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const presetFile = join(registry.resolvePath(workspace, input.projectPath), "export_presets.cfg");
+    let content;
+    try {
+        content = await readFile(presetFile, "utf8");
+    }
+    catch {
+        return [];
+    }
+    const presets = [];
+    const lines = content.split(/\r?\n/);
+    let currentPreset = null;
+    for (const line of lines) {
+        if (line.startsWith("[preset.")) {
+            if (currentPreset)
+                presets.push(currentPreset);
+            currentPreset = { name: "", platform: "", mode: "release" };
+        }
+        else if (currentPreset) {
+            if (line.startsWith("name=")) {
+                currentPreset.name = line.replace(/^name=/, "").replace(/"/g, "").trim();
+            }
+            else if (line.startsWith("platform=")) {
+                currentPreset.platform = line.replace(/^platform=/, "").replace(/"/g, "").trim();
+            }
+            else if (line.startsWith("export_debug=")) {
+                currentPreset.mode = line.includes("true") ? "debug" : "release";
+            }
+        }
+    }
+    if (currentPreset)
+        presets.push(currentPreset);
+    return presets;
+}

package/dist/godot-runtime-testing.js

@@ -0,0 +1,249 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { mkdir } from "node:fs/promises";
+import { dirname, relative } from "node:path";
+const execFileAsync = promisify(execFile);
+// ─── Remote Scene Tree ────────────────────────────────────────────────────
+export async function getRemoteSceneTree(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("remote.get_scene_tree", {
+        maxDepth: input.maxDepth ?? 10,
+    });
+}
+export async function getRuntimeProperty(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("remote.get_property", {
+        nodePath: input.nodePath,
+        property: input.property,
+    });
+}
+export async function getPerformanceMonitors(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    return bridgeClient.sendRequest("remote.get_performance_monitors", {});
+}
+export function parseCsharpExceptions(logLines) {
+    const exceptions = [];
+    let currentEx = null;
+    const EXCEPTION_TYPES = [
+        "NullReferenceException", "InvalidCastException", "ObjectDisposedException",
+        "InvalidOperationException", "ArgumentException", "ArgumentNullException",
+        "NotImplementedException", "IndexOutOfRangeException", "KeyNotFoundException",
+        "IOException", "FileNotFoundException",
+    ];
+    for (const line of logLines) {
+        const trimmed = line.trim();
+        // Check inner exception prefix FIRST (before top-level exception detection)
+        if (currentEx && trimmed.startsWith("---> ")) {
+            const innerMatch = trimmed.slice(5).match(/(\w*Exception):\s*(.*)/);
+            if (innerMatch) {
+                currentEx.innerExceptions.push({
+                    exceptionType: innerMatch[1],
+                    message: innerMatch[2],
+                    innerExceptions: [],
+                    stackFrames: [],
+                    firstOccurrence: new Date().toISOString(),
+                    repeatCount: 1,
+                });
+            }
+            continue;
+        }
+        const isException = EXCEPTION_TYPES.some((t) => trimmed.includes(t)) || trimmed.includes("Exception:");
+        if (isException) {
+            if (currentEx)
+                exceptions.push(currentEx);
+            const typeMatch = trimmed.match(/(\w+Exception):\s*(.*)/);
+            currentEx = {
+                exceptionType: typeMatch?.[1] ?? "Exception",
+                message: typeMatch?.[2] ?? trimmed,
+                innerExceptions: [],
+                stackFrames: [],
+                firstOccurrence: new Date().toISOString(),
+                repeatCount: 1,
+            };
+            continue;
+        }
+        if (currentEx) {
+            const frameMatch = trimmed.match(/^at\s+(.*?)(?:\s+in\s+(.*?):line\s+(\d+))?$/);
+            if (frameMatch) {
+                currentEx.stackFrames.push({
+                    method: frameMatch[1],
+                    path: frameMatch[2],
+                    line: frameMatch[3] ? Number(frameMatch[3]) : undefined,
+                });
+            }
+        }
+    }
+    if (currentEx)
+        exceptions.push(currentEx);
+    // Collapse repeated exceptions
+    const collapsed = [];
+    for (const ex of exceptions) {
+        const prev = collapsed.find((e) => e.exceptionType === ex.exceptionType && e.message === ex.message);
+        if (prev) {
+            prev.repeatCount++;
+        }
+        else {
+            collapsed.push(ex);
+        }
+    }
+    return collapsed;
+}
+export async function pressAction(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected for input simulation.");
+    const duration = Math.min(input.durationMs ?? 100, 2000);
+    await bridgeClient.sendRequest("input.press_action", { action: input.action, durationMs: duration });
+    return { sent: true };
+}
+export async function releaseAction(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    await bridgeClient.sendRequest("input.release_action", { action: input.action });
+    return { sent: true };
+}
+export async function mouseClick(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    await bridgeClient.sendRequest("input.mouse_click", { x: input.x, y: input.y, button: input.button ?? 1 });
+    return { sent: true };
+}
+export async function assertNodeExists(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    try {
+        await bridgeClient.sendRequest("remote.get_node", { nodePath: input.nodePath });
+        return { passed: true, message: `Node '${input.nodePath}' exists.` };
+    }
+    catch {
+        return { passed: false, message: `Node '${input.nodePath}' does not exist.` };
+    }
+}
+export async function assertProperty(input, bridgeClient) {
+    if (!bridgeClient.status)
+        throw new Error("Godot Editor Bridge is not connected.");
+    const { value } = await getRuntimeProperty({ workspaceId: input.workspaceId, nodePath: input.nodePath, property: input.property }, bridgeClient);
+    let passed;
+    switch (input.comparison) {
+        case "eq":
+            passed = JSON.stringify(value) === JSON.stringify(input.expected);
+            break;
+        case "neq":
+            passed = JSON.stringify(value) !== JSON.stringify(input.expected);
+            break;
+        case "gt":
+            passed = value > input.expected;
+            break;
+        case "lt":
+            passed = value < input.expected;
+            break;
+        case "approx":
+            passed = Math.abs(value - input.expected) < 0.001;
+            break;
+        case "contains":
+            passed = String(value).includes(String(input.expected));
+            break;
+        case "exists":
+            passed = value !== null && value !== undefined;
+            break;
+        default: passed = false;
+    }
+    return {
+        passed,
+        actual: value,
+        expected: input.expected,
+        message: passed
+            ? `Property '${input.property}' assertion passed.`
+            : `Expected '${input.property}' to be ${input.comparison} '${JSON.stringify(input.expected)}', got '${JSON.stringify(value)}'.`,
+    };
+}
+export async function runTestSequence(registry, processManager, input, bridgeClient) {
+    const MAX_STEPS = 50;
+    const MAX_DURATION_MS = 30000;
+    const MAX_SCREENSHOTS = 5;
+    if (input.steps.length > MAX_STEPS) {
+        throw new Error(`Test sequence too long (max ${MAX_STEPS} steps).`);
+    }
+    const results = [];
+    let totalDuration = 0;
+    let screenshotCount = 0;
+    for (let i = 0; i < input.steps.length; i++) {
+        const step = input.steps[i];
+        switch (step.type) {
+            case "wait": {
+                const delay = Math.min(step.durationMs, 5000);
+                totalDuration += delay;
+                if (totalDuration > MAX_DURATION_MS) {
+                    results.push({ step: i, type: step.type, passed: false, message: "Total duration limit exceeded." });
+                    return { results };
+                }
+                await new Promise((r) => setTimeout(r, delay));
+                results.push({ step: i, type: step.type, passed: true, message: `Waited ${delay}ms.` });
+                break;
+            }
+            case "press_action": {
+                const r = await pressAction({ workspaceId: input.workspaceId, processId: input.processId, action: step.action, durationMs: step.durationMs }, bridgeClient).catch((err) => ({ sent: false, error: err.message }));
+                results.push({ step: i, type: step.type, passed: r.sent ?? false, message: `Press action '${step.action}'` });
+                break;
+            }
+            case "screenshot": {
+                if (screenshotCount >= MAX_SCREENSHOTS) {
+                    results.push({ step: i, type: step.type, passed: false, message: "Screenshot limit exceeded." });
+                    break;
+                }
+                screenshotCount++;
+                results.push({ step: i, type: step.type, passed: true, message: `Screenshot step queued to ${step.outputPath}.` });
+                break;
+            }
+            case "assert_node_exists": {
+                const r = await assertNodeExists({ workspaceId: input.workspaceId, nodePath: step.nodePath }, bridgeClient).catch(() => ({ passed: false, message: "Bridge error" }));
+                results.push({ step: i, type: step.type, passed: r.passed, message: r.message });
+                break;
+            }
+            case "assert_property": {
+                const r = await assertProperty({ workspaceId: input.workspaceId, nodePath: step.nodePath, property: step.property, comparison: step.comparison, expected: step.expected }, bridgeClient).catch((err) => ({ passed: false, actual: null, expected: step.expected, message: err.message }));
+                results.push({ step: i, type: step.type, passed: r.passed, message: r.message });
+                break;
+            }
+            case "assert_no_errors": {
+                const logs = processManager.getProcessLogs({ workspaceId: input.workspaceId, processId: input.processId, lines: 100 });
+                const hasErrors = logs.lines.some((l) => l.includes("ERROR:") || l.includes("Exception:"));
+                results.push({ step: i, type: step.type, passed: !hasErrors, message: hasErrors ? "Runtime errors detected." : "No runtime errors." });
+                break;
+            }
+            default: {
+                results.push({ step: i, type: step.type ?? "unknown", passed: false, message: "Unknown step type." });
+            }
+        }
+    }
+    return { results };
+}
+export async function exportGodotProject(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const projectDir = registry.resolvePath(workspace, input.projectPath);
+    const absoluteOutputPath = registry.resolvePath(workspace, input.outputPath);
+    await mkdir(dirname(absoluteOutputPath), { recursive: true });
+    const godotExe = process.env.GODOT_DOTNET_EXECUTABLE ?? process.env.GODOT_EXECUTABLE ?? "godot-mono";
+    const exportFlag = (input.mode ?? "debug") === "debug" ? "--export-debug" : "--export-release";
+    const args = ["--headless", "--path", projectDir, exportFlag, input.preset, absoluteOutputPath];
+    const start = Date.now();
+    try {
+        const { stdout, stderr } = await execFileAsync(godotExe, args, { cwd: projectDir });
+        return {
+            success: true,
+            outputFiles: [relative(workspace.root, absoluteOutputPath).replace(/\\/g, "/")],
+            durationMs: Date.now() - start,
+            output: (stdout + "\n" + stderr).slice(0, 1000),
+        };
+    }
+    catch (err) {
+        return {
+            success: false,
+            outputFiles: [],
+            durationMs: Date.now() - start,
+            output: (err.stdout ?? "") + "\n" + (err.stderr ?? err.message),
+        };
+    }
+}

package/dist/godot-tools.js

@@ -0,0 +1,183 @@
+import { readFile, readdir } from "node:fs/promises";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { join } from "node:path";
+const execFileAsync = promisify(execFile);
+export function parseGodotProjectFile(content) {
+    let configVersion = 5;
+    let name = "Godot Project";
+    let mainScene = "";
+    let renderer = "Forward+";
+    const features = [];
+    const autoloads = {};
+    const inputActions = [];
+    const nameMatch = content.match(/config\/name="([^"]+)"/);
+    if (nameMatch)
+        name = nameMatch[1];
+    const sceneMatch = content.match(/run\/main_scene="([^"]+)"/);
+    if (sceneMatch)
+        mainScene = sceneMatch[1];
+    const versionMatch = content.match(/config_version=(\d+)/);
+    if (versionMatch)
+        configVersion = Number(versionMatch[1]);
+    const rendererMatch = content.match(/rendering\/renderer\/rendering_method="([^"]+)"/);
+    if (rendererMatch)
+        renderer = rendererMatch[1];
+    const featureMatch = content.match(/config\/features=PackedStringArray\((.*?)\)/);
+    if (featureMatch) {
+        features.push(...featureMatch[1].split(",").map((f) => f.replace(/"/g, "").trim()));
+    }
+    // Parse [autoload] section
+    const autoloadSection = content.match(/\[autoload\]([\s\S]*?)(?=\n\[|$)/);
+    if (autoloadSection) {
+        const lines = autoloadSection[1].split("\n");
+        for (const line of lines) {
+            const kv = line.match(/^(\w+)="([^"]+)"/);
+            if (kv)
+                autoloads[kv[1]] = kv[2];
+        }
+    }
+    // Parse [input] section
+    const inputSection = content.match(/\[input\]([\s\S]*?)(?=\n\[|$)/);
+    if (inputSection) {
+        const lines = inputSection[1].split("\n");
+        for (const line of lines) {
+            const kv = line.match(/^(\w+)=\{/);
+            if (kv)
+                inputActions.push(kv[1]);
+        }
+    }
+    return { configVersion, name, mainScene, renderer, features, autoloads, inputActions };
+}
+export function parseGodotScene(content) {
+    const nodes = [];
+    const externalResources = [];
+    const signals = [];
+    const lines = content.split(/\r?\n/);
+    let currentElement = null;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("[ext_resource")) {
+            const idMatch = trimmed.match(/id="([^"]+)"/);
+            const typeMatch = trimmed.match(/type="([^"]+)"/);
+            const pathMatch = trimmed.match(/path="([^"]+)"/);
+            if (idMatch && typeMatch && pathMatch) {
+                externalResources.push({ id: idMatch[1], type: typeMatch[1], path: pathMatch[1] });
+            }
+        }
+        else if (trimmed.startsWith("[node")) {
+            const nameMatch = trimmed.match(/name="([^"]+)"/);
+            const typeMatch = trimmed.match(/type="([^"]+)"/);
+            const parentMatch = trimmed.match(/parent="([^"]+)"/);
+            if (nameMatch) {
+                const node = {
+                    name: nameMatch[1],
+                    type: typeMatch ? typeMatch[1] : "Node",
+                    parent: parentMatch ? parentMatch[1] : undefined,
+                    properties: {},
+                };
+                nodes.push(node);
+                currentElement = { type: "node", data: node };
+            }
+        }
+        else if (trimmed.startsWith("[connection")) {
+            const signalMatch = trimmed.match(/signal="([^"]+)"/);
+            const fromMatch = trimmed.match(/from="([^"]+)"/);
+            const toMatch = trimmed.match(/to="([^"]+)"/);
+            const methodMatch = trimmed.match(/method="([^"]+)"/);
+            if (signalMatch && fromMatch && toMatch && methodMatch) {
+                signals.push({
+                    signal: signalMatch[1],
+                    from: fromMatch[1],
+                    to: toMatch[1],
+                    method: methodMatch[1],
+                });
+            }
+        }
+        else if (currentElement?.type === "node" && trimmed.includes("=")) {
+            const eqIdx = trimmed.indexOf("=");
+            const k = trimmed.slice(0, eqIdx).trim();
+            const v = trimmed.slice(eqIdx + 1).trim();
+            currentElement.data.properties[k] = v;
+        }
+    }
+    const rootNode = nodes.find((n) => !n.parent)?.name;
+    return { rootNode, nodes, externalResources, signals };
+}
+export async function detectGodotProject(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const targetDir = input.path
+        ? registry.resolvePath(workspace, input.path)
+        : workspace.root;
+    const projectGodotPath = join(targetDir, "project.godot");
+    let content = "";
+    try {
+        content = await readFile(projectGodotPath, "utf8");
+    }
+    catch {
+        return {
+            projectPath: input.path ?? ".",
+            godotProjectFound: false,
+            hasCSharp: false,
+        };
+    }
+    const parsed = parseGodotProjectFile(content);
+    let dirFiles = [];
+    try {
+        dirFiles = await readdir(targetDir);
+    }
+    catch { }
+    const hasCSharp = dirFiles.some((f) => f.endsWith(".csproj") || f.endsWith(".sln"));
+    return {
+        projectPath: input.path ?? ".",
+        godotProjectFound: true,
+        ...parsed,
+        hasCSharp,
+    };
+}
+export async function godotRun(registry, processManager, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const projectDir = registry.resolvePath(workspace, input.projectPath);
+    const godotBin = process.env.GODOT_EXECUTABLE ?? "godot";
+    const args = ["--path", `"${projectDir}"`];
+    if (input.scenePath) {
+        const absScene = registry.resolvePath(workspace, input.scenePath);
+        args.push(`"${absScene}"`);
+    }
+    if (input.editor)
+        args.push("-e");
+    if (input.debug)
+        args.push("-d");
+    if (input.additionalArguments)
+        args.push(...input.additionalArguments);
+    const command = `${godotBin} ${args.join(" ")}`;
+    const result = processManager.startProcess({
+        workspaceId: input.workspaceId,
+        command,
+        workingDirectory: projectDir,
+    });
+    return {
+        processId: result.processId,
+        status: result.status,
+        detectedUrls: result.detectedUrls,
+    };
+}
+export async function inspectGodotScene(registry, input) {
+    const workspace = registry.getWorkspace(input.workspaceId);
+    const absolutePath = registry.resolvePath(workspace, input.scenePath);
+    if (input.scenePath.endsWith(".scn")) {
+        throw new Error("Binary .scn scenes are not supported. Use text .tscn format.");
+    }
+    const content = await readFile(absolutePath, "utf8");
+    const parsed = parseGodotScene(content);
+    const nodeTypes = Array.from(new Set(parsed.nodes.map((n) => n.type)));
+    return {
+        scenePath: input.scenePath,
+        rootNode: parsed.rootNode,
+        nodeCount: parsed.nodes.length,
+        nodeTypes,
+        nodes: parsed.nodes,
+        externalResources: parsed.externalResources,
+        signals: parsed.signals,
+    };
+}