### Start Recording Input

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/RecordInput/Skill/SKILL.md

Use this command to begin capturing keyboard and mouse input. Ensure Unity is in PlayMode and the Input System package is installed.

```bash
uloop record-input --action Start
```

--------------------------------

### Install and Build Project

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/TypeScriptServer~/README.md

Run these commands in a new environment or after modifying package.json to install dependencies and build the project.

```bash
npm install
npm run build
```

--------------------------------

### Install Unity CLI Loop Skills

Source: https://github.com/hatayama/unity-cli-loop/blob/main/README.md

Install specific skills for LLM tools to interact with Unity projects. Use flags like --claude or --codex for project-specific installations, or --global for a global installation.

```bash
# Install for Claude Code project
uloop skills install --claude

# Install for OpenAI Codex project
uloop skills install --codex

# Or install globally
uloop skills install --claude --global
```

--------------------------------

### Start Replay with uloop CLI

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ReplayInput/Skill/SKILL.md

Use the uloop CLI to start input replay. Auto-detects the latest recording or accepts a specific input path. Supports continuous looping.

```bash
uloop replay-input --action Start

# Start replay with specific file
uloop replay-input --action Start --input-path scripts/my-play.json

# Start replay with looping
uloop replay-input --action Start --loop true
```

--------------------------------

### completion

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Cli~/README.md

Install Bash/Zsh/PowerShell completion for tab-completion support.

```APIDOC
## completion

### Description
Install Bash/Zsh/PowerShell completion for tab-completion support.

### Method
`uloop completion`

### Parameters
#### Query Parameters
- `--install` (flag) - Required - Install completion scripts
- `--shell <shell>` (string) - Optional - Explicitly specify shell (e.g., `bash`, `powershell`)

### Request Example
```bash
# Auto-detect shell and install
uloop completion --install

# Explicitly specify shell
uloop completion --shell bash --install        # Git Bash / MINGW64
uloop completion --shell powershell --install  # PowerShell
```
```

--------------------------------

### Install TypeScript Server Dependencies

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/TypeScriptServer~/README.md

Navigate to the TypeScript server directory and run this command to install necessary packages.

```bash
cd Packages/src/TypeScriptServer
npm install
```

--------------------------------

### Find and Click Start Button After Play Mode Initialization

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/playmode-automation-zsh.md

Waits for scene initialization after entering Play mode, then finds and clicks a button whose name contains 'Start'. Provides feedback on available buttons if the target is not found.

```csharp
using UnityEngine.UI;
using System.Linq;

// Scene may need a moment to initialize after Play starts
Button[] buttons = Object.FindObjectsByType<Button>(FindObjectsSortMode.None);
Button startBtn = buttons.FirstOrDefault(b => b.gameObject.name.Contains("Start"));
if (startBtn == null) return $"Start button not found. Available: {string.Join(", ", buttons.Select(b => b.gameObject.name))}";

startBtn.onClick.Invoke();
return $"Clicked {startBtn.gameObject.name}";
```

--------------------------------

### Install uloop-cli via npm

Source: https://github.com/hatayama/unity-cli-loop/blob/main/README.md

Install the Unity CLI Loop globally using npm. This command-line tool provides direct access to Unity CLI functionalities.

```bash
npm install -g uloop-cli
```

--------------------------------

### Install Shell Completion for Unity CLI

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/README.md

Set up command-line autocompletion for Bash, Zsh, or PowerShell to improve usability. The `--install` flag adds the completion script to your shell's configuration.

```bash
# Add completion script to shell config (auto-detects shell)
uloop completion --install
```

```bash
# Explicitly specify shell (when auto-detection fails on Windows)
uloop completion --shell bash --install        # Git Bash / MINGW64
uloop completion --shell powershell --install  # PowerShell
```

```bash
# Check completion script
uloop completion
```

--------------------------------

### Install LLM Skills for uloop

Source: https://context7.com/hatayama/unity-cli-loop/llms.txt

Installs skills for AI tools like Claude Code and OpenAI Codex to interact with uloop commands. Can be installed per-project or globally.

```bash
# Install for Claude Code (project-level)
uloop skills install --claude

# Install for OpenAI Codex (project-level)
uloop skills install --codex

# Install globally (available in all projects)
uloop skills install --claude --global
```

--------------------------------

### Install Unity CLI Loop Skills

Source: https://context7.com/hatayama/unity-cli-loop/llms.txt

Install custom skills for Unity CLI Loop using the provided command. This makes your custom tools available for use within the CLI.

```bash
uloop skills install --claude
```

--------------------------------

### Install Shell Completion

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Cli~/README.md

Set up shell completion for Bash, Zsh, or PowerShell to enable tab-completion for uloop commands.

```bash
# Auto-detect shell and install
uloop completion --install

# Explicitly specify shell
uloop completion --shell bash --install        # Git Bash / MINGW64
uloop completion --shell powershell --install  # PowerShell
```

--------------------------------

### Unity Connection Test (Quick) Execution Output

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/TypeScriptServer~/README.md

Example output for a quick Unity connection test, showing successful connection, ping response, and completion status.

```text
=== Unity Connection Test ===
Verbose: OFF
Quick Test: ON

1. Connecting to Unity...
✓ Connected successfully!

2. Testing ping...
✓ Ping response: Unity MCP Bridge received: Hello from connection test!

✓ Quick test completed successfully!

5. Disconnecting...
✓ Disconnected
```

--------------------------------

### Configure OpenUPM Scoped Registry

Source: https://github.com/hatayama/unity-cli-loop/blob/main/README.md

Add this entry to your Project Settings' Scoped Registries to use OpenUPM for installing Unity CLI Loop. This is the recommended installation method.

```text
Name: OpenUPM
URL: https://package.openupm.com
Scope(s): io.github.hatayama.uloopmcp
```

--------------------------------

### Install Shell Completion for Unity CLI Loop

Source: https://github.com/hatayama/unity-cli-loop/blob/main/README.md

To enable command autocompletion in your shell (Bash, Zsh, PowerShell), use the `completion --install` command. It attempts to auto-detect your shell, but you can specify it explicitly if needed.

```bash
uloop completion --install
```

```bash
uloop completion --shell bash --install
```

```bash
uloop completion --shell powershell --install
```

```bash
uloop completion
```

--------------------------------

### Execute Dynamic Code with Simple Return

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/playmode-automation-powershell.md

Basic example of executing dynamic C# code via PowerShell, returning a simple string.

```powershell
uloop execute-dynamic-code --code 'return "Hello from PowerShell";'
```

--------------------------------

### Get Project Info with uloop CLI

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Assets/Editor/CustomCommandSamples/GetProjectInfo/Skill/SKILL.md

Run this command to retrieve detailed information about your Unity project. The output is returned in JSON format.

```bash
uloop get-project-info
```

--------------------------------

### Run TypeScript Server (Production)

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/TypeScriptServer~/README.md

Starts the MCP server in production mode, where the ping tool is disabled.

```bash
npm start
```

--------------------------------

### Start Recording with Key Filter

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/RecordInput/Skill/SKILL.md

Begin recording input while filtering for specific keys. This is useful for reducing noise and focusing on essential controls. The keys are provided as a comma-separated string.

```bash
uloop record-input --action Start --keys "W,A,S,D,Space"
```

--------------------------------

### uloop control-play-mode

Source: https://context7.com/hatayama/unity-cli-loop/llms.txt

Controls the Unity PlayMode by starting, stopping, or pausing the editor. Play also resumes from a paused state.

```APIDOC
## control-play-mode

### Description
Controls Unity Play Mode (Play, Pause, Stop).

### Method
POST

### Endpoint
/uloop/control-play-mode

### Parameters
#### Query Parameters
- **action** (string) - Required - The action to perform (Play, Pause, Stop).
```

--------------------------------

### Utility Commands: List, Sync, Completion

Source: https://context7.com/hatayama/unity-cli-loop/llms.txt

Utility commands for managing Unity CLI Loop. List registered tools, sync definitions, and install shell completion scripts.

```bash
# List all tools registered in the running Unity Editor
uloop list
```

```bash
# Sync tool definitions from Unity to local cache
uloop sync
```

```bash
# Setup shell completion (auto-detects shell)
uloop completion --install
```

```bash
# Explicitly target PowerShell on Windows
uloop completion --shell powershell --install
```

--------------------------------

### Run TypeScript Server (Development)

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/TypeScriptServer~/README.md

Starts the MCP server in development mode, enabling the ping tool. Can also be controlled via environment variables.

```bash
npm run dev
```

```bash
npm run start:dev
```

```bash
ENABLE_PING_TOOL=true npm start
```

--------------------------------

### Start Play Mode with Unity CLI Loop

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/playmode-automation-powershell.md

Initiates Play mode in the Unity application. This is the first step in automating user interactions or tests within the editor.

```powershell
uloop control-play-mode --action Play
```

--------------------------------

### Windows Codex Starting Prompt

Source: https://github.com/hatayama/unity-cli-loop/blob/main/docs/architecture/execute-dynamic-code-windows-handoff.md

Use this prompt as the initial message when interacting with Windows Codex to resume work on the specified branch and review relevant documentation.

```text
Please resume work on branch `codex/rebuild-execute-dynamic-code`.

First read:
- docs/architecture/execute-dynamic-code-rebuild.md
- docs/architecture/execute-dynamic-code-windows-handoff.md

Important recent commits:
- 583cde7e Log dynamic compile fast-path failures for Windows handoff
- 893f42f2 Route prewarm capability through build facade
- 0889d2c6 Split dynamic code infrastructure into module facades

Goal:
- Validate execute-dynamic-code on Windows
- Confirm whether the fast Roslyn path, one-shot Roslyn path, or AssemblyBuilder fallback is being used
- If the ideal path is not active, inspect Unity Console error logs and fix the cause

Suggested validation commands:
1. uloop compile
2. uloop run-tests --test-mode EditMode --filter-type regex --filter-value 'io.github.hatayama.uLoopMCP.DynamicCodeToolTests'
3. uloop execute-dynamic-code --code "return 1 + 2;"
4. uloop execute-dynamic-code --code "StringBuilder builder1002 = new StringBuilder(); builder1002.Append(\"ok-1002\"); return builder1002.ToString();"
5. uloop execute-dynamic-code --code "DynamicAssemblyTest test1004 = new DynamicAssemblyTest(); return test1004.HelloWorld();"

Watch the Unity Console for:
- dynamic_code_fast_path_unavailable
- dynamic_code_shared_worker_fallback
- dynamic_code_shared_worker_failure
- dynamic_code_one_shot_compiler_start_failure
```

--------------------------------

### Direct Communication Test with Unity

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/TypeScriptServer~/README.md

Examples of executing commands directly via JSON-RPC communication with the Unity MCP server.

```APIDOC
## Run Compilation

### Method
POST (simulated via nc)

### Endpoint
`localhost:7400`

### Request Body
```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "compile",
  "params": {
    "forceRecompile": false
  }
}
```
```

```APIDOC
## Send Ping

### Method
POST (simulated via nc)

### Endpoint
`localhost:7400`

### Request Body
```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "ping",
  "params": {
    "message": "test"
  }
}
```
```

```APIDOC
## Get Logs

### Method
POST (simulated via nc)

### Endpoint
`localhost:7400`

### Request Body
```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "getLogs",
  "params": {
    "logType": "All",
    "maxCount": 10
  }
}
```
```

```APIDOC
## Run Tests

### Method
POST (simulated via nc)

### Endpoint
`localhost:7400`

### Request Body
```json
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "runtests",
  "params": {
    "filterType": "all",
    "filterValue": ""
  }
}
```
```

--------------------------------

### Unity Compile Test Execution Output

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/TypeScriptServer~/README.md

Example output demonstrating a successful Unity compile test, including connection status, compilation results, and disconnection.

```text
=== Unity Compile Test ===
Force Recompile: OFF

1. Connecting to Unity...
✓ Connected successfully!

2. Executing compile...
✓ Compile completed!
Success: true
Errors: 0
Warnings: 0
Completed at: 2025-06-18T23:20:14.775Z

3. Disconnecting...
✓ Disconnected
```

--------------------------------

### Record Input During Unity Play Mode

Source: https://github.com/hatayama/unity-cli-loop/blob/main/README.md

Records keyboard and mouse input frame-by-frame into a JSON file using the Input System. Available only when the Input System package is installed.

```text
→ record-input (Action: Start)
```

```text
→ record-input (Action: Start, Keys: "W,A,S,D,Space")
```

```text
→ record-input (Action: Stop)
```

```text
→ JSON file saved to .uloop/outputs/InputRecordings/
```

--------------------------------

### Run uloop hello-world with Custom Name

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Assets/Editor/CustomCommandSamples/HelloWorld/Skill/SKILL.md

Greet a specific person by providing a custom name. This demonstrates passing string parameters to the tool.

```bash
uloop hello-world --name "Alice"
```

--------------------------------

### Get Selected Asset GUIDs

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves the GUIDs of all selected assets in the Project window.

```APIDOC
## Get Selected Asset GUIDs

### Description
Retrieves the GUIDs of all selected assets in the Project window.

### Code Example
```csharp
using UnityEditor;
using System.Collections.Generic;

string[] guids = Selection.assetGUIDs;
if (guids.Length == 0)
{
    return "No assets selected";
}

List<string> paths = new List<string>();
foreach (string guid in guids)
{
    paths.Add(AssetDatabase.GUIDToAssetPath(guid));
}
return $"Selected assets: {string.Join(", ", paths)}";
```
```

--------------------------------

### Screenshot with Prefix Match

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/Screenshot/Skill/SKILL.md

Captures screenshots of all windows whose names start with a specified prefix. This is useful for targeting groups of related windows.

```bash
uloop screenshot --window-name Project --match-mode prefix
```

--------------------------------

### Get Selected Asset GUIDs

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves the GUIDs of all selected Assets. Returns a message if no assets are selected.

```csharp
using UnityEditor;
using System.Collections.Generic;

string[] guids = Selection.assetGUIDs;
if (guids.Length == 0)
{
    return "No assets selected";
}

List<string> paths = new List<string>();
foreach (string guid in guids)
{
    paths.Add(AssetDatabase.GUIDToAssetPath(guid));
}
return $"Selected assets: {string.Join(", ", paths)}";
```

--------------------------------

### launch

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Cli~/README.md

Open a Unity project with the matching Editor version.

```APIDOC
## launch

### Description
Open a Unity project with the matching Editor version.

### Method
`uloop launch`

### Parameters
#### Path Parameters
- `[project-path]` (string) - Optional - Path to Unity project (searches current directory if omitted)

#### Query Parameters
- `-r, --restart` (flag) - Optional - Kill running Unity and restart
- `-q, --quit` (flag) - Optional - Gracefully quit running Unity
- `-d, --delete-recovery` (flag) - Optional - Delete Assets/_Recovery before launch
- `-p, --platform <platform>` (string) - Optional - Build target (e.g., Android, iOS, StandaloneOSX)
- `--max-depth <n>` (number) - Optional - Search depth when project-path is omitted (-1 for unlimited) (default: `3`)
- `-a, --add-unity-hub` (flag) - Optional - Add to Unity Hub only (does not launch)
- `-f, --favorite` (flag) - Optional - Add to Unity Hub as favorite (does not launch)

### Request Example
```bash
uloop launch
uloop launch /path/to/project
uloop launch -r
uloop launch -p Android
```
```

--------------------------------

### Get Hierarchy with get-hierarchy

Source: https://github.com/hatayama/unity-cli-loop/blob/main/README.md

Retrieves the active Hierarchy in nested JSON format, which is automatically saved to a file. Can retrieve hierarchy starting from selected GameObjects.

```unity-cli
get-hierarchy (UseSelection: true)
```

--------------------------------

### Get UI Hierarchy

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/playmode-automation-zsh.md

Retrieves the hierarchy of UI elements starting from a specified root path, including their components. Useful for understanding UI structure.

```zsh
uloop get-hierarchy --root-path "Canvas" --max-depth 3 --include-components true
```

--------------------------------

### Launch Unity Editor with Options

Source: https://context7.com/hatayama/unity-cli-loop/llms.txt

Opens the Unity project with the matching Editor version. Supports options for restart, build target platform switching, and Unity Hub integration.

```bash
uloop launch
```

```bash
uloop launch --platform Android
```

```bash
uloop launch --restart
```

```bash
uloop launch --quit
```

```bash
uloop launch /Users/dev/OtherUnityProject
```

```bash
uloop launch --add-unity-hub
```

--------------------------------

### Launch Unity Project

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Cli~/README.md

Open a Unity project with a matching Editor version. Options include restarting, quitting, deleting recovery data, specifying platform, and adding to Unity Hub.

```bash
uloop launch
uloop launch /path/to/project
uloop launch -r
uloop launch -p Android
```

--------------------------------

### Get Hierarchy from Specific Root

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/GetHierarchy/Skill/SKILL.md

Retrieve the hierarchy starting from a specified GameObject path within the scene. This is useful for focusing on a particular branch of the hierarchy.

```bash
uloop get-hierarchy --root-path "Canvas/UI"
```

--------------------------------

### Get Hierarchy from Selected GameObjects

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/GetHierarchy/Skill/SKILL.md

Use this option to retrieve the hierarchy starting from the GameObject(s) currently selected in the Unity Hierarchy window. The `--root-path` parameter is ignored when this option is active.

```bash
uloop get-hierarchy --use-selection
```

--------------------------------

### Search and Launch Unity Project

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Cli~/src/skills/skill-definitions/cli-only/uloop-launch/Skill/SKILL.md

Launches the Unity project located in the current directory.

```bash
uloop launch
```

--------------------------------

### Launch Unity Project

Source: https://github.com/hatayama/unity-cli-loop/blob/main/README.md

Launch the Unity project with the correct version using the 'launch' command. You can specify a build target or restart the Unity editor.

```bash
# Launch Unity project with correct version
uloop launch

# Launch with build target (Android, iOS, StandaloneOSX, etc.)
uloop launch -p Android

# Kill running Unity and restart
uloop launch -r
```

--------------------------------

### Check TypeScript Compiler Version

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/TypeScriptServer~/README.md

Verifies if the TypeScript compiler is installed and accessible, suggesting 'npm install' if it's not found.

```bash
npx tsc --version || echo "npm install required"
```

--------------------------------

### JSON-RPC Success Response Example

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/docs/ARCHITECTURE_Unity.md

An example of a successful JSON-RPC 2.0 response, indicating that a request was processed correctly by the Unity Editor.

```json
{
  "jsonrpc": "2.0",
  "id": 1647834567890,
  "result": {
    "Message": "Unity MCP Bridge received: Hello Unity MCP!",
    "ExecutionTimeMs": 5
  }
}
```

--------------------------------

### Run uloop hello-world Command

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Assets/Editor/CustomCommandSamples/HelloWorld/Skill/SKILL.md

Execute the default hello world command. This is useful for basic testing of the MCP tool system.

```bash
uloop hello-world
```

--------------------------------

### JSON-RPC Request Message Example

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/docs/ARCHITECTURE_Unity.md

An example of a JSON-RPC 2.0 request message used for communication between the TypeScript server and the Unity Editor.

```json
{
  "jsonrpc": "2.0",
  "id": 1647834567890,
  "method": "ping",
  "params": {
    "Message": "Hello Unity MCP!"
  }
}
```

--------------------------------

### `uloop launch` — Launch Unity Editor

Source: https://context7.com/hatayama/unity-cli-loop/llms.txt

Opens the Unity project with the matching Editor version, with options for restart, build target platform switching, and Unity Hub integration.

```APIDOC
## `uloop launch` — Launch Unity Editor

### Description
Opens the Unity project with the matching Editor version (as specified in `ProjectVersion.txt`), with options for restart, build target platform switching, and Unity Hub integration.

### Usage Examples

```bash
# Launch Unity for the project in the current directory
uloop launch

# Launch targeting Android
uloop launch --platform Android

# Kill running Unity and restart
uloop launch --restart

# Gracefully quit Unity
uloop launch --quit

# Launch a different project (explicit path)
uloop launch /Users/dev/OtherUnityProject

# Add project to Unity Hub without launching
uloop launch --add-unity-hub
```
```

--------------------------------

### JSON-RPC Error Response Example

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/docs/ARCHITECTURE_Unity.md

An example of a JSON-RPC 2.0 error response, used to communicate issues or blocked operations during tool execution.

```json
{
  "jsonrpc": "2.0",
  "id": 1647834567890,
  "error": {
    "code": -32603,
    "message": "Tool blocked by security settings",
    "data": {
      "type": "security_blocked",
      "command": "find-gameobjects",
      "reason": "GameObject search is disabled"
    }
  }
}
```

--------------------------------

### Check if Asset Exists

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/asset-operations.md

Determines if an asset exists at a given path by attempting to convert the path to a GUID. A non-empty GUID indicates the asset's presence.

```csharp
using UnityEditor;

string path = "Assets/Prefabs/Player.prefab";
string guid = AssetDatabase.AssetPathToGUID(path);

bool exists = !string.IsNullOrEmpty(guid);
return exists ? $"Asset exists: {path}" : $"Asset not found: {path}";
```

--------------------------------

### McpServerInitializationUseCase Implementation

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/docs/ARCHITECTURE_Unity.md

A concrete UseCase for initializing the MCP server, depending on McpServerConfigurationService, PortAllocationService, and McpServerStartupService. It manages server startup logic.

```csharp
public class McpServerInitializationUseCase : AbstractUseCase<ServerInitializationSchema, ServerInitializationResponse>
{
    private readonly McpServerConfigurationService configService;
    private readonly PortAllocationService portService;
    private readonly McpServerStartupService startupService;

    public McpServerInitializationUseCase(
        McpServerConfigurationService configService,
        PortAllocationService portService,
        McpServerStartupService startupService)
    {
        this.configService = configService;
        this.portService = portService;
        this.startupService = startupService;
    }

    public override async Task<ServerInitializationResponse> ExecuteAsync(ServerInitializationSchema schema, CancellationToken cancellationToken)
    {
        var configuration = this.configService.GetConfiguration();
        var port = this.portService.AllocatePort(configuration.Port);

        await this.startupService.StartupServerAsync(configuration, port);

        return new ServerInitializationResponse { Port = port };
    }
}
```

--------------------------------

### Initialize Services in UnityMcpServer

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/docs/ARCHITECTURE_TypeScript.md

Sets up dependency injection by calling `registerServices()` during server initialization. This ensures all necessary managers are available through the service locator.

```typescript
export class UnityMcpServer {
  constructor() {
    // Initialize all managers through service locator
    this.initializeServices();
  }

  private initializeServices(): void {
    registerServices(); // Setup dependency injection
  }

  async handleCallTool(request: CallToolRequest): Promise<CallToolResult> {
    const useCase = ServiceLocator.resolve<ExecuteToolUseCase>(
      ServiceTokens.EXECUTE_TOOL_USE_CASE
    );
    return await useCase.execute(this.mapToExecuteToolRequest(request));
  }
}
```

--------------------------------

### Run uloop hello-world with Japanese Language

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Assets/Editor/CustomCommandSamples/HelloWorld/Skill/SKILL.md

Generate a greeting in Japanese for a specific name. This showcases the use of enum parameters for language selection.

```bash
uloop hello-world --name "太郎" --language japanese
```

--------------------------------

### Get Unity and Project Version Information

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Cli~/src/skills/skill-definitions/cli-only/uloop-get-version/Skill/SKILL.md

Execute this command to retrieve a JSON output containing Unity version, platform, file paths, and project details like ProductName, CompanyName, and application Version. This is useful for verifying environment configurations.

```bash
uloop get-version
```

--------------------------------

### Launch Unity with Build Target

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Cli~/src/skills/skill-definitions/cli-only/uloop-launch/Skill/SKILL.md

Launches the Unity Editor and sets the specified build target.

```bash
uloop launch -p Android
```

--------------------------------

### List available Unity CLI tools

Source: https://github.com/hatayama/unity-cli-loop/blob/main/README.md

Use the 'list' command to see all available tools provided by the Unity CLI. This is useful for discovering functionalities.

```bash
uloop list
```

--------------------------------

### Get Selected Assets

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves all selected assets in the Project window.

```APIDOC
## Get Selected Assets

### Description
Retrieves all selected assets in the Project window.

### Code Example
```csharp
using UnityEditor;
using System.Collections.Generic;

Object[] selectedAssets = Selection.GetFiltered<Object>(SelectionMode.Assets);
if (selectedAssets.Length == 0)
{
    return "No assets selected";
}

List<string> paths = new List<string>();
foreach (Object asset in selectedAssets)
{
    paths.Add(AssetDatabase.GetAssetPath(asset));
}
return $"Assets: {string.Join(", ", paths)}";
```
```

--------------------------------

### Launch Unity Project CLI

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Cli~/src/skills/skill-definitions/cli-only/uloop-launch/Skill/SKILL.md

Use to open a Unity project with the correct Editor version. The command waits until Unity is ready for CLI operations.

```bash
uloop launch [project-path] [options]
```

--------------------------------

### Get Editable Objects Only

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves only Transforms that are editable from the current selection.

```APIDOC
## Get Editable Objects Only

### Description
Retrieves only Transforms that are editable from the current selection.

### Code Example
```csharp
using UnityEditor;
using System.Collections.Generic;

Transform[] transforms = Selection.GetTransforms(SelectionMode.Editable);
if (transforms.Length == 0)
{
    return "No editable transforms selected";
}

List<string> names = new List<string>();
foreach (Transform t in transforms)
{
    names.Add(t.name);
}
return $"Editable: {string.Join(", ", names)}";
```
```

--------------------------------

### Get Top-Level Transforms Only

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves only the top-level Transforms from the current selection.

```APIDOC
## Get Top-Level Transforms Only

### Description
Retrieves only the top-level Transforms from the current selection.

### Code Example
```csharp
using UnityEditor;
using System.Collections.Generic;

Transform[] transforms = Selection.GetTransforms(SelectionMode.TopLevel);
if (transforms.Length == 0)
{
    return "No transforms selected";
}

List<string> names = new List<string>();
foreach (Transform t in transforms)
{
    names.Add(t.name);
}
return $"Top-level: {string.Join(", ", names)}";
```
```

--------------------------------

### Launch Specific Unity Project

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Cli~/src/skills/skill-definitions/cli-only/uloop-launch/Skill/SKILL.md

Launches a Unity project from a specified path.

```bash
uloop launch /path/to/project
```

--------------------------------

### Get Selected GameObjects

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves all currently selected GameObjects in the Unity Editor.

```APIDOC
## Get Selected GameObjects

### Description
Retrieves all currently selected GameObjects in the Unity Editor.

### Code Example
```csharp
using UnityEditor;
using System.Collections.Generic;

GameObject[] selected = Selection.gameObjects;
if (selected.Length == 0)
{
    return "No GameObjects selected";
}

List<string> names = new List<string>();
foreach (GameObject obj in selected)
{
    names.Add(obj.name);
}
return $"Selected: {string.Join(", ", names)}";
```
```

--------------------------------

### Get All Children of GameObject

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/scene-operations.md

Retrieves the names of all direct children of the currently selected GameObject.

```csharp
GameObject parent = Selection.activeGameObject;
if (parent == null)
{
    return "No GameObject selected";
}

List<string> children = new List<string>();
foreach (Transform child in parent.transform)
{
    children.Add(child.name);
}
return $"Children: {string.Join(", ", children)}";
```

--------------------------------

### Get Deep Selection (Including Children)

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves all Transforms in the selection, including children of selected objects.

```APIDOC
## Get Deep Selection (Including Children)

### Description
Retrieves all Transforms in the selection, including children of selected objects.

### Code Example
```csharp
using UnityEditor;

Transform[] transforms = Selection.GetTransforms(SelectionMode.Deep);
if (transforms.Length == 0)
{
    return "No transforms selected";
}

return $"Deep selection count: {transforms.Length}";
```
```

--------------------------------

### Install Unity CLI Loop via Git URL

Source: https://github.com/hatayama/unity-cli-loop/blob/main/README.md

Use this Git URL in Unity Package Manager to add the Unity CLI Loop package. Ensure you use the correct path for the 'src' directory.

```text
https://github.com/hatayama/unity-cli-loop.git?path=/Packages/src
```

--------------------------------

### Get Active (Last Selected) GameObject

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves the last active (focused) GameObject in the current selection.

```APIDOC
## Get Active (Last Selected) GameObject

### Description
Retrieves the last active (focused) GameObject in the current selection.

### Code Example
```csharp
using UnityEditor;

GameObject active = Selection.activeGameObject;
if (active == null)
{
    return "No active GameObject";
}
return $"Active: {active.name}";
```
```

--------------------------------

### Get All Root GameObjects in Scene

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/scene-operations.md

Retrieves and lists the names of all root GameObjects in the currently active scene.

```csharp
UnityEngine.SceneManagement.Scene scene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
GameObject[] roots = scene.GetRootGameObjects();

List<string> names = new List<string>();
foreach (GameObject root in roots)
{
    names.Add(root.name);
}
return $"Root objects: {string.Join(", ", names)}";
```

--------------------------------

### `uloop simulate-mouse-input` — Simulate Mouse via Input System

Source: https://context7.com/hatayama/unity-cli-loop/llms.txt

Injects mouse input directly into `Mouse.current` for game logic that reads the Unity Input System API.

```APIDOC
## `uloop simulate-mouse-input` — Simulate Mouse via Input System

### Description
Injects mouse input directly into `Mouse.current` for game logic that reads the Unity Input System API (e.g. `Mouse.current.leftButton.wasPressedThisFrame`). Requires the Input System package with Active Input Handling set to `Input System Package (New)` or `Both`.

### Usage Examples

```bash
# Left-click at game coordinates
uloop simulate-mouse-input --action Click --x 400 --y 300

# Right-click
uloop simulate-mouse-input --action Click --x 400 --y 300 --button Right

# FPS camera look (inject mouse delta)
uloop simulate-mouse-input --action MoveDelta --delta-x 150 --delta-y 0
```
```

--------------------------------

### Get Selected Assets

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves all selected Assets in the Project window. Returns a message if no assets are selected.

```csharp
using UnityEditor;
using System.Collections.Generic;

Object[] selectedAssets = Selection.GetFiltered<Object>(SelectionMode.Assets);
if (selectedAssets.Length == 0)
{
    return "No assets selected";
}

List<string> paths = new List<string>();
foreach (Object asset in selectedAssets)
{
    paths.Add(AssetDatabase.GetAssetPath(asset));
}
return $"Assets: {string.Join(", ", paths)}";
```

--------------------------------

### Get All Logs

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/GetLogs/Skill/SKILL.md

Retrieves all available logs from the Unity Console. This is the default behavior when no specific filters are applied.

```bash
uloop get-logs
```

--------------------------------

### Run All EditMode Tests

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/RunTests/Skill/SKILL.md

Executes all EditMode tests by default. Ensure the Unity Test Framework package is installed.

```bash
uloop run-tests
```

--------------------------------

### Replay Recorded Input During Unity Play Mode

Source: https://github.com/hatayama/unity-cli-loop/blob/main/README.md

Replays recorded keyboard and mouse input during Play Mode by injecting input frame-by-frame via the Input System. Supports looping and progress monitoring. Requires the Input System package.

```text
→ replay-input (Action: Start)
```

```text
→ replay-input (Action: Start, InputPath: "scripts/my-play.json", Loop: true)
```

```text
→ replay-input (Action: Status)
```

```text
→ replay-input (Action: Stop)
```

--------------------------------

### Drag and Drop Simulation

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/SimulateMouseUi/Skill/SKILL.md

Executes a complete drag-and-drop operation from a starting point to a destination. The drag speed can be adjusted.

```bash
uloop simulate-mouse-ui --action Drag --from-x 50 --from-y 50 --x 300 --y 300 --drag-speed 200
```

--------------------------------

### Debug Scripts: Get All Logs

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/TypeScriptServer~/README.md

Runs a specific debug script to retrieve all available logs from the Unity side.

```bash
cd Packages/src/TypeScriptServer
npm run debug:all-logs
```

--------------------------------

### Create Prefab from GameObject

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/prefab-operations.md

Saves a given GameObject as a prefab asset. Ensure the target directory exists.

```csharp
using UnityEditor;

GameObject cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
cube.name = "MyCube";
string path = "Assets/Prefabs/MyCube.prefab";
PrefabUtility.SaveAsPrefabAsset(cube, path);
Object.DestroyImmediate(cube);
return $"Prefab created at {path}";
```

--------------------------------

### Get Selected GameObjects

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves all currently selected GameObjects in the Unity Editor. Returns a message if no GameObjects are selected.

```csharp
using UnityEditor;
using System.Collections.Generic;

GameObject[] selected = Selection.gameObjects;
if (selected.Length == 0)
{
    return "No GameObjects selected";
}

List<string> names = new List<string>();
foreach (GameObject obj in selected)
{
    names.Add(obj.name);
}
return $"Selected: {string.Join(", ", names)}";
```

--------------------------------

### Combine Screenshot Options

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/Screenshot/Skill/SKILL.md

Combines multiple options to capture a specific window with a reduced resolution scale and save it to a designated directory.

```bash
uloop screenshot --window-name Scene --resolution-scale 0.5 --output-directory /tmp/screenshots
```

--------------------------------

### Instantiate Prefab

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/prefab-operations.md

Loads a prefab from its asset path and instantiates it into the scene. Checks if the prefab exists before instantiation.

```csharp
using UnityEditor;

string prefabPath = "Assets/Prefabs/MyCube.prefab";
GameObject prefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
if (prefab == null)
{
    return $"Prefab not found at {prefabPath}";
}

GameObject instance = (GameObject)PrefabUtility.InstantiatePrefab(prefab);
instance.transform.position = new Vector3(0, 1, 0);
return $"Instantiated {instance.name}";
```

--------------------------------

### Get Deep Selection of Transforms

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves all Transforms in the current selection, including children. Returns the count of selected transforms.

```csharp
using UnityEditor;

Transform[] transforms = Selection.GetTransforms(SelectionMode.Deep);
if (transforms.Length == 0)
{
    return "No transforms selected";
}

return $"Deep selection count: {transforms.Length}";
```

--------------------------------

### Connection-Check Script for Unity

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/TypeScriptServer~/README.md

Test basic connection and communication with the Unity side. Options include running all tests, a quick ping test, or verbose output.

```bash
# Test all features (ping + compile + logs)
node debug/connection-check.js

# Run only ping test
node debug/connection-check.js --quick

# Run with verbose output
node debug/connection-check.js --verbose

# Show help
node debug/connection-check.js --help
```

--------------------------------

### Get Top-Level Transforms from Selection

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves only the top-level Transforms from the current selection. Returns a message if no top-level transforms are selected.

```csharp
using UnityEditor;
using System.Collections.Generic;

Transform[] transforms = Selection.GetTransforms(SelectionMode.TopLevel);
if (transforms.Length == 0)
{
    return "No transforms selected";
}

List<string> names = new List<string>();
foreach (Transform t in transforms)
{
    names.Add(t.name);
}
return $"Top-level: {string.Join(", ", names)}";
```

--------------------------------

### Get Active GameObject

Source: https://github.com/hatayama/unity-cli-loop/blob/main/Packages/src/Editor/Api/McpTools/ExecuteDynamicCode/Skill/references/selection-operations.md

Retrieves the currently active (last selected) GameObject. Returns a message if no active GameObject is found.

```csharp
using UnityEditor;

GameObject active = Selection.activeGameObject;
if (active == null)
{
    return "No active GameObject";
}
return $"Active: {active.name}";
```

--------------------------------

### Implement Custom Unity Tool

Source: https://github.com/hatayama/unity-cli-loop/blob/main/README.md

Implement your custom tool by creating a class that inherits from AbstractUnityTool. Use the McpTool attribute for auto-registration. The ExecuteAsync method handles the tool's logic, ensuring type-safe parameter access and checking for cancellation.

```csharp
using System.Threading;
using System.Threading.Tasks;

[McpTool(Description = "Description of my custom tool")]  // ← Auto-registered with this attribute
public class MyCustomTool : AbstractUnityTool<MyCustomSchema, MyCustomResponse>
{
    public override string ToolName => "my-custom-tool";

    // Executed on main thread
    protected override Task<MyCustomResponse> ExecuteAsync(MyCustomSchema parameters, CancellationToken cancellationToken)
    {
        // Type-safe parameter access
        string param = parameters.MyParameter;
        MyEnum enumValue = parameters.EnumParameter;

        // Check for cancellation before long-running operations
        cancellationToken.ThrowIfCancellationRequested();

        // Implement custom logic here
        string result = ProcessCustomLogic(param, enumValue);
        bool success = !string.IsNullOrEmpty(result);

        // For long-running operations, periodically check for cancellation
        // cancellationToken.ThrowIfCancellationRequested();

        return Task.FromResult(new MyCustomResponse(result, success));
    }

    private string ProcessCustomLogic(string input, MyEnum enumValue)
    {
        // Implement custom logic
        return $
```