gdharness 1.1.0 → 1.1.2

package/build/cli.js

@@ -15992,7 +15992,7 @@ var init_tool_definitions = __esm(() => {
       requires: ["projectPath"],
       operations: {
         status: {
-          summary: "which resources are outdated or failed, or one resource with resourcePath",
+          summary: "which resources are outdated or failed, or one resource with resourcePath: a source changed since its import, an import whose output under .godot/imported is gone (missing_outputs), and a glTF scene imported before the images it uses (imported_before), each with its reason",
           requires: []
         },
         options: { summary: "the import options of one resource", requires: ["resourcePath"] },
@@ -16440,7 +16440,7 @@ var init_tool_definitions = __esm(() => {
     },
     {
       name: "editor_rescan",
-      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
+      description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
       parameters: {
         projectPath: PROJECT_PATH,
         timeoutMs: {
@@ -41802,6 +41802,17 @@ class GodotServer {
     const nearest = descendantsIn(tree, root).filter((pid) => isEngine(pid) && !ancestorsIn(tree, pid, root).some((one) => one !== root && isEngine(one)));
     return nearest.length === 1 ? nearest[0] : undefined;
   }
+  async editorIsScanningOrImporting() {
+    if (!this.godotBridge.isConnected()) {
+      return false;
+    }
+    try {
+      const status = asParams(await this.godotBridge.invokeTool("scan_status", {}));
+      return status["scanning"] === true || status["importing"] === true;
+    } catch {
+      return false;
+    }
+  }
   async handleRescanFilesystem(args) {
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 30000;
     const started = Date.now();
@@ -41811,9 +41822,26 @@ class GodotServer {
     const blind = await this.classesTheEditorCannotSee(args);
     const atRisk = before === null ? [] : blind.unseen.filter((one) => before.has(one.className));
     const ghosts = blind.stillHeld ?? [];
-    const first = await this.handleViaBridge("rescan_filesystem", args);
-    if (first.isError) {
-      return first;
+    let waitedForEditorMs = 0;
+    let first;
+    for (;; ) {
+      const busySince = Date.now();
+      let wasBusy = false;
+      while (Date.now() - started < timeoutMs && await this.editorIsScanningOrImporting()) {
+        wasBusy = true;
+        await new Promise((settle) => setTimeout(settle, 100));
+      }
+      if (wasBusy) {
+        waitedForEditorMs += Date.now() - busySince;
+      }
+      first = await this.handleViaBridge("rescan_filesystem", args);
+      if (first.isError) {
+        return first;
+      }
+      const declined = asParams(JSON.parse(first.content[0]?.text ?? "{}"))["started"] === false;
+      if (!declined || Date.now() - started >= timeoutMs) {
+        break;
+      }
     }
     let busy = true;
     while (busy && Date.now() - started < timeoutMs) {
@@ -41872,6 +41900,7 @@ class GodotServer {
       ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
+      waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
       heldBeforeReload: reloaded.heldBefore,
       reloadedMethods: reloaded.methods,
       reloadProblem: reloaded.problem,

package/build/godot/addons/gdharness_editor/tools/scene_tools.gd

@@ -656,10 +656,16 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 		return {"ok": false, "error": "Editor plugin unavailable"}
 
 	var filesystem: EditorFileSystem = EditorInterface.get_resource_filesystem()
-	if not Read.as_bool(args.get("statusOnly", false)):
+	# Not over a scan or an import the editor is already running: a scan asked for then starts a
+	# second reimport over the first, and the editor logs "Task 'reimport' already exists" and two
+	# conditions from its progress dialog. Declined and said, so the caller waits and asks again.
+	var busy: bool = filesystem.is_scanning() or filesystem.is_importing()
+	var started: bool = false
+	if not Read.as_bool(args.get("statusOnly", false)) and not busy:
 		_scans_finished_at_request = _scans_finished
 		_scan_pending = true
 		filesystem.scan()
+		started = true
 
 	# Importing is reported separately from scanning, and a class is not registered until
 	# both are done, so a caller watching only one of them can look too early.
@@ -677,6 +683,7 @@ func rescan_filesystem(args: Dictionary) -> Dictionary:
 		_scan_pending = false
 	return {
 		"ok": true,
+		"started": started,
 		"scanning": scanning,
 		"importing": importing,
 		"pending": _scan_pending,

package/build/godot/operations/import_pipeline.gd

@@ -380,12 +380,106 @@ func _import_status_of(resource_path: String, import_file_path: String) -> Dicti
 			"source_exists": true
 		}
 
-	var source_modified: int = FileAccess.get_modified_time(resource_path)
-	var import_modified: int = FileAccess.get_modified_time(import_file_path)
-
-	return {
-		"path": resource_path,
-		"status": "needs_reimport" if source_modified > import_modified else "up_to_date",
-		"import_file_exists": true,
-		"source_exists": true
+	var status: Dictionary = {
+		"path": resource_path, "status": "up_to_date", "import_file_exists": true, "source_exists": true
 	}
+	if FileAccess.get_modified_time(resource_path) > FileAccess.get_modified_time(import_file_path):
+		status["status"] = "needs_reimport"
+		status["reason"] = "the source changed after it was imported"
+		return status
+
+	# The sidecar alone does not say the import is there: deleting the outputs under
+	# .godot/imported is the ordinary way to force one, and a resource whose output is gone was
+	# answered as current, which is what a reimport is then skipped on.
+	var outputs: Array[String] = _outputs_of(import_file_path)
+	var missing: Array[String] = []
+	for output: String in outputs:
+		if not FileAccess.file_exists(output):
+			missing.append(output)
+	if not missing.is_empty():
+		status["status"] = "needs_reimport"
+		status["reason"] = "its imported output is not on disk"
+		status["missing_outputs"] = missing
+		return status
+
+	# A scene imported before the textures it uses were: it loads each image as it imports, so one
+	# imported ahead of them is built without them, and nothing about its own files says so. A second
+	# reimport started over one in progress did exactly that downstream, and 64 scenes that were
+	# untextured all read as up to date here.
+	var built_at: int = _oldest(outputs, import_file_path)
+	var before: Array[String] = []
+	for image: String in _images_of(resource_path):
+		if FileAccess.file_exists(image + ".import"):
+			if _newest(_outputs_of(image + ".import"), image + ".import") > built_at:
+				before.append(image)
+	if not before.is_empty():
+		status["status"] = "needs_reimport"
+		status["reason"] = "it was imported before the images it uses, so it was built without them"
+		status["imported_before"] = before
+	return status
+
+
+## The files an import wrote, from its sidecar's [code]dest_files[/code]; empty when it lists none.
+static func _outputs_of(import_file_path: String) -> Array[String]:
+	var config: ConfigFile = ConfigFile.new()
+	var outputs: Array[String] = []
+	if config.load(import_file_path) != OK:
+		return outputs
+	var listed: Variant = config.get_value("deps", "dest_files", [])
+	if listed is Array:
+		for one: Variant in listed:
+			outputs.append(str(one))
+	return outputs
+
+
+## When the earliest of [param outputs] was written, or [param fallback] when none is on disk.
+static func _oldest(outputs: Array[String], fallback: String) -> int:
+	var oldest: int = -1
+	for output: String in outputs:
+		if FileAccess.file_exists(output):
+			var at: int = FileAccess.get_modified_time(output)
+			oldest = at if oldest < 0 else mini(oldest, at)
+	return oldest if oldest >= 0 else FileAccess.get_modified_time(fallback)
+
+
+## When the latest of [param outputs] was written, or [param fallback] when none is on disk.
+static func _newest(outputs: Array[String], fallback: String) -> int:
+	var newest: int = -1
+	for output: String in outputs:
+		if FileAccess.file_exists(output):
+			newest = maxi(newest, FileAccess.get_modified_time(output))
+	return newest if newest >= 0 else FileAccess.get_modified_time(fallback)
+
+
+## The image files a glTF scene refers to by path, resolved against the scene's own directory.
+## Embedded images and every other scene format answer nothing.
+static func _images_of(scene_path: String) -> Array[String]:
+	var images: Array[String] = []
+	var text: String = ""
+	match scene_path.get_extension().to_lower():
+		"gltf":
+			text = FileAccess.get_file_as_string(scene_path)
+		"glb":
+			# A 12-byte header, then the first chunk: its length, its type, and for "JSON" the text.
+			var bytes: PackedByteArray = FileAccess.get_file_as_bytes(scene_path)
+			if bytes.size() >= 20 and bytes.decode_u32(16) == 0x4E4F534A:
+				var length: int = bytes.decode_u32(12)
+				text = bytes.slice(20, mini(20 + length, bytes.size())).get_string_from_utf8()
+	if text.is_empty():
+		return images
+	var parsed: Variant = JSON.parse_string(text)
+	if not parsed is Dictionary:
+		return images
+	var document: Dictionary = parsed
+	var listed: Variant = document.get("images", [])
+	if not listed is Array:
+		return images
+	for image: Variant in listed:
+		if not image is Dictionary:
+			continue
+		var entry: Dictionary = image
+		var uri: String = str(entry.get("uri", ""))
+		if uri.is_empty() or uri.begins_with("data:"):
+			continue
+		images.append(scene_path.get_base_dir().path_join(uri.uri_decode()).simplify_path())
+	return images

package/build/index.js

@@ -30118,7 +30118,7 @@ var TOOL_SPECS = [
     requires: ["projectPath"],
     operations: {
       status: {
-        summary: "which resources are outdated or failed, or one resource with resourcePath",
+        summary: "which resources are outdated or failed, or one resource with resourcePath: a source changed since its import, an import whose output under .godot/imported is gone (missing_outputs), and a glTF scene imported before the images it uses (imported_before), each with its reason",
         requires: []
       },
       options: { summary: "the import options of one resource", requires: ["resourcePath"] },
@@ -30566,7 +30566,7 @@ var TOOL_SPECS = [
   },
   {
     name: "editor_rescan",
-    description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
+    description: "Makes the running editor scan the project filesystem, so files written outside it are picked up. A scan or an import the editor is already running is waited out first rather than scanned over, which would start a second import over it, and the answer says how long under waitedForEditorScanMs. The scan is a change-detecting walk rather than an unconditional reparse, so a file another engine has already imported reads as settled and the walk does not look inside it: its class_name then stays out of the list the editor resolves against, however many times you scan. Any class in that state is named under unseenByEditor, which is what no check on disk can see, since the declaration and the cache are both correct there and only the editor disagrees. The cure is this call on its own, with no change to the declaring script: measured against a real editor on three platforms, with idle waits of the same length ruled out so the scan is credited rather than the time it takes, and reproduced in a second project against its own reproduction in 203ms. editor_launch restart also does it and costs a window, and project_import refresh_classes does not: it rewrites the cache and does not touch what the editor is holding. A scan writes .godot/global_script_class_cache.cfg from the list the editor is holding, so a class the editor cannot resolve goes out of that file with it. That is not a reason to refuse the scan, because on a class the editor has merely not walked yet the scan is the cure; what the answer does instead is name the loss under cacheLost and rebuild the cache from the files, naming what came back under cacheRestored, so no fresh engine, CI run or clone inherits the short file. An editor that lost classes is still holding the short list, so the note says to restart it before scanning again. The other direction is guarded the same way: a class the editor still holds for a script that was renamed or deleted comes back into the cache at a path that is not there, and the next engine to read it fails on \"Could not parse global class\" in whichever correct script shares the bare name, so the cache is rebuilt without it and the answer names it under cacheDropped; the editor goes on holding it until it is restarted, and every scan until then ends in that rebuild. A script or shader written outside the editor has no .uid sidecar until something imports it, and the scan writes one beside it, which a project that commits sidecars needs before the commit. Needs the editor connected.",
     parameters: {
       projectPath: PROJECT_PATH,
       timeoutMs: {
@@ -34539,6 +34539,17 @@ class GodotServer {
     const nearest = descendantsIn(tree, root).filter((pid) => isEngine(pid) && !ancestorsIn(tree, pid, root).some((one) => one !== root && isEngine(one)));
     return nearest.length === 1 ? nearest[0] : undefined;
   }
+  async editorIsScanningOrImporting() {
+    if (!this.godotBridge.isConnected()) {
+      return false;
+    }
+    try {
+      const status = asParams(await this.godotBridge.invokeTool("scan_status", {}));
+      return status["scanning"] === true || status["importing"] === true;
+    } catch {
+      return false;
+    }
+  }
   async handleRescanFilesystem(args) {
     const timeoutMs = readPositiveNumber(args, "timeoutMs") ?? 30000;
     const started = Date.now();
@@ -34548,9 +34559,26 @@ class GodotServer {
     const blind = await this.classesTheEditorCannotSee(args);
     const atRisk = before === null ? [] : blind.unseen.filter((one) => before.has(one.className));
     const ghosts = blind.stillHeld ?? [];
-    const first = await this.handleViaBridge("rescan_filesystem", args);
-    if (first.isError) {
-      return first;
+    let waitedForEditorMs = 0;
+    let first;
+    for (;; ) {
+      const busySince = Date.now();
+      let wasBusy = false;
+      while (Date.now() - started < timeoutMs && await this.editorIsScanningOrImporting()) {
+        wasBusy = true;
+        await new Promise((settle) => setTimeout(settle, 100));
+      }
+      if (wasBusy) {
+        waitedForEditorMs += Date.now() - busySince;
+      }
+      first = await this.handleViaBridge("rescan_filesystem", args);
+      if (first.isError) {
+        return first;
+      }
+      const declined = asParams(JSON.parse(first.content[0]?.text ?? "{}"))["started"] === false;
+      if (!declined || Date.now() - started >= timeoutMs) {
+        break;
+      }
     }
     let busy = true;
     while (busy && Date.now() - started < timeoutMs) {
@@ -34609,6 +34637,7 @@ class GodotServer {
       ok: !busy && unseen.length === 0 && stillGone.length === 0 && stillAtMissingPaths.length === 0 && checked.unchecked === undefined,
       stillWorking: busy,
       waitedMs: Date.now() - started,
+      waitedForEditorScanMs: waitedForEditorMs > 0 ? waitedForEditorMs : undefined,
       heldBeforeReload: reloaded.heldBefore,
       reloadedMethods: reloaded.methods,
       reloadProblem: reloaded.problem,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gdharness",
-  "version": "1.1.0",
+  "version": "1.1.2",
   "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",