gdharness 1.3.39 → 1.3.41

package/build/godot/operations/plugins.gd

@@ -107,7 +107,45 @@ func enable_plugin(params: Dictionary) -> Dictionary:
 	if err != OK:
 		return _log.failure("Failed to save project.godot: " + error_string(err))
 
-	return {"plugin_name": plugin_name, "action": "enabled", "enabled_plugins": _names_of(enabled_paths)}
+	var answer: Dictionary = {
+		"plugin_name": plugin_name, "action": "enabled", "enabled_plugins": _names_of(enabled_paths)
+	}
+	var unloadable: String = _why_not_loaded(plugin_cfg_path)
+	if not unloadable.is_empty():
+		answer["note"] = unloadable
+	return answer
+
+
+# What the editor finds wrong with the plugin at [param plugin_cfg_path] when it loads it, the checks
+# EditorNode::set_addon_plugin_enabled makes, or "" when it would load. Written all the same, since
+# the script can be put right before the editor next starts.
+static func _why_not_loaded(plugin_cfg_path: String) -> String:
+	var config: ConfigFile = ConfigFile.new()
+	if config.load(plugin_cfg_path) != OK:
+		return "The editor cannot read %s, so it will not enable the plugin." % plugin_cfg_path
+	if not config.has_section_key("plugin", "script"):
+		return "%s has no script field, so the editor will not enable the plugin." % plugin_cfg_path
+	var script_name: String = str(config.get_value("plugin", "script"))
+	if script_name.is_empty():
+		return ""
+	var script_path: String = plugin_cfg_path.get_base_dir().path_join(script_name)
+	if not FileAccess.file_exists(script_path):
+		return "%s does not exist, so the editor will not enable the plugin." % script_path
+	# Loaded only to learn whether the editor could; what the engine says of a script that does not
+	# parse is about a file the answer does not describe.
+	printerr(GdhLog.ASIDE)
+	var script: Script = ResourceLoader.load(script_path, "Script", ResourceLoader.CACHE_MODE_IGNORE)
+	printerr(GdhLog.RESUMED)
+	if script == null or script.get_instance_base_type() == &"":
+		return (
+			"%s does not compile, so the editor disables the plugin again at its next start." % script_path
+			+ " script_diagnostics names the error."
+		)
+	if not ClassDB.is_parent_class(script.get_instance_base_type(), "EditorPlugin"):
+		return "%s does not extend EditorPlugin, so the editor loads nothing for it." % script_path
+	if not script.is_tool():
+		return "%s is not a @tool script, so the editor loads nothing for it." % script_path
+	return ""
 
 
 # Disable a plugin

package/build/godot/operations/project_config.gd

@@ -194,6 +194,12 @@ func unset_project_setting(params: Dictionary) -> Dictionary:
 		answer["removed"] = false
 		answer["saved"] = false
 		answer["note"] = "project.godot does not set %s, so there was nothing to take out." % setting_path
+		var near: PackedStringArray = PackedStringArray() if held else _settings_near(setting_path)
+		if not near.is_empty():
+			answer["note"] += (
+				" Nor does the engine declare it; the nearest %s %s."
+				% ["setting is" if near.size() == 1 else "settings are", ", ".join(near)]
+			)
 		return _with_what_holds(answer, setting_path)
 	answer["old_value"] = _values.serialize_value(value)
 	# The default rather than null for a setting the engine declares: null takes the declaration away
@@ -221,8 +227,12 @@ func _with_what_holds(answer: Dictionary, setting_path: String) -> Dictionary:
 
 
 # The settings in the same section as [param setting_path] named nearest it, for a new one that is
-# likely a misspelt one: a setting nothing declares is written all the same, and is never read.
+# likely a misspelt one: a setting nothing declares is written all the same, and is never read. None
+# for an override of a setting the engine has, which its feature's builds read in the base's place.
 static func _settings_near(setting_path: String) -> PackedStringArray:
+	var base: String = GdhSettingReads.override_base(setting_path)
+	if not base.is_empty() and ProjectSettings.has_setting(base):
+		return PackedStringArray()
 	var section: String = setting_path.get_slice("/", 0) + "/"
 	var names: PackedStringArray = []
 	for info: Dictionary in ProjectSettings.get_property_list():

package/build/godot/operations/property_values.gd

@@ -383,19 +383,16 @@ func _readable(value: Variant, relative_to: Node) -> Variant:
 	return _values.serialize_value(value)
 
 
-## What [param target] stores, by name, but its script and the properties in [param leave]. A list
-## or a map is copied, since a setter can change the one it holds in place.
+## What [param target] stores, by name, but its script and the properties in [param leave], in the
+## names a read answers with: a Curve's points as point_0/position and the rest rather than the _data
+## list every point write changes. A list or a map is copied, since a setter can change the one it
+## holds in place.
 func _stored(target: Object, leave: Dictionary) -> Dictionary:
 	var held: Dictionary = {}
-	for entry: Dictionary in target.get_property_list():
+	for entry: Dictionary in GdhShapes.read_properties(target):
 		var name: String = str(entry["name"])
 		var usage: int = GdhRead.as_int(entry["usage"])
-		if (
-			usage & PROPERTY_USAGE_STORAGE == 0
-			or usage & HEADINGS != 0
-			or name == "script"
-			or leave.has(name)
-		):
+		if usage & HEADINGS != 0 or name == "script" or leave.has(name):
 			continue
 		var value: Variant = target.get(name)
 		if value is Array:

package/build/keeper.js

@@ -7053,7 +7053,18 @@ public static class GdharnessDesktop {
   }
 
   [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
-  static extern IntPtr CreateDesktopW(string name, IntPtr device, IntPtr mode, uint flags, uint access, IntPtr attributes);
+  static extern IntPtr CreateDesktopExW(string name, IntPtr device, IntPtr mode, uint flags, uint access, IntPtr attributes, uint heapKilobytes, IntPtr reserved);
+  [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+  static extern IntPtr CreateWindowStationW(string name, uint flags, uint access, IntPtr attributes);
+  [DllImport("user32.dll", SetLastError = true)] static extern IntPtr GetProcessWindowStation();
+  [DllImport("user32.dll", SetLastError = true)] static extern bool SetProcessWindowStation(IntPtr station);
+  [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+  static extern bool GetUserObjectInformationW(IntPtr handle, int index, StringBuilder into, int size, out int needed);
+  const uint WindowStationAllAccess = 0x37F;
+  const int ObjectName = 2;
+  // What Windows gives an interactive desktop. A non-interactive station's desktops get a small
+  // fraction of that by default, and one desktop here holds every engine a run starts.
+  const uint DesktopHeapKilobytes = 20480;
 
   [DllImport("kernel32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
   static extern bool CreateProcessW(string application, StringBuilder commandLine, IntPtr processAttributes, IntPtr threadAttributes, bool inherit, uint flags, IntPtr environment, string directory, ref StartupInfo startup, out Started started);
@@ -7144,12 +7155,34 @@ public static class GdharnessDesktop {
     StartupInfo startup = new StartupInfo();
     startup.cb = Marshal.SizeOf(typeof(StartupInfo));
     if (desktop.Length > 0) {
-      Step(stepFile, "creating the " + desktop + " desktop");
-      IntPtr held = CreateDesktopW(desktop, IntPtr.Zero, IntPtr.Zero, 0, GenericAll, IntPtr.Zero);
+      Step(stepFile, "opening the session's own window station");
+      IntPtr station = CreateWindowStationW(null, 0, WindowStationAllAccess, IntPtr.Zero);
+      if (station == IntPtr.Zero) {
+        throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateWindowStationW");
+      }
+      StringBuilder stationName = new StringBuilder(256);
+      int needed;
+      if (!GetUserObjectInformationW(station, ObjectName, stationName, stationName.Capacity * 2, out needed)) {
+        throw new Win32Exception(Marshal.GetLastWin32Error(), "GetUserObjectInformationW");
+      }
+      // A desktop is made in the calling process's station, so this one is the caller's while it is.
+      IntPtr own = GetProcessWindowStation();
+      if (!SetProcessWindowStation(station)) {
+        throw new Win32Exception(Marshal.GetLastWin32Error(), "SetProcessWindowStation");
+      }
+      IntPtr held;
+      int made;
+      try {
+        Step(stepFile, "creating the " + desktop + " desktop");
+        held = CreateDesktopExW(desktop, IntPtr.Zero, IntPtr.Zero, 0, GenericAll, IntPtr.Zero, DesktopHeapKilobytes, IntPtr.Zero);
+        made = Marshal.GetLastWin32Error();
+      } finally {
+        SetProcessWindowStation(own);
+      }
       if (held == IntPtr.Zero) {
-        throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateDesktopW " + desktop);
+        throw new Win32Exception(made, "CreateDesktopExW " + stationName + "\\\\" + desktop);
       }
-      startup.desktop = desktop;
+      startup.desktop = stationName + "\\\\" + desktop;
     }
     startup.flags = UseStdHandles;
     if (noActivate) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.3.39",
+  "version": "1.3.41",
   "mcpName": "io.github.Aureliolo/gdharness",
   "description": "A harness for driving a Godot 4 project from an agent: editor addons, a runtime bridge into the running game, an MCP server in front of them, and a CLI that installs and diagnoses the Godot side.",
   "type": "module",