gdharness 1.1.0 → 1.1.1

package/build/cli.js

@@ -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/index.js

@@ -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.1",
   "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",