uloop-cli 0.68.2 → 0.69.0

package/src/cli.ts

@@ -12,7 +12,7 @@ import { existsSync, readFileSync, writeFileSync, mkdirSync, unlinkSync } from '
 import { join, basename, dirname } from 'path';
 import { homedir } from 'os';
 import { spawn } from 'child_process';
-import { Command } from 'commander';
+import { Command, Option } from 'commander';
 import {
   executeToolCommand,
   listAvailableTools,
@@ -24,6 +24,7 @@ import {
   loadToolsCache,
   hasCacheFile,
   getDefaultTools,
+  getDefaultToolNames,
   ToolDefinition,
   ToolProperty,
   getCachedServerVersion,
@@ -34,7 +35,8 @@ import { registerLaunchCommand } from './commands/launch.js';
 import { registerFocusWindowCommand } from './commands/focus-window.js';
 import { VERSION } from './version.js';
 import { findUnityProjectRoot } from './project-root.js';
-import { validateProjectPath } from './port-resolver.js';
+import { validateProjectPath, UnityNotRunningError } from './port-resolver.js';
+import { ProjectMismatchError } from './project-validator.js';
 import { filterEnabledTools, isToolEnabled } from './tool-settings-loader.js';
 
 interface CliOptions extends GlobalOptions {
@@ -45,6 +47,16 @@ const FOCUS_WINDOW_COMMAND = 'focus-window' as const;
 const LAUNCH_COMMAND = 'launch' as const;
 const UPDATE_COMMAND = 'update' as const;
 
+const HELP_GROUP_BUILTIN_TOOLS = 'Built-in Tools:' as const;
+const HELP_GROUP_THIRD_PARTY_TOOLS = 'Third-party Tools:' as const;
+const HELP_GROUP_CLI_COMMANDS = 'CLI Commands:' as const;
+
+const HELP_GROUP_ORDER = [
+  HELP_GROUP_CLI_COMMANDS,
+  HELP_GROUP_BUILTIN_TOOLS,
+  HELP_GROUP_THIRD_PARTY_TOOLS,
+] as const;
+
 // commander.js built-in flags that exit immediately without needing Unity
 const NO_SYNC_FLAGS = ['-v', '--version', '-h', '--help'] as const;
 
@@ -66,7 +78,44 @@ program
   .description('Unity MCP CLI - Direct communication with Unity Editor')
   .version(VERSION, '-v, --version', 'Output the version number')
   .showHelpAfterError('(run with -h for available options)')
-  .configureHelp({ sortSubcommands: true });
+  .configureHelp({
+    sortSubcommands: true,
+    // commander.js default groupItems determines group display order by registration order,
+    // but CLI commands are registered at module level (before tools), so the default order
+    // would be wrong. We re-implement to enforce HELP_GROUP_ORDER.
+    groupItems<T extends Command | Option>(
+      unsortedItems: T[],
+      visibleItems: T[],
+      getGroup: (item: T) => string,
+    ): Map<string, T[]> {
+      const groupMap = new Map<string, T[]>();
+      for (const item of unsortedItems) {
+        const group: string = getGroup(item);
+        if (!groupMap.has(group)) {
+          groupMap.set(group, []);
+        }
+      }
+      for (const item of visibleItems) {
+        const group: string = getGroup(item);
+        if (!groupMap.has(group)) {
+          groupMap.set(group, []);
+        }
+        groupMap.get(group)!.push(item);
+      }
+      const ordered = new Map<string, T[]>();
+      for (const key of HELP_GROUP_ORDER) {
+        const items: T[] | undefined = groupMap.get(key);
+        if (items !== undefined) {
+          ordered.set(key, items);
+          groupMap.delete(key);
+        }
+      }
+      for (const [key, value] of groupMap) {
+        ordered.set(key, value);
+      }
+      return ordered;
+    },
+  });
 
 // --list-commands: Output command names for shell completion
 program.option('--list-commands', 'List all command names (for shell completion)');
@@ -74,6 +123,12 @@ program.option('--list-commands', 'List all command names (for shell completion)
 // --list-options <cmd>: Output options for a specific command (for shell completion)
 program.option('--list-options <cmd>', 'List options for a command (for shell completion)');
 
+// Set default help group for CLI commands registered at module level
+program.commandsGroup(HELP_GROUP_CLI_COMMANDS);
+// Eagerly initialize the implicit help command so it inherits the CLI Commands group.
+// Without this, the lazy-created help command skips _initCommandGroup and falls into "Commands:" group.
+program.helpCommand(true);
+
 // Built-in commands (not from tools.json)
 program
   .command('list')
@@ -132,12 +187,13 @@ registerLaunchCommand(program);
 /**
  * Register a tool as a CLI command dynamically.
  */
-function registerToolCommand(tool: ToolDefinition): void {
+function registerToolCommand(tool: ToolDefinition, helpGroup: string): void {
   // Skip if already registered as a built-in command
   if (BUILTIN_COMMANDS.includes(tool.name as (typeof BUILTIN_COMMANDS)[number])) {
     return;
   }
-  const cmd = program.command(tool.name).description(tool.description);
+  const firstLine: string = tool.description.split('\n')[0];
+  const cmd = program.command(tool.name).description(firstLine).helpGroup(helpGroup);
 
   // Add options from inputSchema.properties
   const properties = tool.inputSchema.properties;
@@ -304,6 +360,10 @@ function convertValue(value: unknown, propInfo: ToolProperty): unknown {
   return value;
 }
 
+function getToolHelpGroup(toolName: string, defaultToolNames: ReadonlySet<string>): string {
+  return defaultToolNames.has(toolName) ? HELP_GROUP_BUILTIN_TOOLS : HELP_GROUP_THIRD_PARTY_TOOLS;
+}
+
 function extractGlobalOptions(options: Record<string, unknown>): GlobalOptions {
   return {
     port: options['port'] as string | undefined,
@@ -363,6 +423,28 @@ async function runWithErrorHandling(fn: () => Promise<void>): Promise<void> {
   try {
     await fn();
   } catch (error) {
+    if (error instanceof UnityNotRunningError) {
+      console.error('\x1b[31mError: Unity Editor for this project is not running.\x1b[0m');
+      console.error('');
+      console.error(`  Project: ${error.projectRoot}`);
+      console.error('');
+      console.error('Start the Unity Editor for this project and try again.');
+      process.exit(1);
+    }
+
+    if (error instanceof ProjectMismatchError) {
+      console.error('\x1b[31mError: Unity Editor for this project is not running.\x1b[0m');
+      console.error('');
+      console.error(`  Project:      ${error.expectedProjectRoot}`);
+      console.error(`  Connected to: ${error.connectedProjectRoot}`);
+      console.error('');
+      console.error('Another Unity instance was found, but it belongs to a different project.');
+      console.error(
+        'Start the Unity Editor for this project, or use --port to specify the target.',
+      );
+      process.exit(1);
+    }
+
     const message = error instanceof Error ? error.message : String(error);
 
     // Unity busy states have clear causes - no version diagnostic needed
@@ -788,6 +870,26 @@ function shouldSkipAutoSync(cmdName: string | undefined, args: string[]): boolea
   return args.some((arg) => (NO_SYNC_FLAGS as readonly string[]).includes(arg));
 }
 
+// Options that consume the next argument as a value
+const OPTIONS_WITH_VALUE: ReadonlySet<string> = new Set(['--port', '-p', '--project-path']);
+
+/**
+ * Find the first non-option argument that is not a value of a known option.
+ */
+function findCommandName(args: readonly string[]): string | undefined {
+  for (let i = 0; i < args.length; i++) {
+    const arg: string = args[i];
+    if (arg.startsWith('-')) {
+      if (OPTIONS_WITH_VALUE.has(arg)) {
+        i++; // skip the next arg (option value)
+      }
+      continue;
+    }
+    return arg;
+  }
+  return undefined;
+}
+
 function extractSyncGlobalOptions(args: string[]): GlobalOptions {
   const options: GlobalOptions = {};
 
@@ -832,8 +934,8 @@ async function main(): Promise<void> {
   }
 
   const args = process.argv.slice(2);
-  const cmdName = args.find((arg) => !arg.startsWith('-'));
   const syncGlobalOptions = extractSyncGlobalOptions(args);
+  const cmdName = findCommandName(args);
 
   // No command name = no Unity operation; skip project detection
   const NO_PROJECT_COMMANDS = [UPDATE_COMMAND, 'completion'] as const;
@@ -841,20 +943,24 @@ async function main(): Promise<void> {
     cmdName === undefined || (NO_PROJECT_COMMANDS as readonly string[]).includes(cmdName);
 
   if (skipProjectDetection) {
-    const defaultTools = getDefaultTools();
+    const defaultToolNames: ReadonlySet<string> = getDefaultToolNames();
     // Only filter disabled tools for top-level help (uloop --help); subcommand help
     // (e.g. uloop completion --help) does not list dynamic tools, so scanning is unnecessary
     const isTopLevelHelp: boolean =
       cmdName === undefined && (args.includes('-h') || args.includes('--help'));
     const shouldFilter: boolean = syncGlobalOptions.projectPath !== undefined || isTopLevelHelp;
+    // Use cache to include third-party tools in help output; falls back to defaults when no cache exists
+    const sourceTools: ToolDefinition[] = shouldFilter
+      ? loadToolsCache(syncGlobalOptions.projectPath).tools
+      : getDefaultTools().tools;
     const tools: ToolDefinition[] = shouldFilter
-      ? filterEnabledTools(defaultTools.tools, syncGlobalOptions.projectPath)
-      : defaultTools.tools;
+      ? filterEnabledTools(sourceTools, syncGlobalOptions.projectPath)
+      : sourceTools;
     if (!shouldFilter || isToolEnabled(FOCUS_WINDOW_COMMAND, syncGlobalOptions.projectPath)) {
-      registerFocusWindowCommand(program);
+      registerFocusWindowCommand(program, HELP_GROUP_BUILTIN_TOOLS);
     }
     for (const tool of tools) {
-      registerToolCommand(tool);
+      registerToolCommand(tool, getToolHelpGroup(tool.name, defaultToolNames));
     }
     program.parse();
     return;
@@ -887,11 +993,12 @@ async function main(): Promise<void> {
   // Register tool commands from cache (after potential auto-sync)
   const toolsCache = loadToolsCache();
   const projectPath: string | undefined = syncGlobalOptions.projectPath;
+  const defaultToolNames: ReadonlySet<string> = getDefaultToolNames();
   if (isToolEnabled(FOCUS_WINDOW_COMMAND, projectPath)) {
-    registerFocusWindowCommand(program);
+    registerFocusWindowCommand(program, HELP_GROUP_BUILTIN_TOOLS);
   }
   for (const tool of filterEnabledTools(toolsCache.tools, projectPath)) {
-    registerToolCommand(tool);
+    registerToolCommand(tool, getToolHelpGroup(tool.name, defaultToolNames));
   }
 
   if (cmdName && !commandExists(cmdName, projectPath)) {
@@ -906,7 +1013,7 @@ async function main(): Promise<void> {
       const newCache = loadToolsCache();
       const tool = filterEnabledTools(newCache.tools, projectPath).find((t) => t.name === cmdName);
       if (tool) {
-        registerToolCommand(tool);
+        registerToolCommand(tool, getToolHelpGroup(tool.name, defaultToolNames));
         console.log(`\x1b[32m✓ Found '${cmdName}' after sync.\x1b[0m\n`);
       } else {
         console.error(`\x1b[31mError: Command '${cmdName}' not found even after sync.\x1b[0m`);

package/src/commands/focus-window.ts

@@ -12,66 +12,71 @@ import { findRunningUnityProcess, focusUnityProcess } from 'launch-unity';
 import { findUnityProjectRoot } from '../project-root.js';
 import { validateProjectPath } from '../port-resolver.js';
 
-export function registerFocusWindowCommand(program: Command): void {
-  program
+export function registerFocusWindowCommand(program: Command, helpGroup?: string): void {
+  const cmd = program
     .command('focus-window')
     .description('Bring Unity Editor window to front using OS-level commands')
-    .option('--project-path <path>', 'Unity project path')
-    .action(async (options: { projectPath?: string }) => {
-      let projectRoot: string | null;
-      if (options.projectPath !== undefined) {
-        try {
-          projectRoot = validateProjectPath(options.projectPath);
-        } catch (error) {
-          console.error(
-            JSON.stringify({
-              Success: false,
-              Message: error instanceof Error ? error.message : String(error),
-            }),
-          );
-          process.exit(1);
-          return;
-        }
-      } else {
-        projectRoot = findUnityProjectRoot();
-      }
-      if (projectRoot === null) {
-        console.error(
-          JSON.stringify({
-            Success: false,
-            Message: 'Unity project not found',
-          }),
-        );
-        process.exit(1);
-      }
+    .option('--project-path <path>', 'Unity project path');
 
-      const runningProcess = await findRunningUnityProcess(projectRoot);
-      if (!runningProcess) {
-        console.error(
-          JSON.stringify({
-            Success: false,
-            Message: 'No running Unity process found for this project',
-          }),
-        );
-        process.exit(1);
-      }
+  if (helpGroup !== undefined) {
+    cmd.helpGroup(helpGroup);
+  }
 
+  cmd.action(async (options: { projectPath?: string }) => {
+    let projectRoot: string | null;
+    if (options.projectPath !== undefined) {
       try {
-        await focusUnityProcess(runningProcess.pid);
-        console.log(
-          JSON.stringify({
-            Success: true,
-            Message: `Unity Editor window focused (PID: ${runningProcess.pid})`,
-          }),
-        );
+        projectRoot = validateProjectPath(options.projectPath);
       } catch (error) {
         console.error(
           JSON.stringify({
             Success: false,
-            Message: `Failed to focus Unity window: ${error instanceof Error ? error.message : String(error)}`,
+            Message: error instanceof Error ? error.message : String(error),
           }),
         );
         process.exit(1);
+        return;
       }
-    });
+    } else {
+      projectRoot = findUnityProjectRoot();
+    }
+    if (projectRoot === null) {
+      console.error(
+        JSON.stringify({
+          Success: false,
+          Message: 'Unity project not found',
+        }),
+      );
+      process.exit(1);
+    }
+
+    const runningProcess = await findRunningUnityProcess(projectRoot);
+    if (!runningProcess) {
+      console.error(
+        JSON.stringify({
+          Success: false,
+          Message: 'No running Unity process found for this project',
+        }),
+      );
+      process.exit(1);
+    }
+
+    try {
+      await focusUnityProcess(runningProcess.pid);
+      console.log(
+        JSON.stringify({
+          Success: true,
+          Message: `Unity Editor window focused (PID: ${runningProcess.pid})`,
+        }),
+      );
+    } catch (error) {
+      console.error(
+        JSON.stringify({
+          Success: false,
+          Message: `Failed to focus Unity window: ${error instanceof Error ? error.message : String(error)}`,
+        }),
+      );
+      process.exit(1);
+    }
+  });
 }

package/src/compile-helpers.ts

@@ -17,14 +17,14 @@ 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 = [
+const COMPILE_FORCE_RECOMPILE_ARG_KEYS = [
   'ForceRecompile',
   'forceRecompile',
   'force_recompile',
   'force-recompile',
 ] as const;
 
-export const COMPILE_WAIT_FOR_DOMAIN_RELOAD_ARG_KEYS = [
+const COMPILE_WAIT_FOR_DOMAIN_RELOAD_ARG_KEYS = [
   'WaitForDomainReload',
   'waitForDomainReload',
   'wait_for_domain_reload',
@@ -36,7 +36,7 @@ export interface CompileExecutionOptions {
   waitForDomainReload: boolean;
 }
 
-export interface CompileCompletionWaitOptions {
+interface CompileCompletionWaitOptions {
   projectRoot: string;
   requestId: string;
   timeoutMs: number;
@@ -45,9 +45,9 @@ export interface CompileCompletionWaitOptions {
   isUnityReadyWhenIdle?: () => Promise<boolean>;
 }
 
-export type CompileCompletionOutcome = 'completed' | 'timed_out';
+type CompileCompletionOutcome = 'completed' | 'timed_out';
 
-export interface CompileCompletionResult<T> {
+interface CompileCompletionResult<T> {
   outcome: CompileCompletionOutcome;
   result?: T;
 }

package/src/default-tools.json

@@ -1,5 +1,5 @@
 {
-  "version": "0.68.2",
+  "version": "0.69.0",
   "tools": [
     {
       "name": "compile",
@@ -239,6 +239,34 @@
         }
       }
     },
+    {
+      "name": "get-unity-search-providers",
+      "description": "Get detailed information about Unity Search providers including display names, descriptions, active status, and capabilities",
+      "inputSchema": {
+        "type": "object",
+        "properties": {
+          "ProviderId": {
+            "type": "string",
+            "description": "Specific provider ID to get details for (empty = all providers). Examples: 'asset', 'scene', 'menu', 'settings'"
+          },
+          "ActiveOnly": {
+            "type": "boolean",
+            "description": "Whether to include only active providers",
+            "default": false
+          },
+          "SortByPriority": {
+            "type": "boolean",
+            "description": "Sort providers by priority (lower number = higher priority)",
+            "default": true
+          },
+          "IncludeDescriptions": {
+            "type": "boolean",
+            "description": "Include detailed descriptions for each provider",
+            "default": true
+          }
+        }
+      }
+    },
     {
       "name": "get-menu-items",
       "description": "Retrieve Unity MenuItems",

package/src/direct-unity-client.ts

@@ -13,14 +13,14 @@ const JSONRPC_VERSION = '2.0';
 const DEFAULT_HOST = '127.0.0.1';
 const NETWORK_TIMEOUT_MS = 180000;
 
-export interface JsonRpcRequest {
+interface JsonRpcRequest {
   jsonrpc: string;
   method: string;
   params?: Record<string, unknown>;
   id: number;
 }
 
-export interface JsonRpcResponse {
+interface JsonRpcResponse {
   jsonrpc: string;
   result?: unknown;
   error?: {

package/src/execute-tool.ts

@@ -13,6 +13,7 @@ import { join } from 'path';
 import * as semver from 'semver';
 import { DirectUnityClient } from './direct-unity-client.js';
 import { resolveUnityPort, validateProjectPath } from './port-resolver.js';
+import { validateConnectedProject } from './project-validator.js';
 import { saveToolsCache, getCacheFilePath, ToolsCache, ToolDefinition } from './tool-cache.js';
 import { VERSION } from './version.js';
 import { createSpinner } from './spinner.js';
@@ -214,6 +215,9 @@ export async function executeToolCommand(
       ? validateProjectPath(globalOptions.projectPath)
       : findUnityProjectRoot();
 
+  // Validate project identity only when port was auto-resolved (not --port) and project root is known
+  const shouldValidateProject = portNumber === undefined && projectRoot !== null;
+
   // Monotonically-increasing flag: once true, retries cannot reset it to false.
   // The retry loop overwrites `lastError` and `immediateResult` on each attempt,
   // which destroys the evidence of whether an earlier attempt successfully dispatched
@@ -229,6 +233,10 @@ export async function executeToolCommand(
     try {
       await client.connect();
 
+      if (shouldValidateProject) {
+        await validateConnectedProject(client, projectRoot);
+      }
+
       spinner.update(`Executing ${toolName}...`);
       // connect() succeeded: socket is established. sendRequest() calls socket.write()
       // synchronously (direct-unity-client.ts:136), so the data reaches the kernel
@@ -383,6 +391,11 @@ export async function listAvailableTools(globalOptions: GlobalOptions): Promise<
     portNumber = parsed;
   }
   const port = await resolveUnityPort(portNumber, globalOptions.projectPath);
+  const projectRoot =
+    globalOptions.projectPath !== undefined
+      ? validateProjectPath(globalOptions.projectPath)
+      : findUnityProjectRoot();
+  const shouldValidateProject = portNumber === undefined && projectRoot !== null;
 
   const restoreStdin = suppressStdinEcho();
   const spinner = createSpinner('Connecting to Unity...');
@@ -395,6 +408,10 @@ export async function listAvailableTools(globalOptions: GlobalOptions): Promise<
     try {
       await client.connect();
 
+      if (shouldValidateProject) {
+        await validateConnectedProject(client, projectRoot);
+      }
+
       spinner.update('Fetching tool list...');
       const result = await client.sendRequest<{
         Tools: Array<{ name: string; description: string }>;
@@ -471,6 +488,11 @@ export async function syncTools(globalOptions: GlobalOptions): Promise<void> {
     portNumber = parsed;
   }
   const port = await resolveUnityPort(portNumber, globalOptions.projectPath);
+  const projectRoot =
+    globalOptions.projectPath !== undefined
+      ? validateProjectPath(globalOptions.projectPath)
+      : findUnityProjectRoot();
+  const shouldValidateProject = portNumber === undefined && projectRoot !== null;
 
   const restoreStdin = suppressStdinEcho();
   const spinner = createSpinner('Connecting to Unity...');
@@ -483,6 +505,10 @@ export async function syncTools(globalOptions: GlobalOptions): Promise<void> {
     try {
       await client.connect();
 
+      if (shouldValidateProject) {
+        await validateConnectedProject(client, projectRoot);
+      }
+
       spinner.update('Syncing tools...');
       const result = await client.sendRequest<{
         Tools: UnityToolInfo[];

package/src/port-resolver.ts

@@ -11,7 +11,11 @@ import { existsSync } from 'fs';
 import { join, resolve } from 'path';
 import { findUnityProjectRoot, isUnityProject, hasUloopInstalled } from './project-root.js';
 
-const DEFAULT_PORT = 8700;
+export class UnityNotRunningError extends Error {
+  constructor(public readonly projectRoot: string) {
+    super('UNITY_NOT_RUNNING');
+  }
+}
 
 interface UnityMcpSettings {
   isServerRunning?: boolean;
@@ -78,11 +82,7 @@ export async function resolveUnityPort(
 
   if (projectPath !== undefined) {
     const resolved = validateProjectPath(projectPath);
-    const settingsPort = await readPortFromSettings(resolved);
-    if (settingsPort !== null) {
-      return settingsPort;
-    }
-    return DEFAULT_PORT;
+    return await readPortFromSettingsOrThrow(resolved);
   }
 
   const projectRoot = findUnityProjectRoot();
@@ -92,34 +92,55 @@ export async function resolveUnityPort(
     );
   }
 
-  const settingsPort = await readPortFromSettings(projectRoot);
-  if (settingsPort !== null) {
-    return settingsPort;
-  }
+  return await readPortFromSettingsOrThrow(projectRoot);
+}
 
-  return DEFAULT_PORT;
+function createSettingsReadError(projectRoot: string): Error {
+  const settingsPath = join(projectRoot, 'UserSettings/UnityMcpSettings.json');
+  return new Error(
+    `Could not read Unity server port from settings.\n\n` +
+      `  Settings file: ${settingsPath}\n\n` +
+      `Run 'uloop launch -r' to restart Unity, or use --port to specify the port directly.`,
+  );
 }
 
-async function readPortFromSettings(projectRoot: string): Promise<number | null> {
+// File I/O and JSON parsing can fail for external reasons (permissions, corruption, concurrent writes)
+async function readPortFromSettingsOrThrow(projectRoot: string): Promise<number> {
   const settingsPath = join(projectRoot, 'UserSettings/UnityMcpSettings.json');
 
   if (!existsSync(settingsPath)) {
-    return null;
+    throw createSettingsReadError(projectRoot);
   }
 
   let content: string;
   try {
     content = await readFile(settingsPath, 'utf-8');
   } catch {
-    return null;
+    throw createSettingsReadError(projectRoot);
   }
 
-  let settings: UnityMcpSettings;
+  let parsed: unknown;
   try {
-    settings = JSON.parse(content) as UnityMcpSettings;
+    parsed = JSON.parse(content);
   } catch {
-    return null;
+    throw createSettingsReadError(projectRoot);
   }
 
-  return resolvePortFromUnitySettings(settings);
+  if (typeof parsed !== 'object' || parsed === null) {
+    throw createSettingsReadError(projectRoot);
+  }
+  const settings = parsed as UnityMcpSettings;
+
+  // Only block when isServerRunning is explicitly false (Unity clean shutdown).
+  // undefined/missing means old settings format — proceed to next validation stage.
+  if (settings.isServerRunning === false) {
+    throw new UnityNotRunningError(projectRoot);
+  }
+
+  const port = resolvePortFromUnitySettings(settings);
+  if (port === null) {
+    throw createSettingsReadError(projectRoot);
+  }
+
+  return port;
 }

package/src/project-root.ts

@@ -143,7 +143,7 @@ export function findUnityProjectRoot(startPath: string = process.cwd()): string
   return findUnityProjectInParents(startPath);
 }
 
-export interface UnityProjectStatus {
+interface UnityProjectStatus {
   found: boolean;
   path: string | null;
   hasUloop: boolean;