unity-mcp-cli: auto-dismiss Unity Editor "compile errors at launch" dialog so the resolver can run (Win/macOS/Linux) (#738)

feat(cli): auto-dismiss Unity Editor launch-errors dialog. Pass-1 simplify: abort-signal + grace-window early-exit, recurrence-aware loop, Unity-PID scoping on Linux, regex-escape, parser hardened, permanent-error bailout, interval 500->1500ms. Pass-2 simplify: drop in-flight probe outcomes when abort fires mid-await, gate timeout warning on deadline-not-abort, extract producer-side prefix constants. Pass-3 review returned [none]. 346/347 CLI tests pass.

Closes #737

Author: IvanMurzak

cli/README.md

@@ -255,8 +255,21 @@ cd ./MyGame && unity-mcp-cli open
 | `--tools <names>` | `UNITY_MCP_TOOLS` | No | Comma-separated list of tools to enable |
 | `--transport <method>` | `UNITY_MCP_TRANSPORT` | No | Transport method: `streamableHttp` or `stdio` |
 | `--start-server <value>` | `UNITY_MCP_START_SERVER` | No | Set to `true` or `false` to control MCP server auto-start |
+| `--no-auto-dismiss-launch-errors` | — | No | Disable auto-dismissal of the Unity Editor "compile errors at launch" dialog (default: enabled) |
+| `--launch-dismiss-timeout-ms <ms>` | — | No | Overall timeout (milliseconds) for the launch-errors auto-dismiss polling loop (default: `30000`) |
+| `--launch-dismiss-poll-interval-ms <ms>` | — | No | Polling tick interval (milliseconds) for the launch-errors auto-dismiss loop (default: `1500`) |
 
-The editor process is spawned in detached mode — the CLI returns immediately.
+The editor process is spawned in detached mode. By default, after spawning the editor, `open` polls for Unity's "compile errors at launch" dialog and clicks `Ignore` so the editor finishes initialising — without this, any in-Editor automation that needs to run after a state where Unity itself can't compile (e.g. the NuGet dependency resolver) cannot self-heal. The dialog appears within seconds of editor launch when it appears at all, so when no dialog has been seen within a short grace window after polling starts the loop exits early — the no-dialog case adds at most that grace window's delay, never the full `--launch-dismiss-timeout-ms`. If the dialog is observed (and successfully dismissed), polling continues until the overall timeout so a re-appearing dialog (resolver fixes one error → dialog re-surfaces with the next) is dismissed again. Library-mode callers can supply an `AbortSignal` (`launchDismissAbortSignal` on `OpenProjectOptions`) to abort the loop the instant their own readiness signal fires.
+
+### Auto-dismiss platform requirements
+
+| Platform | Requirement | Notes |
+|---|---|---|
+| **Windows** | Built-in (Win32 API) | Uses `EnumWindows` / `EnumChildWindows` / `SendMessageW(BM_CLICK)` driven from PowerShell. No extra setup required. |
+| **macOS** | **Accessibility permission** must be granted to the terminal (or `unity-mcp-cli` binary). System Settings → Privacy & Security → Accessibility. | Implemented via AppleScript / `osascript`. Without this permission, `osascript` reports an error every poll tick and the dialog cannot be dismissed. |
+| **Linux/X11** | `xdotool` on `PATH` (e.g. `sudo apt-get install xdotool`). | Wayland is **not** supported in the first cut — track upstream issues for Wayland support. |
+
+To opt out entirely, pass `--no-auto-dismiss-launch-errors`.
 
 **Example — open with MCP connection:**
 

cli/src/commands/open.ts

@@ -40,6 +40,41 @@ export function resolveOpenProjectPath(
 /** Re-export for backward compatibility with existing tests. */
 export const isUnityProjectDir = libIsUnityProjectDir;
 
+/**
+ * Parse a `--xxx <ms>` style commander option as a positive integer.
+ * Commander stores the raw string (including the literal default
+ * supplied to `.option()`), so a parse-and-validate step is required
+ * before the value can flow into the library. Exits with code 1 on
+ * a non-numeric / non-positive value — matches the CLI's existing
+ * error-handling pattern for malformed flag values (`--auth`,
+ * `--transport`, `--start-server`).
+ *
+ * Exported for unit tests; the CLI wrapper is the only production
+ * caller.
+ */
+export function parsePositiveIntFlag(
+  raw: string | undefined,
+  flagName: string,
+  fallback: number,
+): number {
+  if (raw === undefined) return fallback;
+  const trimmed = String(raw).trim();
+  if (trimmed === '') return fallback;
+  // Reject scientific notation, fractions, and explicit signs — the
+  // ms value MUST be a positive whole number for the polling loop's
+  // bookkeeping to be sane.
+  if (!/^\d+$/.test(trimmed)) {
+    ui.error(`${flagName} must be a positive integer (got: "${raw}")`);
+    process.exit(1);
+  }
+  const parsed = parseInt(trimmed, 10);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    ui.error(`${flagName} must be a positive integer (got: "${raw}")`);
+    process.exit(1);
+  }
+  return parsed;
+}
+
 /**
  * Print actionable help when a required Unity Editor version is not found.
  * Lists installed editors and suggests install or override commands. Lives
@@ -92,6 +127,20 @@ export const openCommand = new Command('open')
   .option('--keep-connected', 'Force keep connected (sets UNITY_MCP_KEEP_CONNECTED=true)')
   .option('--transport <method>', 'Transport method: streamableHttp or stdio (sets UNITY_MCP_TRANSPORT)')
   .option('--start-server <value>', 'Set to true/false to control server auto-start (sets UNITY_MCP_START_SERVER)', undefined)
+  .option(
+    '--no-auto-dismiss-launch-errors',
+    'Disable auto-dismissal of the Unity Editor "compile errors at launch" dialog (default: enabled). On macOS, requires Accessibility permission for the terminal / unity-mcp-cli binary. On Linux/X11, requires `xdotool` on PATH (Wayland not supported).',
+  )
+  .option(
+    '--launch-dismiss-timeout-ms <ms>',
+    'Overall timeout (milliseconds) for the launch-errors auto-dismiss polling loop (default: 30000)',
+    '30000',
+  )
+  .option(
+    '--launch-dismiss-poll-interval-ms <ms>',
+    'Polling tick interval (milliseconds) for the launch-errors auto-dismiss loop (default: 1500)',
+    '1500',
+  )
   .action(async (positionalPath: string | undefined, options: {
     path?: string;
     unity?: string;
@@ -103,6 +152,9 @@ export const openCommand = new Command('open')
     keepConnected?: boolean;
     transport?: string;
     startServer?: string;
+    autoDismissLaunchErrors?: boolean;
+    launchDismissTimeoutMs?: string;
+    launchDismissPollIntervalMs?: string;
   }) => {
     // Resolve the path the same way the library does, but also
     // validate the existence + Unity-project shape up front so we
@@ -159,6 +211,25 @@ export const openCommand = new Command('open')
       startServerBool = val === 'true';
     }
 
+    // --launch-dismiss-timeout-ms / --launch-dismiss-poll-interval-ms
+    // are commander string options with numeric defaults. Parse and
+    // validate here so the failure mode is a clear CLI error rather
+    // than a silent NaN that disables the polling loop.
+    const launchDismissTimeoutMs = parsePositiveIntFlag(
+      options.launchDismissTimeoutMs,
+      '--launch-dismiss-timeout-ms',
+      30000,
+    );
+    const launchDismissPollIntervalMs = parsePositiveIntFlag(
+      options.launchDismissPollIntervalMs,
+      '--launch-dismiss-poll-interval-ms',
+      1500,
+    );
+    // Commander's `--no-auto-dismiss-launch-errors` produces
+    // `autoDismissLaunchErrors: false`; the absence of the flag
+    // produces `undefined` (which `openProject` treats as the default
+    // `true`). No additional parsing needed.
+
     // Pre-flight already-running check so we don't flash the
     // "Locating Unity Editor..." spinner when Unity is already open
     // for this project. The lib does its own check too (single
@@ -183,6 +254,9 @@ export const openCommand = new Command('open')
       keepConnected: options.keepConnected,
       transport: options.transport as OpenProjectTransport | undefined,
       startServer: startServerBool,
+      autoDismissLaunchErrors: options.autoDismissLaunchErrors !== false,
+      launchDismissTimeoutMs,
+      launchDismissPollIntervalMs,
       onProgress: (event) => {
         switch (event.phase) {
           case 'detecting-editor-version': {
@@ -234,6 +308,15 @@ export const openCommand = new Command('open')
             ui.success(`Launched Unity Editor (PID: ${event.pid ?? 'unknown'})`);
             break;
           }
+          case 'launch-errors-dismissed': {
+            // Single info-level log line on dismissal — exact format
+            // is part of the issue's acceptance contract. Keep in
+            // sync with `launch-error-dismiss.ts` if changed.
+            ui.info(
+              `[open] dismissed Unity launch-errors dialog (button=${event.button}, platform=${event.platform})`,
+            );
+            break;
+          }
           default:
             break;
         }