uloop-cli 0.64.0 → 0.65.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "uloop-cli",
-  "version": "0.64.0",
+  "version": "0.65.0",
   "//version": "x-release-please-version",
   "description": "CLI tool for Unity Editor communication via uLoopMCP",
   "main": "dist/cli.bundle.cjs",
@@ -42,13 +42,13 @@
   },
   "dependencies": {
     "commander": "14.0.3",
-    "launch-unity": "0.15.1",
+    "launch-unity": "0.16.0",
     "semver": "7.7.4"
   },
   "devDependencies": {
     "@eslint/js": "9.39.2",
     "@types/jest": "30.0.0",
-    "@types/node": "25.2.3",
+    "@types/node": "25.3.0",
     "@types/semver": "7.7.1",
     "esbuild": "0.27.3",
     "eslint": "9.39.2",
@@ -60,6 +60,6 @@
     "ts-jest": "29.4.6",
     "tsx": "4.21.0",
     "typescript": "5.9.3",
-    "typescript-eslint": "8.55.0"
+    "typescript-eslint": "8.56.0"
   }
 }

package/src/__tests__/cli-e2e.test.ts

@@ -7,7 +7,12 @@
  * @jest-environment node
  */
 
-import { execSync, ExecSyncOptionsWithStringEncoding } from 'child_process';
+import {
+  execSync,
+  ExecSyncOptionsWithStringEncoding,
+  spawnSync,
+  SpawnSyncOptionsWithStringEncoding,
+} from 'child_process';
 import { join } from 'path';
 
 const CLI_PATH = join(__dirname, '../..', 'dist/cli.bundle.cjs');
@@ -21,6 +26,13 @@ const EXEC_OPTIONS: ExecSyncOptionsWithStringEncoding = {
   stdio: ['pipe', 'pipe', 'pipe'],
 };
 
+const SPAWN_OPTIONS: SpawnSyncOptionsWithStringEncoding = {
+  encoding: 'utf-8',
+  timeout: 60000,
+  cwd: UNITY_PROJECT_ROOT,
+  stdio: 'pipe',
+};
+
 const INTERVAL_MS = 1500;
 const DOMAIN_RELOAD_RETRY_MS = 3000;
 const DOMAIN_RELOAD_MAX_RETRIES = 3;
@@ -54,6 +66,15 @@ function runCli(args: string): { stdout: string; stderr: string; exitCode: numbe
   }
 }
 
+function runCliParts(args: string[]): { stdout: string; stderr: string; exitCode: number } {
+  const result = spawnSync('node', [CLI_PATH, ...args], SPAWN_OPTIONS);
+  return {
+    stdout: result.stdout ?? '',
+    stderr: result.stderr ?? '',
+    exitCode: result.status ?? 1,
+  };
+}
+
 function runCliWithRetry(args: string): { stdout: string; stderr: string; exitCode: number } {
   for (let attempt = 0; attempt < DOMAIN_RELOAD_MAX_RETRIES; attempt++) {
     const result = runCli(args);
@@ -72,12 +93,44 @@ function runCliWithRetry(args: string): { stdout: string; stderr: string; exitCo
   return runCli(args);
 }
 
+function runCliWithRetryParts(args: string[]): {
+  stdout: string;
+  stderr: string;
+  exitCode: number;
+} {
+  for (let attempt = 0; attempt < DOMAIN_RELOAD_MAX_RETRIES; attempt++) {
+    const result = runCliParts(args);
+    const output = result.stderr || result.stdout;
+
+    if (result.exitCode === 0 || !isDomainReloadError(output)) {
+      return result;
+    }
+
+    if (attempt < DOMAIN_RELOAD_MAX_RETRIES - 1) {
+      sleepSync(DOMAIN_RELOAD_RETRY_MS);
+    }
+  }
+
+  return runCliParts(args);
+}
+
 function runCliJson<T>(args: string): T {
   const { stdout, stderr, exitCode } = runCliWithRetry(args);
   if (exitCode !== 0) {
     throw new Error(`CLI failed with exit code ${exitCode}: ${stderr || stdout}`);
   }
-  return JSON.parse(stdout) as T;
+
+  const trimmedOutput = stdout.trim();
+  const jsonStartByLine = trimmedOutput.lastIndexOf('\n{');
+  const jsonStart = jsonStartByLine >= 0 ? jsonStartByLine + 1 : trimmedOutput.indexOf('{');
+  const jsonEnd = trimmedOutput.lastIndexOf('}');
+
+  if (jsonStart < 0 || jsonEnd < 0 || jsonEnd < jsonStart) {
+    throw new Error(`JSON payload not found in CLI output: ${trimmedOutput}`);
+  }
+
+  const jsonPayload = trimmedOutput.slice(jsonStart, jsonEnd + 1);
+  return JSON.parse(jsonPayload) as T;
 }
 
 describe('CLI E2E Tests (requires running Unity)', () => {
@@ -97,6 +150,7 @@ describe('CLI E2E Tests (requires running Unity)', () => {
   describe('get-logs', () => {
     const TEST_LOG_MENU_PATH = 'uLoopMCP/Debug/LogGetter Tests/Output Test Logs';
     const MENU_ITEM_WAIT_MS = 1000;
+    const ERROR_FAMILY_PREFIX = 'CliE2EErrorFamily';
 
     function setupTestLogs(): void {
       runCliWithRetry('clear-console');
@@ -107,6 +161,38 @@ describe('CLI E2E Tests (requires running Unity)', () => {
       sleepSync(MENU_ITEM_WAIT_MS);
     }
 
+    function setupErrorFamilyLogs(token: string): void {
+      runCliWithRetry('clear-console');
+      const code = [
+        'using UnityEngine;',
+        'using System;',
+        `Debug.LogError("${ERROR_FAMILY_PREFIX}_Error_${token}");`,
+        `Debug.LogException(new InvalidOperationException("${ERROR_FAMILY_PREFIX}_Exception_${token}"));`,
+        `Debug.LogAssertion("${ERROR_FAMILY_PREFIX}_Assert_${token}");`,
+        `Debug.LogWarning("${ERROR_FAMILY_PREFIX}_Warning_${token}");`,
+      ].join(' ');
+      const result = runCliWithRetryParts(['execute-dynamic-code', '--code', code]);
+      if (result.exitCode !== 0) {
+        throw new Error(`execute-dynamic-code failed: ${result.stderr || result.stdout}`);
+      }
+      sleepSync(MENU_ITEM_WAIT_MS);
+    }
+
+    function setupAssertTextLogs(token: string): void {
+      runCliWithRetry('clear-console');
+      const code = [
+        'using UnityEngine;',
+        `Debug.Log("Please assert your identity ${token}");`,
+        `Debug.LogWarning("All assertions passed ${token}");`,
+        `Debug.LogError("${ERROR_FAMILY_PREFIX}_ErrorOnly_${token}");`,
+      ].join(' ');
+      const result = runCliWithRetryParts(['execute-dynamic-code', '--code', code]);
+      if (result.exitCode !== 0) {
+        throw new Error(`execute-dynamic-code failed: ${result.stderr || result.stdout}`);
+      }
+      sleepSync(MENU_ITEM_WAIT_MS);
+    }
+
     it('should retrieve test logs after executing Output Test Logs menu item', () => {
       setupTestLogs();
 
@@ -163,6 +249,64 @@ describe('CLI E2E Tests (requires running Unity)', () => {
       expect(messages.some((m) => m.includes('This is an error log'))).toBe(true);
     });
 
+    it('should filter by lowercase log type error', () => {
+      setupTestLogs();
+
+      const result = runCliJson<{ Logs: Array<{ Type: string; Message: string }> }>(
+        'get-logs --log-type error',
+      );
+
+      expect(result.Logs.length).toBeGreaterThan(0);
+      for (const log of result.Logs) {
+        expect(log.Type).toBe('Error');
+      }
+      const messages = result.Logs.map((log) => log.Message);
+      expect(messages.some((m) => m.includes('This is an error log'))).toBe(true);
+    });
+
+    it('should include error and exception logs in Error filter', () => {
+      const token = `${Date.now()}`;
+      setupErrorFamilyLogs(token);
+
+      const result = runCliJson<{ Logs: Array<{ Type: string; Message: string }> }>(
+        `get-logs --log-type Error --search-text "${token}" --max-count 20`,
+      );
+
+      expect(result.Logs.length).toBeGreaterThanOrEqual(2);
+      for (const log of result.Logs) {
+        expect(log.Type).toBe('Error');
+      }
+
+      const messages = result.Logs.map((log) => log.Message);
+      expect(messages.some((m) => m.includes(`${ERROR_FAMILY_PREFIX}_Error_${token}`))).toBe(true);
+      expect(messages.some((m) => m.includes(`${ERROR_FAMILY_PREFIX}_Exception_${token}`))).toBe(
+        true,
+      );
+      expect(messages.some((m) => m.includes(`${ERROR_FAMILY_PREFIX}_Warning_${token}`))).toBe(
+        false,
+      );
+    });
+
+    it('should not include plain assert text logs in Error filter', () => {
+      const token = `${Date.now()}`;
+      setupAssertTextLogs(token);
+
+      const result = runCliJson<{ Logs: Array<{ Type: string; Message: string }> }>(
+        `get-logs --log-type Error --search-text "${token}" --max-count 20`,
+      );
+
+      for (const log of result.Logs) {
+        expect(log.Type).toBe('Error');
+      }
+
+      const messages = result.Logs.map((log) => log.Message);
+      expect(messages.some((m) => m.includes(`${ERROR_FAMILY_PREFIX}_ErrorOnly_${token}`))).toBe(
+        true,
+      );
+      expect(messages.some((m) => m.includes(`Please assert your identity ${token}`))).toBe(false);
+      expect(messages.some((m) => m.includes(`All assertions passed ${token}`))).toBe(false);
+    });
+
     it('should search logs by text', () => {
       setupTestLogs();
 
@@ -487,7 +631,7 @@ describe('CLI E2E Tests (requires running Unity)', () => {
       const { stdout, exitCode } = runCli('launch --help');
 
       expect(exitCode).toBe(0);
-      expect(stdout).toContain('Launch Unity project');
+      expect(stdout).toContain('Open a Unity project');
       expect(stdout).toContain('--restart');
       expect(stdout).toContain('--platform');
       expect(stdout).toContain('--max-depth');

package/src/__tests__/execute-tool.test.ts

@@ -0,0 +1,31 @@
+import { isTransportDisconnectError } from '../execute-tool.js';
+
+describe('isTransportDisconnectError', () => {
+  it('returns true for UNITY_NO_RESPONSE', () => {
+    expect(isTransportDisconnectError(new Error('UNITY_NO_RESPONSE'))).toBe(true);
+  });
+
+  it('returns true for Connection lost with details', () => {
+    expect(isTransportDisconnectError(new Error('Connection lost: read ECONNRESET'))).toBe(true);
+  });
+
+  it('returns true for Connection lost with EPIPE', () => {
+    expect(isTransportDisconnectError(new Error('Connection lost: write EPIPE'))).toBe(true);
+  });
+
+  it('returns false for JSON-RPC error from Unity', () => {
+    expect(isTransportDisconnectError(new Error('Unity error: compilation failed'))).toBe(false);
+  });
+
+  it('returns false for connection refused (pre-dispatch error)', () => {
+    expect(isTransportDisconnectError(new Error('connect ECONNREFUSED 127.0.0.1:8711'))).toBe(
+      false,
+    );
+  });
+
+  it('returns false for non-Error values', () => {
+    expect(isTransportDisconnectError('UNITY_NO_RESPONSE')).toBe(false);
+    expect(isTransportDisconnectError(null)).toBe(false);
+    expect(isTransportDisconnectError(undefined)).toBe(false);
+  });
+});

package/src/cli.ts

@@ -756,6 +756,25 @@ function shouldSkipAutoSync(cmdName: string | undefined, args: string[]): boolea
   return args.some((arg) => (NO_SYNC_FLAGS as readonly string[]).includes(arg));
 }
 
+function extractSyncGlobalOptions(args: string[]): GlobalOptions {
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--port' || arg === '-p') {
+      const nextArg = args[i + 1];
+      if (nextArg !== undefined && !nextArg.startsWith('-')) {
+        return { port: nextArg };
+      }
+      continue;
+    }
+
+    if (arg.startsWith('--port=')) {
+      return { port: arg.slice('--port='.length) };
+    }
+  }
+
+  return {};
+}
+
 /**
  * Main entry point with auto-sync for unknown commands.
  */
@@ -766,6 +785,7 @@ async function main(): Promise<void> {
 
   const args = process.argv.slice(2);
   const cmdName = args.find((arg) => !arg.startsWith('-'));
+  const syncGlobalOptions = extractSyncGlobalOptions(args);
 
   if (!shouldSkipAutoSync(cmdName, args)) {
     // Check if cache version is outdated and auto-sync if needed
@@ -775,7 +795,7 @@ async function main(): Promise<void> {
         `\x1b[33mCache outdated (${cachedVersion} → ${VERSION}). Syncing tools from Unity...\x1b[0m`,
       );
       try {
-        await syncTools({});
+        await syncTools(syncGlobalOptions);
         console.log('\x1b[32m✓ Tools synced successfully.\x1b[0m\n');
       } catch (error) {
         const message = error instanceof Error ? error.message : String(error);
@@ -800,7 +820,7 @@ async function main(): Promise<void> {
   if (cmdName && !commandExists(cmdName)) {
     console.log(`\x1b[33mUnknown command '${cmdName}'. Syncing tools from Unity...\x1b[0m`);
     try {
-      await syncTools({});
+      await syncTools(syncGlobalOptions);
       const newCache = loadToolsCache();
       const tool = newCache.tools.find((t) => t.name === cmdName);
       if (tool) {

package/src/commands/launch.ts

@@ -14,6 +14,7 @@ import { orchestrateLaunch } from 'launch-unity';
 interface LaunchCommandOptions {
   restart?: boolean;
   quit?: boolean;
+  deleteRecovery?: boolean;
   platform?: string;
   maxDepth?: string;
   addUnityHub?: boolean;
@@ -30,6 +31,7 @@ export function registerLaunchCommand(program: Command): void {
     )
     .argument('[project-path]', 'Path to Unity project')
     .option('-r, --restart', 'Kill running Unity and restart')
+    .option('-d, --delete-recovery', 'Delete Assets/_Recovery before launch')
     .option('-q, --quit', 'Gracefully quit running Unity')
     .option('-p, --platform <platform>', 'Build target (e.g., Android, iOS)')
     .option('--max-depth <n>', 'Search depth when project-path is omitted', '3')
@@ -66,6 +68,7 @@ async function runLaunchCommand(
     unityArgs: [],
     restart: options.restart === true,
     quit: options.quit === true,
+    deleteRecovery: options.deleteRecovery === true,
     addUnityHub: options.addUnityHub === true,
     favoriteUnityHub: options.favorite === true,
   });

package/src/compile-helpers.ts

@@ -0,0 +1,291 @@
+/**
+ * Compile-related helpers duplicated from TypeScriptServer~ to avoid cross-project imports
+ * that violate CLI's rootDir boundary (TS6059).
+ *
+ * Source: TypeScriptServer~/src/compile/compile-domain-reload-helpers.ts
+ */
+
+// CLI tools output to console by design, object keys come from Unity tool responses which are trusted,
+// and lock file paths are constructed from trusted project root detection
+/* eslint-disable security/detect-object-injection, security/detect-non-literal-fs-filename */
+
+import assert from 'node:assert';
+import { existsSync, readFileSync } from 'fs';
+import * as net from 'net';
+import { join } from 'path';
+
+// Only alphanumeric, underscore, and hyphen — blocks path separators and traversal sequences
+const SAFE_REQUEST_ID_PATTERN: RegExp = /^[a-zA-Z0-9_-]+$/;
+
+export const COMPILE_FORCE_RECOMPILE_ARG_KEYS = [
+  'ForceRecompile',
+  'forceRecompile',
+  'force_recompile',
+  'force-recompile',
+] as const;
+
+export const COMPILE_WAIT_FOR_DOMAIN_RELOAD_ARG_KEYS = [
+  'WaitForDomainReload',
+  'waitForDomainReload',
+  'wait_for_domain_reload',
+  'wait-for-domain-reload',
+] as const;
+
+export interface CompileExecutionOptions {
+  forceRecompile: boolean;
+  waitForDomainReload: boolean;
+}
+
+export interface CompileCompletionWaitOptions {
+  projectRoot: string;
+  requestId: string;
+  timeoutMs: number;
+  pollIntervalMs: number;
+  unityPort?: number;
+  isUnityReadyWhenIdle?: () => Promise<boolean>;
+}
+
+export type CompileCompletionOutcome = 'completed' | 'timed_out';
+
+export interface CompileCompletionResult<T> {
+  outcome: CompileCompletionOutcome;
+  result?: T;
+}
+
+/**
+ * Between compilationFinished and beforeAssemblyReload, there is a brief gap (~50ms measured)
+ * where no lock files exist. This grace period prevents false "completed" detection during that gap.
+ */
+const LOCK_GRACE_PERIOD_MS = 500;
+
+const READINESS_CHECK_TIMEOUT_MS = 3000;
+const DEFAULT_HOST = '127.0.0.1';
+const CONTENT_LENGTH_HEADER = 'Content-Length:';
+const HEADER_SEPARATOR = '\r\n\r\n';
+
+function toBoolean(value: unknown): boolean {
+  if (typeof value === 'boolean') {
+    return value;
+  }
+
+  if (typeof value === 'string') {
+    return value.toLowerCase() === 'true';
+  }
+
+  return false;
+}
+
+function getCompileBooleanArg(args: Record<string, unknown>, keys: readonly string[]): boolean {
+  for (const key of keys) {
+    if (!(key in args)) {
+      continue;
+    }
+
+    return toBoolean(args[key]);
+  }
+
+  return false;
+}
+
+export function resolveCompileExecutionOptions(
+  args: Record<string, unknown>,
+): CompileExecutionOptions {
+  return {
+    forceRecompile: getCompileBooleanArg(args, COMPILE_FORCE_RECOMPILE_ARG_KEYS),
+    waitForDomainReload: getCompileBooleanArg(args, COMPILE_WAIT_FOR_DOMAIN_RELOAD_ARG_KEYS),
+  };
+}
+
+function createCompileRequestId(): string {
+  const timestamp = Date.now();
+  const randomToken = Math.floor(Math.random() * 1000000)
+    .toString()
+    .padStart(6, '0');
+  return `compile_${timestamp}_${randomToken}`;
+}
+
+export function ensureCompileRequestId(args: Record<string, unknown>): string {
+  const existingRequestId = args['RequestId'];
+  if (typeof existingRequestId === 'string' && existingRequestId.length > 0) {
+    if (SAFE_REQUEST_ID_PATTERN.test(existingRequestId)) {
+      return existingRequestId;
+    }
+  }
+
+  const requestId: string = createCompileRequestId();
+  args['RequestId'] = requestId;
+  return requestId;
+}
+
+function getCompileResultFilePath(projectRoot: string, requestId: string): string {
+  assert(
+    SAFE_REQUEST_ID_PATTERN.test(requestId),
+    `requestId contains unsafe characters: '${requestId}'`,
+  );
+  return join(projectRoot, 'Temp', 'uLoopMCP', 'compile-results', `${requestId}.json`);
+}
+
+function isUnityBusyByLockFiles(projectRoot: string): boolean {
+  const compilingLockPath = join(projectRoot, 'Temp', 'compiling.lock');
+  if (existsSync(compilingLockPath)) {
+    return true;
+  }
+
+  const domainReloadLockPath = join(projectRoot, 'Temp', 'domainreload.lock');
+  if (existsSync(domainReloadLockPath)) {
+    return true;
+  }
+
+  const serverStartingLockPath = join(projectRoot, 'Temp', 'serverstarting.lock');
+  return existsSync(serverStartingLockPath);
+}
+
+function stripUtf8Bom(content: string): string {
+  if (content.charCodeAt(0) === 0xfeff) {
+    return content.slice(1);
+  }
+
+  return content;
+}
+
+function tryReadCompileResult<T>(projectRoot: string, requestId: string): T | undefined {
+  const resultFilePath = getCompileResultFilePath(projectRoot, requestId);
+  if (!existsSync(resultFilePath)) {
+    return undefined;
+  }
+
+  try {
+    const content = readFileSync(resultFilePath, 'utf-8');
+    const parsed = JSON.parse(stripUtf8Bom(content)) as unknown;
+    return parsed as T;
+  } catch {
+    // File may be partially written by Unity or deleted between existsSync and readFileSync (TOCTOU).
+    // Return undefined so the polling loop retries on the next tick.
+    return undefined;
+  }
+}
+
+/**
+ * Verify Unity server can actually process a JSON-RPC request, not just accept TCP.
+ * Sends a lightweight get-tool-details request and waits for any valid framed response.
+ */
+function canSendRequestToUnity(port: number): Promise<boolean> {
+  return new Promise((resolve) => {
+    const socket = new net.Socket();
+    const timer = setTimeout(() => {
+      socket.destroy();
+      resolve(false);
+    }, READINESS_CHECK_TIMEOUT_MS);
+
+    const cleanup = (): void => {
+      clearTimeout(timer);
+      socket.destroy();
+    };
+
+    socket.connect(port, DEFAULT_HOST, () => {
+      const rpcRequest: string = JSON.stringify({
+        jsonrpc: '2.0',
+        method: 'get-tool-details',
+        params: { IncludeDevelopmentOnly: false },
+        id: 0,
+      });
+      const contentLength: number = Buffer.byteLength(rpcRequest, 'utf8');
+      const frame: string = `${CONTENT_LENGTH_HEADER} ${contentLength}${HEADER_SEPARATOR}${rpcRequest}`;
+      socket.write(frame);
+    });
+
+    let buffer: Buffer = Buffer.alloc(0);
+    socket.on('data', (chunk: Buffer) => {
+      buffer = Buffer.concat([buffer, chunk]);
+      const sepIndex: number = buffer.indexOf(HEADER_SEPARATOR);
+      if (sepIndex !== -1) {
+        cleanup();
+        resolve(true);
+      }
+    });
+
+    socket.on('error', () => {
+      cleanup();
+      resolve(false);
+    });
+
+    socket.on('close', () => {
+      clearTimeout(timer);
+      resolve(false);
+    });
+  });
+}
+
+export function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Wait until the compile result file exists AND all Unity lock files are gone.
+ * After the result file appears and locks disappear, waits an additional grace period
+ * to catch the gap between compilationFinished and beforeAssemblyReload (~50ms measured).
+ */
+export async function waitForCompileCompletion<T>(
+  options: CompileCompletionWaitOptions,
+): Promise<CompileCompletionResult<T>> {
+  const startTime: number = Date.now();
+  let idleSinceTimestamp: number | null = null;
+
+  while (Date.now() - startTime < options.timeoutMs) {
+    const result: T | undefined = tryReadCompileResult<T>(options.projectRoot, options.requestId);
+    const isBusy: boolean = isUnityBusyByLockFiles(options.projectRoot);
+
+    if (result !== undefined && !isBusy) {
+      const now: number = Date.now();
+      if (idleSinceTimestamp === null) {
+        idleSinceTimestamp = now;
+      }
+
+      const idleDuration: number = now - idleSinceTimestamp;
+      if (idleDuration >= LOCK_GRACE_PERIOD_MS) {
+        if (options.unityPort !== undefined) {
+          const isReady: boolean = await canSendRequestToUnity(options.unityPort);
+          if (isReady) {
+            return { outcome: 'completed', result };
+          }
+        } else if (options.isUnityReadyWhenIdle) {
+          const isReady: boolean = await options.isUnityReadyWhenIdle();
+          if (isReady) {
+            return { outcome: 'completed', result };
+          }
+        } else {
+          return { outcome: 'completed', result };
+        }
+      }
+    } else {
+      idleSinceTimestamp = null;
+    }
+
+    await sleep(options.pollIntervalMs);
+  }
+
+  const lastResult: T | undefined = tryReadCompileResult<T>(options.projectRoot, options.requestId);
+  if (lastResult !== undefined && !isUnityBusyByLockFiles(options.projectRoot)) {
+    // Guard the compilationFinished→beforeAssemblyReload gap, same as the main loop
+    await sleep(LOCK_GRACE_PERIOD_MS);
+    if (isUnityBusyByLockFiles(options.projectRoot)) {
+      return { outcome: 'timed_out' };
+    }
+
+    if (options.unityPort !== undefined) {
+      const isReady: boolean = await canSendRequestToUnity(options.unityPort);
+      if (isReady) {
+        return { outcome: 'completed', result: lastResult };
+      }
+    } else if (options.isUnityReadyWhenIdle) {
+      const isReady: boolean = await options.isUnityReadyWhenIdle();
+      if (isReady) {
+        return { outcome: 'completed', result: lastResult };
+      }
+    } else {
+      return { outcome: 'completed', result: lastResult };
+    }
+  }
+
+  return { outcome: 'timed_out' };
+}

package/src/default-tools.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.64.0",
+  "version": "0.65.0",
   "tools": [
     {
       "name": "compile",
@@ -10,6 +10,10 @@
           "ForceRecompile": {
             "type": "boolean",
             "description": "Force full recompilation"
+          },
+          "WaitForDomainReload": {
+            "type": "boolean",
+            "description": "Wait for domain reload completion before returning"
           }
         }
       }