gdharness 1.1.5 → 1.1.7

package/build/keeper.js

@@ -2,7 +2,210 @@
 
 // src/keeper.ts
 import { spawn } from "node:child_process";
-import { closeSync, openSync as openSync2 } from "node:fs";
+import { closeSync, existsSync, mkdtempSync, openSync as openSync2, readFileSync as readFileSync2, rmSync as rmSync2 } from "node:fs";
+import { tmpdir as tmpdir2 } from "node:os";
+import { join as join3 } from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+
+// src/desktop.ts
+import { createHash } from "node:crypto";
+var SOURCE = `using System;
+using System.ComponentModel;
+using System.IO;
+using System.Runtime.InteropServices;
+using System.Text;
+
+public static class GdharnessDesktop {
+  const uint GenericAll = 0x10000000;
+  const int UseStdHandles = 0x100;
+  const int UseShowWindow = 0x1;
+  const short ShowNoActivate = 4;
+  // No console at all, rather than a hidden one: a console's host would sit on the desktop too.
+  const uint DetachedProcess = 0x00000008;
+  const uint Infinite = 0xFFFFFFFF;
+
+  [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
+  struct StartupInfo {
+    public int cb;
+    public string reserved;
+    public string desktop;
+    public string title;
+    public int x, y, xSize, ySize, xCount, yCount, fill, flags;
+    public short show, reservedSize;
+    public IntPtr reservedBytes, input, output, error;
+  }
+
+  [StructLayout(LayoutKind.Sequential)]
+  struct Started {
+    public IntPtr process, thread;
+    public int processId, threadId;
+  }
+
+  [DllImport("user32.dll", SetLastError = true, CharSet = CharSet.Unicode)]
+  static extern IntPtr CreateDesktopW(string name, IntPtr device, IntPtr mode, uint flags, uint access, IntPtr attributes);
+
+  [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);
+
+  [DllImport("kernel32.dll")] static extern IntPtr GetStdHandle(int which);
+  [DllImport("kernel32.dll")] static extern uint WaitForSingleObject(IntPtr handle, uint milliseconds);
+  [DllImport("kernel32.dll")] static extern bool GetExitCodeProcess(IntPtr handle, out uint code);
+  [DllImport("kernel32.dll")] static extern bool CloseHandle(IntPtr handle);
+
+  delegate bool EachWindow(IntPtr window, IntPtr unused);
+  [DllImport("user32.dll")] static extern bool EnumWindows(EachWindow each, IntPtr unused);
+  [DllImport("user32.dll")] static extern bool IsWindowVisible(IntPtr window);
+  [DllImport("user32.dll")] static extern uint GetWindowThreadProcessId(IntPtr window, out uint processId);
+  [DllImport("user32.dll")] static extern bool LockSetForegroundWindow(uint code);
+  const uint LockForeground = 1;
+  const uint UnlockForeground = 2;
+  const uint TimedOut = 0x102;
+
+  static bool ShowsAWindow(int processId) {
+    bool shown = false;
+    EnumWindows(delegate(IntPtr window, IntPtr unused) {
+      uint owner;
+      GetWindowThreadProcessId(window, out owner);
+      if (owner == (uint)processId && IsWindowVisible(window)) {
+        shown = true;
+        return false;
+      }
+      return true;
+    }, IntPtr.Zero);
+    return shown;
+  }
+
+  // Keeps the foreground where it is while the process starts: its own call to take it fails while
+  // the foreground is locked, and the user's own Alt+Tab or click still moves it. Released once its
+  // window has been showing for a while, since a program takes the foreground as it shows its window
+  // and not afterwards, or when it exits, or after two minutes whatever happens.
+  static void HoldTheForeground(Started started) {
+    DateTime until = DateTime.UtcNow.AddMinutes(2);
+    DateTime? shownAt = null;
+    while (DateTime.UtcNow < until) {
+      if (WaitForSingleObject(started.process, 100) != TimedOut) {
+        return;
+      }
+      if (shownAt == null && ShowsAWindow(started.processId)) {
+        shownAt = DateTime.UtcNow;
+      }
+      if (shownAt != null && DateTime.UtcNow - shownAt.Value > TimeSpan.FromSeconds(10)) {
+        return;
+      }
+    }
+  }
+
+  // Starts the command line, both of its streams on this process's output, writes its pid, and
+  // waits for it: the answer is its exit code. On the named desktop when there is one, whose handle
+  // is held until then, since a desktop goes when the last handle to it does, and on this process's
+  // own otherwise. With noActivate its first window is shown without being activated, which is
+  // what a program's first ShowWindow does whatever it asks for when the start names a show state,
+  // and the foreground is held while it starts, since Godot also asks for it outright.
+  public static int Run(string desktop, string commandLine, string pidFile, bool noActivate) {
+    StartupInfo startup = new StartupInfo();
+    startup.cb = Marshal.SizeOf(typeof(StartupInfo));
+    if (desktop.Length > 0) {
+      IntPtr held = CreateDesktopW(desktop, IntPtr.Zero, IntPtr.Zero, 0, GenericAll, IntPtr.Zero);
+      if (held == IntPtr.Zero) {
+        throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateDesktopW " + desktop);
+      }
+      startup.desktop = desktop;
+    }
+    startup.flags = UseStdHandles;
+    if (noActivate) {
+      startup.flags |= UseShowWindow;
+      startup.show = ShowNoActivate;
+    }
+    startup.input = GetStdHandle(-10);
+    startup.output = GetStdHandle(-11);
+    startup.error = startup.output;
+    Started started;
+    if (noActivate) {
+      LockSetForegroundWindow(LockForeground);
+    }
+    try {
+    if (!CreateProcessW(null, new StringBuilder(commandLine), IntPtr.Zero, IntPtr.Zero, true, DetachedProcess, IntPtr.Zero, null, ref startup, out started)) {
+      throw new Win32Exception(Marshal.GetLastWin32Error(), "CreateProcessW " + commandLine);
+    }
+    File.WriteAllText(pidFile, started.processId.ToString());
+    if (noActivate) {
+      HoldTheForeground(started);
+    }
+    } finally {
+      if (noActivate) {
+        LockSetForegroundWindow(UnlockForeground);
+      }
+    }
+    WaitForSingleObject(started.process, Infinite);
+    uint code;
+    GetExitCodeProcess(started.process, out code);
+    CloseHandle(started.thread);
+    CloseHandle(started.process);
+    return unchecked((int)code);
+  }
+}
+`;
+function quoted(argument) {
+  if (argument !== "" && !/[\s"]/.test(argument)) {
+    return argument;
+  }
+  let text = '"';
+  let backslashes = 0;
+  for (const character of argument) {
+    if (character === "\\") {
+      backslashes += 1;
+      continue;
+    }
+    text += character === '"' ? `${"\\".repeat(backslashes * 2 + 1)}"` : `${"\\".repeat(backslashes)}${character}`;
+    backslashes = 0;
+  }
+  return `${text}${"\\".repeat(backslashes * 2)}"`;
+}
+function windowsCommandLine(command, args) {
+  return [command, ...args].map(quoted).join(" ");
+}
+function throughHelper(how, command, args, pidFile, errorFile) {
+  const spec = {
+    desktop: how.desktop ?? "",
+    noActivate: how.noActivate === true,
+    commandLine: windowsCommandLine(command, args),
+    pidFile,
+    errorFile,
+    source: SOURCE,
+    digest: createHash("sha256").update(SOURCE).digest("hex").slice(0, 16)
+  };
+  const encoded = Buffer.from(JSON.stringify(spec), "utf8").toString("base64");
+  const script = [
+    "$ErrorActionPreference = 'Stop'",
+    `$spec = [Text.Encoding]::UTF8.GetString([Convert]::FromBase64String('${encoded}')) | ConvertFrom-Json`,
+    "try {",
+    "  $assembly = Join-Path ([IO.Path]::GetTempPath()) ('gdharness-desktop-' + $spec.digest + '.dll')",
+    "  if (-not (Test-Path -LiteralPath $assembly)) {",
+    '    $partial = "$assembly.$PID"',
+    "    Add-Type -TypeDefinition $spec.source -OutputAssembly $partial",
+    "    try { Move-Item -LiteralPath $partial -Destination $assembly } catch { Remove-Item -LiteralPath $partial -ErrorAction SilentlyContinue }",
+    "  }",
+    "  Add-Type -LiteralPath $assembly",
+    "  $code = [GdharnessDesktop]::Run($spec.desktop, $spec.commandLine, $spec.pidFile, [bool]$spec.noActivate)",
+    "} catch {",
+    "  [IO.File]::WriteAllText($spec.errorFile, $_.Exception.Message)",
+    "  exit 1",
+    "}",
+    "exit $code"
+  ].join(`
+`);
+  return {
+    command: "powershell.exe",
+    args: [
+      "-NoProfile",
+      "-NonInteractive",
+      "-ExecutionPolicy",
+      "Bypass",
+      "-EncodedCommand",
+      Buffer.from(script, "utf16le").toString("base64")
+    ]
+  };
+}
 
 // src/outside.ts
 import { fileURLToPath } from "node:url";
@@ -39,7 +242,7 @@ function readLaunched(printed) {
 }
 
 // src/run-record.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import {
   mkdirSync,
   openSync,
@@ -104,7 +307,7 @@ function realAsFarAsItExists(path) {
 function projectKey(projectPath) {
   const real = realAsFarAsItExists(resolve2(projectPath)).replace(/[\\/]+$/, "");
   const folded = process.platform === "win32" || process.platform === "darwin" ? real.toLowerCase() : real;
-  return createHash("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
+  return createHash2("sha256").update(folded.replaceAll("\\", "/")).digest("hex").slice(0, 16);
 }
 function runRecordPath(projectPath, directory = runtimeDirectory()) {
   return join2(directory, "runs", `note-${projectKey(projectPath)}.json`);
@@ -159,11 +362,12 @@ function recordAt(path) {
 }
 
 // src/keeper.ts
-async function startDetached(spec, output) {
+async function startDirectly(spec, output, hidden, detached = true, errors = output) {
   return await new Promise((resolve) => {
     const child = spawn(spec.command, [...spec.args], {
-      stdio: ["ignore", output, output],
-      detached: true,
+      stdio: ["ignore", output, errors],
+      detached,
+      windowsHide: hidden,
       env: withChanges(process.env, spec.envChanges)
     });
     child.once("error", (error) => {
@@ -174,10 +378,49 @@ async function startDetached(spec, output) {
     });
   });
 }
+async function startThroughHelper(spec, output) {
+  const scratch = mkdtempSync(join3(tmpdir2(), "gdharness-desktop-"));
+  const pidFile = join3(scratch, "pid");
+  const errorFile = join3(scratch, "error");
+  const where = spec.desktop === undefined ? "without activation" : `on the ${spec.desktop} desktop`;
+  try {
+    const wrapper = throughHelper(spec, spec.command, spec.args, pidFile, errorFile);
+    const started = await startDirectly({ ...spec, command: wrapper.command, args: wrapper.args }, output, true, false, "ignore");
+    if ("error" in started) {
+      return started;
+    }
+    const exited = { now: false };
+    started.child.once("exit", () => {
+      exited.now = true;
+    });
+    for (let waited = 0;waited < DESKTOP_START_MS; waited += 50) {
+      const pid = existsSync(pidFile) ? Number(readFileSync2(pidFile, "utf8").trim()) : Number.NaN;
+      if (Number.isInteger(pid) && pid > 0) {
+        return { child: started.child, pid };
+      }
+      if (exited.now) {
+        const why = existsSync(errorFile) ? readFileSync2(errorFile, "utf8").trim() : "it exited saying nothing";
+        return { error: `it could not be started ${where}: ${why}` };
+      }
+      await delay(50);
+    }
+    started.child.kill();
+    return { error: `it was not started ${where} within ${DESKTOP_START_MS} ms` };
+  } finally {
+    rmSync2(scratch, { recursive: true, force: true });
+  }
+}
+var DESKTOP_START_MS = 60000;
+async function startDetached(spec, output, hidden) {
+  return process.platform === "win32" && (spec.desktop !== undefined || spec.noActivate === true) ? await startThroughHelper(spec, output) : await startDirectly(spec, output, hidden);
+}
+function needsItsHelperKept(spec) {
+  return process.platform === "win32" && (spec.desktop !== undefined || spec.noActivate === true);
+}
 async function launch() {
   const spec = await receivedSpec();
-  if (spec.run === undefined) {
-    const started = await startDetached(spec, "ignore");
+  if (spec.run === undefined && !needsItsHelperKept(spec)) {
+    const started = await startDetached(spec, "ignore", true);
     if ("error" in started) {
       process.stdout.write(`error ${started.error}
 `);
@@ -225,18 +468,20 @@ async function launch() {
 }
 async function keep() {
   const spec = await receivedSpec();
-  if (spec.run === undefined) {
-    process.stdout.write(`error a keeper was started without a run
+  const run = spec.run;
+  if (run === undefined && !needsItsHelperKept(spec)) {
+    process.stdout.write(`error a keeper was started without a run or a helper to keep
 `);
     process.exit(1);
   }
-  const run = spec.run;
-  const transcript = openSync2(run.transcript, "a");
+  const transcript = run === undefined ? "ignore" : openSync2(run.transcript, "a");
   let started;
   try {
-    started = await startDetached(spec, transcript);
+    started = await startDetached(spec, transcript, run === undefined);
   } finally {
-    closeSync(transcript);
+    if (transcript !== "ignore") {
+      closeSync(transcript);
+    }
   }
   if ("error" in started) {
     process.stdout.write(`error ${started.error}
@@ -244,16 +489,20 @@ async function keep() {
     process.exit(1);
   }
   const { child, pid } = started;
-  writeRunRecord({
-    pid,
-    transcript: run.transcript,
-    startedAt: run.startedAt,
-    projectPath: run.projectPath,
-    arguments: spec.args,
-    command: spec.command
-  });
+  if (run !== undefined) {
+    writeRunRecord({
+      pid,
+      transcript: run.transcript,
+      startedAt: run.startedAt,
+      projectPath: run.projectPath,
+      arguments: spec.args,
+      command: spec.command
+    });
+  }
   child.once("exit", (code, signal) => {
-    recordRunEnded(run.projectPath, pid, { exitCode: code, exitSignal: code === null ? signal : null });
+    if (run !== undefined) {
+      recordRunEnded(run.projectPath, pid, { exitCode: code, exitSignal: code === null ? signal : null });
+    }
     process.exit(0);
   });
   process.stdout.write(`pid ${pid}

package/package.json

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