unity-editor-toolkit

Purpose

Unity Editor Toolkit enables comprehensive Unity Editor automation and control from Claude Code. It provides:

• •Extensive Command Coverage: 500+ commands spanning 25 Unity Editor categories
• •Real-time Communication: Instant bidirectional WebSocket connection (JSON-RPC 2.0)
• •SQLite Database Integration: Real-time GameObject synchronization with GUID-based persistence
  • •GUID-based Identification: Persistent GameObject tracking across Unity sessions
  • •Multi-scene Support: Synchronize all loaded scenes simultaneously (1s interval)
  • •Command Pattern: Undo/Redo support for database operations
  • •Auto Migration: Automatic schema migration system
  • •Batch Operations: Efficient bulk inserts, updates, and deletes (500 objects/batch)
• •Menu Execution: Run Unity Editor menu items programmatically (Window, Assets, Edit, GameObject menus)
• •ScriptableObject Management: Complete CRUD operations with array/list support and all field types
  • •Array/List Operations: Add, remove, get, clear elements with nested access (items[0].name)
  • •All Field Types: Integer, Float, String, Boolean, Vector*, Color, Quaternion, Bounds, AnimationCurve, ObjectReference, and more
  • •Nested Property Traversal: Access deeply nested fields with dot notation and array indices
• •Deep Editor Integration: GameObject/hierarchy, transforms, components, scenes, materials, prefabs, animation, physics, lighting, build pipeline, and more
• •Security First: Multi-layer defense against injection attacks (SQL, command, JSON, path traversal) and unauthorized access
• •Production Ready: Cross-platform support with robust error handling and logging

Always run scripts with --help first to see usage. DO NOT read the source until you try running the script first and find that a customized solution is abslutely necessary. These scripts can be very large and thus pollute your context window. They exist to be called directly as black-box scripts rather than ingested into your context window.

📚 문서 우선 원칙 (필수)

⚠️ CRITICAL: Unity Editor Toolkit skill을 사용할 때는 반드시 다음 순서를 따르세요:

1️⃣ Reference 문서 확인 (필수)

명령어를 사용하기 전에 반드시 skills/references/ 폴더의 해당 문서를 읽으세요:

• •COMMANDS.md - 모든 명령어의 카테고리 및 개요
• •Category-specific docs - 사용할 명령어의 카테고리 문서:
  • •Component Commands - comp list/add/remove/enable/disable/get/set/inspect/move-up/move-down/copy
  • •GameObject Commands - go find/create/destroy/set-active/set-parent/get-parent/get-children
  • •Transform Commands - tf get/set-position/set-rotation/set-scale
  • •Scene Commands - scene current/list/load/new/save/unload/set-active
  • •Console Commands - console logs/clear
  • •EditorPrefs Commands - prefs get/set/delete/list/clear/import
  • •Other Categories - 추가 명령어 카테고리

2️⃣ --help 실행

# 모든 명령어 확인
cd <unity-project-root> && node .unity-websocket/uw --help

# 특정 명령어의 옵션 확인
cd <unity-project-root> && node .unity-websocket/uw <command> --help

3️⃣ 예제 실행

reference 문서의 Examples 섹션을 참고하여 명령어를 실행하세요.

4️⃣ 소스 코드 읽기 (최후의 수단)

• •reference 문서와 --help만으로는 해결 안 될 때만 소스 코드를 읽으세요
• •소스 코드는 컨텍스트 윈도우를 많이 차지하므로 가능하면 피하세요

이 순서를 무시하면:

• •❌ 명령어 사용법을 잘못 이해할 수 있음
• •❌ 옵션을 놓쳐서 원하지 않는 결과가 나올 수 있음
• •❌ 컨텍스트 윈도우를 낭비할 수 있음

When to Use

Use Unity Editor Toolkit when you need to:

1. •

   Automate Unity Editor Tasks

   • •Create and manipulate GameObjects, components, and hierarchies
   • •Configure scenes, materials, and rendering settings
   • •Control animation, physics, and particle systems
   • •Manage assets, prefabs, and build pipelines
2. •

   Real-time Unity Testing

   • •Monitor console logs and errors during development
   • •Query GameObject states and component properties
   • •Test scene configurations and gameplay logic
   • •Debug rendering, physics, or animation issues
3. •

   Batch Operations

   • •Create multiple GameObjects with specific configurations
   • •Apply material/shader changes across multiple objects
   • •Setup scene hierarchies from specifications
   • •Automate repetitive Editor tasks
4. •

   Menu and Editor Automation

   • •Execute Unity Editor menu items programmatically (menu run "Window/General/Console")
   • •Open editor windows and tools via command line
   • •Automate asset refresh, reimport, and build operations
   • •Query available menu items with wildcard filtering
5. •

   ScriptableObject Management

   • •Create and configure ScriptableObject assets programmatically
   • •Read and modify all field types (Vector, Color, Quaternion, AnimationCurve, etc.)
   • •Manipulate arrays/lists with full CRUD operations
   • •Access nested properties with array index notation (items[0].stats.health)
   • •Query ScriptableObject types and inspect asset metadata
6. •

   Database-Driven Workflows

   • •Persistent GameObject tracking across Unity sessions with GUID-based identification
   • •Real-time synchronization of all loaded scenes to SQLite database
   • •Analytics and querying of GameObject hierarchies and properties
   • •Undo/Redo support for database operations via Command Pattern
   • •Efficient batch operations (500 objects/batch) for large scene management
7. •

   CI/CD Integration

   • •Automated builds with platform-specific settings
   • •Test Runner integration for unit/integration tests
   • •Asset validation and integrity checks
   • •Build pipeline automation

Prerequisites

Unity Project Setup

1. •

   Install Unity Editor Toolkit Server Package

   • •Via Unity Package Manager (Git URL or local path)
   • •Requires Unity 2020.3 or higher
   • •Package location: skills/assets/unity-package
2. •

   Configure WebSocket Server

   • •Open Unity menu: Tools > Unity Editor Toolkit > Server Window
   • •Plugin scripts path auto-detected from ~/.claude/plugins/...
   • •Click "Install CLI" to build WebSocket server (one-time setup)
   • •Server starts automatically when Unity Editor opens
3. •

   Database Setup (Optional)

   • •In the Server window, switch to "Database" tab
   • •Click "Connect" to initialize SQLite database
   • •Database file location: {ProjectRoot}/.unity-websocket/unity-editor.db
   • •Click "Start Sync" to enable real-time GameObject synchronization (1s interval)
   • •GUID Components: GameObjects are automatically tagged with persistent GUIDs
   • •Multi-scene: All loaded scenes are synchronized automatically
   • •Analytics: View sync stats, database health, and Undo/Redo history
4. •

   Server Status

   • •Port: Auto-assigned from range 9500-9600
   • •Status file: {ProjectRoot}/.unity-websocket/server-status.json
   • •CLI automatically detects correct port from this file
5. •

   Dependencies

   • •websocket-sharp (install via package installation scripts)
   • •Newtonsoft.Json (Unity's built-in version)
   • •Cysharp.UniTask (for async/await database operations)
   • •SQLite-net (embedded SQLite database)

Claude Code Plugin

The Unity Editor Toolkit plugin provides CLI commands for Unity Editor control.

Core Workflow

1. Connection

Unity Editor Toolkit CLI automatically:

• •Detects Unity project via .unity-websocket/server-status.json
• •Reads port information from status file (9500-9600 range)
• •Connects to WebSocket server if Unity Editor is running

2. Execute Commands

⚠️ Before executing ANY command, check the reference documentation for your command category (see "📚 문서 우선 원칙" section above).

Unity Editor Toolkit provides 86+ commands across 15 categories. All commands run from the Unity project root:

cd <unity-project-root> && node .unity-websocket/uw <command> [options]

Available Categories (Implemented):

Usage:

cd <unity-project-root> && node .unity-websocket/uw <command> [options]

Required: Check Documentation

# 1. 먼저 명령어 카테고리의 reference 문서를 읽으세요
# 예: Component 명령어 사용 → skills/references/COMMANDS_COMPONENT.md 읽기

# 2. --help로 명령어 옵션 확인
cd <unity-project-root> && node .unity-websocket/uw --help
cd <unity-project-root> && node .unity-websocket/uw <command> --help

# 3. reference 문서의 예제를 참고하여 실행

📖 Complete Documentation by Category

Required Reading: Before using any command, read the Category-specific reference document:

• •🔴 MUST READ FIRST - COMMANDS.md - Overview and command roadmap
• •🔴 MUST READ - Category-specific docs (links in the table above)
  • •Component Commands - NEW: comp list/add/remove/enable/disable/get/set/inspect/move-up/move-down/copy
  • •GameObject Commands - go find/create/destroy/set-active/set-parent/get-parent/get-children
  • •Transform Commands - tf get/set-position/set-rotation/set-scale
  • •Scene Commands - scene current/list/load/new/save/unload/set-active
  • •Console Commands - console logs/clear
  • •EditorPrefs Commands - prefs get/set/delete/list/clear/import
  • •Other Categories - Full list with all categories

3. Check Connection Status

# Verify WebSocket connection
cd <unity-project-root> && node .unity-websocket/uw status

# Use custom port
cd <unity-project-root> && node .unity-websocket/uw --port 9301 status

4. Complex Workflows

Create and configure GameObject:

cd <unity-project-root> && node .unity-websocket/uw go create "Enemy" && \
cd <unity-project-root> && node .unity-websocket/uw tf set-position "Enemy" "10,0,5" && \
cd <unity-project-root> && node .unity-websocket/uw tf set-rotation "Enemy" "0,45,0"

Load scene and activate GameObject:

cd <unity-project-root> && node .unity-websocket/uw scene load "Level1" && \
cd <unity-project-root> && node .unity-websocket/uw go set-active "Boss" true

Batch GameObject creation:

for i in {1..10}; do
  cd <unity-project-root> && node .unity-websocket/uw go create "Cube_$i" && \
  cd <unity-project-root> && node .unity-websocket/uw tf set-position "Cube_$i" "$i,0,0"
done

Wait for compilation then execute:

# Make code changes, then wait for compilation to finish
cd <unity-project-root> && node .unity-websocket/uw wait compile && \
cd <unity-project-root> && node .unity-websocket/uw editor refresh

Chain multiple commands sequentially:

# Execute commands from JSON file
cd <unity-project-root> && node .unity-websocket/uw chain execute commands.json

# Execute commands inline
cd <unity-project-root> && node .unity-websocket/uw chain exec \
  "GameObject.Create:name=Player" \
  "GameObject.SetActive:instanceId=123,active=true"

# Continue execution even if some commands fail
cd <unity-project-root> && node .unity-websocket/uw chain exec \
  "Editor.Refresh" \
  "GameObject.Find:path=InvalidPath" \
  "Console.Clear" \
  --continue-on-error

CI/CD Pipeline workflow:

#!/bin/bash
cd /path/to/unity/project

# Cleanup
node .unity-websocket/uw.js chain exec "Console.Clear" "Editor.Refresh"

# Wait for compilation
node .unity-websocket/uw.js wait compile

# Run tests (example)
node .unity-websocket/uw.js chain exec \
  "Scene.Load:name=TestScene" \
  "GameObject.Find:path=TestRunner" \
  "Console.Clear"

Best Practices

1. •

   Always Verify Connection

   • •Run cd <unity-project-root> && node .unity-websocket/uw status before executing commands
   • •Ensure Unity Editor is running and server component is active
2. •

   Use Hierarchical Paths

   • •Prefer full paths for nested GameObjects: "Environment/Terrain/Trees"
   • •Avoids ambiguity when multiple GameObjects share the same name
3. •

   Monitor Console Logs

   • •Use cd <unity-project-root> && node .unity-websocket/uw console logs --errors-only to catch errors during automation
   • •Clear console before running automation scripts for clean logs
4. •

   Batch Operations Carefully

   • •Add delays between commands if creating many GameObjects
   • •Consider Unity Editor performance limitations
5. •

   Connection Management

   • •Unity Editor Toolkit uses localhost-only connections (127.0.0.1)
   • •Port range limited to 9500-9600 to avoid conflicts with other tools
6. •

   Error Handling

   • •Commands return JSON-RPC error responses for invalid operations
   • •Check exit codes and error messages in automation scripts
7. •

   Port Management

   • •Default port 9500 works for most projects
   • •Use --port flag if running multiple Unity Editor instances
   • •Plugin avoids conflicts with Browser Pilot (9222-9322) and Blender Toolkit (9400-9500)
8. •

   Wait Commands Usage

   • •Use wait compile after making code changes to ensure compilation finishes
   • •Use wait playmode enter/exit for play mode synchronization in automated tests
   • •Use wait sleep to add delays between commands when needed
   • •Note: Wait commands have delayed responses (default 5-minute timeout)
   • •Domain reload automatically cancels all pending wait requests
9. •

   Chain Commands Best Practices

   • •Use chain for sequential command execution with automatic error handling
   • •Default behavior: stop on first error (use --continue-on-error to override)
   • •Wait commands are NOT supported in chain (use separate wait commands)
   • •Use JSON files for complex multi-step workflows
   • •Use inline exec for quick command sequences
10. •

    Development Roadmap Awareness

• •Phase 2 (Current): 86 commands implemented across 15 categories
• •Phase 3+: Animation, Physics, Lighting, Camera, Audio, Navigation - 400+ commands planned
• •See full roadmap in COMMANDS.md

References

Detailed documentation available in the references/ folder:

• •QUICKSTART.md - Quick setup and first commands (English)
• •QUICKSTART.ko.md - Quick setup guide (Korean)
• •COMMANDS.md - Complete 500+ command roadmap (English)
• •Implemented Command Categories:
  • •Connection & Status
  • •GameObject & Hierarchy
  • •Transform
  • •Component
  • •Scene Management
  • •Asset Database & Editor
  • •Console & Logging
  • •EditorPrefs Management
  • •Wait Commands
  • •Chain Commands
  • •Menu Execution
  • •Asset Management
  • •Prefab
  • •Material
  • •Shader
• •API_COMPATIBILITY.md - Unity version compatibility (2020.3 - Unity 6)
• •TEST_GUIDE.md - Unity C# server testing guide (English)
• •TEST_GUIDE.ko.md - Unity C# server testing guide (Korean)

Unity C# server package available in assets/unity-package/ - install via Unity Package Manager once released.

Status: 🧪 Experimental - Phase 2 (86 commands implemented) Unity Version Support: 2020.3 - Unity 6 Protocol: JSON-RPC 2.0 over WebSocket Port Range: 9500-9600 (auto-assigned)