auvrynt 1.0.1

package/dist/godot-dotnet-env.js

@@ -0,0 +1,169 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+const execFileAsync = promisify(execFile);
+export async function detectDotnetSdk() {
+    try {
+        const { stdout } = await execFileAsync("dotnet", ["--info"]);
+        const lines = stdout.split(/\r?\n/);
+        const sdkVersions = [];
+        let selectedSdk;
+        let arch;
+        for (const line of lines) {
+            if (line.includes("Architecture:")) {
+                const parts = line.split(":");
+                if (parts[1])
+                    arch = parts[1].trim();
+            }
+            const sdkMatch = line.trim().match(/^(\d+\.\d+\.\d+)\s+\[/);
+            if (sdkMatch) {
+                sdkVersions.push(sdkMatch[1]);
+            }
+        }
+        if (sdkVersions.length > 0) {
+            selectedSdk = sdkVersions[sdkVersions.length - 1];
+        }
+        return {
+            dotnetExecutable: "dotnet",
+            dotnetSdkVersions: sdkVersions,
+            selectedDotnetSdk: selectedSdk,
+            architecture: arch ?? process.arch,
+        };
+    }
+    catch {
+        return {
+            dotnetSdkVersions: [],
+            architecture: process.arch,
+        };
+    }
+}
+export function findGodotExecutableCandidates() {
+    const candidates = [];
+    if (process.env.GODOT_DOTNET_EXECUTABLE) {
+        candidates.push(process.env.GODOT_DOTNET_EXECUTABLE);
+    }
+    if (process.env.GODOT_EXECUTABLE) {
+        candidates.push(process.env.GODOT_EXECUTABLE);
+    }
+    const commonNames = [
+        "godot-mono",
+        "Godot_v4.3-stable_mono_win64.exe",
+        "Godot_v4.2-stable_mono_win64.exe",
+        "Godot_v4.1-stable_mono_win64.exe",
+        "Godot_v4.0-stable_mono_win64.exe",
+        "Godot_v4.4_mono_win64.exe",
+        "godot",
+    ];
+    candidates.push(...commonNames);
+    // Common Windows paths (Scoop, Chocolatey, User apps)
+    const home = homedir();
+    const windowsPaths = [
+        join(home, "scoop", "apps", "godot-mono", "current", "godot.exe"),
+        join(home, "AppData", "Local", "Programs", "Godot", "godot.exe"),
+        "C:\\Program Files\\Godot\\godot.exe",
+    ];
+    for (const p of windowsPaths) {
+        if (existsSync(p))
+            candidates.push(p);
+    }
+    return Array.from(new Set(candidates));
+}
+export async function verifyGodotExecutable(exePath) {
+    try {
+        const { stdout, stderr } = await execFileAsync(exePath, ["--version"]);
+        const output = (stdout + "\n" + stderr).trim();
+        const version = output.split(/\r?\n/)[0] ?? output;
+        // Godot .NET edition versions contain ".mono" or "mono" in the version string
+        const hasDotnetSupport = version.toLowerCase().includes("mono") || output.toLowerCase().includes("mono");
+        return {
+            valid: true,
+            version,
+            hasDotnetSupport,
+        };
+    }
+    catch {
+        return {
+            valid: false,
+            hasDotnetSupport: false,
+        };
+    }
+}
+export async function inspectGodotDotnetEnvironment(registry, input) {
+    const problems = [];
+    const dotnetInfo = await detectDotnetSdk();
+    if (dotnetInfo.dotnetSdkVersions.length === 0) {
+        problems.push({
+            code: "MISSING_DOTNET_SDK",
+            message: ".NET SDK was not detected or `dotnet` command failed.",
+            suggestedFix: "Install a 64-bit .NET 8.0 SDK from https://dotnet.microsoft.com/download",
+        });
+    }
+    const candidateExes = findGodotExecutableCandidates();
+    let selectedGodotExe;
+    let selectedGodotVersion;
+    let godotHasDotnetSupport = false;
+    for (const candidate of candidateExes) {
+        const check = await verifyGodotExecutable(candidate);
+        if (check.valid) {
+            selectedGodotExe = candidate;
+            selectedGodotVersion = check.version;
+            godotHasDotnetSupport = check.hasDotnetSupport;
+            if (godotHasDotnetSupport)
+                break; // Found proper .NET edition
+        }
+    }
+    if (!selectedGodotExe) {
+        problems.push({
+            code: "MISSING_GODOT_EXECUTABLE",
+            message: "Godot executable was not found on PATH or configured locations.",
+            suggestedFix: "Download Godot 4 .NET edition and set GODOT_DOTNET_EXECUTABLE environment variable.",
+        });
+    }
+    else if (!godotHasDotnetSupport) {
+        problems.push({
+            code: "GODOT_MISSING_DOTNET_SUPPORT",
+            message: `Godot executable (${selectedGodotExe}) was found, but it does not include .NET/C# support.`,
+            suggestedFix: "Install or configure the Godot 4 .NET (Mono) edition.",
+        });
+    }
+    let projectTargetFrameworks = [];
+    if (input.projectPath) {
+        const workspace = registry.getWorkspace(input.workspaceId);
+        const targetDir = registry.resolvePath(workspace, input.projectPath);
+        // Check if project contains .csproj
+        try {
+            const { readdir, readFile } = await import("node:fs/promises");
+            const files = await readdir(targetDir);
+            const csproj = files.find((f) => f.endsWith(".csproj"));
+            if (csproj) {
+                const content = await readFile(join(targetDir, csproj), "utf8");
+                const tfm = content.match(/<TargetFrameworks?>(.*?)<\/TargetFrameworks?>/i);
+                if (tfm)
+                    projectTargetFrameworks = tfm[1].split(";").map((t) => t.trim());
+            }
+        }
+        catch { }
+    }
+    let status = "ready";
+    if (problems.some((p) => p.code === "MISSING_DOTNET_SDK" || p.code === "MISSING_GODOT_EXECUTABLE")) {
+        status = "invalid";
+    }
+    else if (problems.length > 0) {
+        status = "incomplete";
+    }
+    return {
+        godotExecutable: selectedGodotExe,
+        godotVersion: selectedGodotVersion,
+        godotHasDotnetSupport,
+        dotnetExecutable: dotnetInfo.dotnetExecutable,
+        dotnetSdkVersions: dotnetInfo.dotnetSdkVersions,
+        selectedDotnetSdk: dotnetInfo.selectedDotnetSdk,
+        projectTargetFrameworks,
+        architecture: dotnetInfo.architecture,
+        exportTemplatesInstalled: true,
+        status,
+        problems,
+    };
+}

package/dist/godot-editor-bridge.js

@@ -0,0 +1,140 @@
+import { createConnection } from "node:net";
+import { randomUUID } from "node:crypto";
+export class GodotEditorBridgeClient {
+    socket = null;
+    token = "";
+    isConnected = false;
+    async connect(host = "127.0.0.1", port = 49322, token = "") {
+        this.token = token;
+        return new Promise((resolve) => {
+            try {
+                this.socket = createConnection({ host, port }, () => {
+                    this.isConnected = true;
+                    resolve(true);
+                });
+                this.socket.on("error", () => {
+                    this.isConnected = false;
+                    resolve(false);
+                });
+                this.socket.on("close", () => {
+                    this.isConnected = false;
+                });
+            }
+            catch {
+                this.isConnected = false;
+                resolve(false);
+            }
+        });
+    }
+    async sendRequest(method, params = {}) {
+        if (!this.socket || !this.isConnected) {
+            throw new Error("Godot Editor Bridge is not connected.");
+        }
+        const requestId = randomUUID();
+        const payload = JSON.stringify({
+            protocolVersion: 1,
+            requestId,
+            token: this.token,
+            method,
+            params,
+        }) + "\n";
+        return new Promise((resolve, reject) => {
+            let buffer = "";
+            const onData = (data) => {
+                buffer += data.toString("utf8");
+                while (true) {
+                    const nlIndex = buffer.indexOf("\n");
+                    if (nlIndex === -1)
+                        break;
+                    const line = buffer.slice(0, nlIndex).trim();
+                    buffer = buffer.slice(nlIndex + 1);
+                    if (!line)
+                        continue;
+                    try {
+                        const resp = JSON.parse(line);
+                        if (resp.requestId === requestId) {
+                            this.socket?.off("data", onData);
+                            if (resp.ok)
+                                resolve(resp.result);
+                            else
+                                reject(new Error(resp.result?.error ?? "Bridge request failed"));
+                            return;
+                        }
+                    }
+                    catch { }
+                }
+            };
+            this.socket?.on("data", onData);
+            this.socket?.write(payload);
+            setTimeout(() => {
+                this.socket?.off("data", onData);
+                reject(new Error("Bridge request timeout"));
+            }, 5000);
+        });
+    }
+    disconnect() {
+        if (this.socket) {
+            this.socket.destroy();
+            this.socket = null;
+            this.isConnected = false;
+        }
+    }
+    get status() {
+        return this.isConnected;
+    }
+}
+const activeBridges = new Map();
+export function getBridgeClient(workspaceId) {
+    let client = activeBridges.get(workspaceId);
+    if (!client) {
+        client = new GodotEditorBridgeClient();
+        activeBridges.set(workspaceId, client);
+    }
+    return client;
+}
+export async function godotEditorConnect(registry, input) {
+    const client = getBridgeClient(input.workspaceId);
+    const connected = await client.connect(input.host ?? "127.0.0.1", input.port ?? 49322, input.token ?? "");
+    if (!connected) {
+        return {
+            connected: false,
+            protocolVersion: 1,
+        };
+    }
+    try {
+        const res = await client.sendRequest("status");
+        return {
+            connected: true,
+            godotVersion: res.godotVersion,
+            projectPath: res.projectPath,
+            protocolVersion: res.protocolVersion ?? 1,
+        };
+    }
+    catch {
+        return {
+            connected: true,
+            protocolVersion: 1,
+        };
+    }
+}
+export async function godotEditorStatus(input) {
+    const client = getBridgeClient(input.workspaceId);
+    if (!client.status) {
+        return { connected: false, protocolVersion: 1 };
+    }
+    try {
+        const res = await client.sendRequest("status");
+        return { connected: true, ...res, protocolVersion: 1 };
+    }
+    catch {
+        return { connected: false, protocolVersion: 1 };
+    }
+}
+export function godotEditorDisconnect(input) {
+    const client = activeBridges.get(input.workspaceId);
+    if (client) {
+        client.disconnect();
+        activeBridges.delete(input.workspaceId);
+    }
+    return { disconnected: true };
+}