unreal-engine-mcp-server 0.5.21 → 0.6.0-a

package/dist/tools/handlers/asset-handlers.js

@@ -1,848 +0,0 @@
-import { cleanObject } from '../../utils/safe-json.js';
-import { executeAutomationRequest } from './common-handlers.js';
-import { normalizeArgs, extractString, extractOptionalString, extractOptionalNumber, extractOptionalBoolean, extractOptionalArray } from './argument-helper.js';
-import { ResponseFactory } from '../../utils/response-factory.js';
-import { sanitizePath } from '../../utils/validation.js';
-const VALID_ASSET_ACTIONS = new Set([
-    'list', 'import', 'duplicate', 'rename', 'move', 'delete',
-    'create_folder', 'search_assets', 'get_dependencies', 'validate',
-    'fixup_redirectors', 'find_by_tag', 'exists', 'bulk_rename', 'bulk_delete',
-    'duplicate_asset', 'rename_asset', 'move_asset', 'delete_asset', 'delete_assets',
-    'create_thumbnail', 'set_tags', 'get_metadata', 'set_metadata', 'generate_report',
-    'create_material', 'create_material_instance', 'create_render_target',
-    'generate_lods', 'add_material_parameter', 'list_instances',
-    'reset_instance_parameters', 'get_material_stats', 'nanite_rebuild_mesh',
-    'add_material_node', 'remove_material_node', 'rebuild_material',
-    'connect_material_pins', 'break_material_connections', 'get_material_node_details',
-    'source_control_checkout', 'source_control_submit', 'source_control_enable', 'get_source_control_state',
-    'analyze_graph', 'get_asset_graph'
-]);
-function isValidAssetAction(action) {
-    return VALID_ASSET_ACTIONS.has(action);
-}
-function isPathTraversalAttempt(path) {
-    if (!path || typeof path !== 'string')
-        return false;
-    const normalized = path.toLowerCase();
-    const traversalPatterns = [
-        '../', '..\\',
-        '/etc/', '/proc/', '/sys/',
-        'c:\\', 'c:/',
-        '\\\\', '//',
-        '%2e%2e', '%252e',
-        '....//', '....\\',
-    ];
-    return traversalPatterns.some(pattern => normalized.includes(pattern));
-}
-function validatePathSecurity(pathValue, paramName) {
-    if (!pathValue)
-        return null;
-    if (isPathTraversalAttempt(pathValue)) {
-        return cleanObject({
-            success: false,
-            error: 'SECURITY_VIOLATION',
-            message: `Path traversal attempt detected in ${paramName}. Access denied.`,
-            [paramName]: pathValue
-        });
-    }
-    return null;
-}
-function validatePathsSecurity(paths, paramName) {
-    if (!paths || !Array.isArray(paths))
-        return null;
-    for (const p of paths) {
-        if (isPathTraversalAttempt(p)) {
-            return cleanObject({
-                success: false,
-                error: 'SECURITY_VIOLATION',
-                message: `Path traversal attempt detected in ${paramName}. Access denied.`,
-                [paramName]: paths
-            });
-        }
-    }
-    return null;
-}
-export async function handleAssetTools(action, args, tools) {
-    try {
-        switch (action) {
-            case 'list': {
-                const params = normalizeArgs(args, [
-                    { key: 'path', aliases: ['directory', 'directoryPath', 'assetPath'], default: '/Game' },
-                    { key: 'limit', default: 50 },
-                    { key: 'recursive', aliases: ['recursivePaths'], default: false },
-                    { key: 'depth', default: undefined }
-                ]);
-                let path = extractOptionalString(params, 'path') ?? '/Game';
-                path = sanitizePath(path);
-                const limit = extractOptionalNumber(params, 'limit') ?? 50;
-                const recursive = extractOptionalBoolean(params, 'recursive') ?? false;
-                const depth = extractOptionalNumber(params, 'depth');
-                const effectiveRecursive = recursive === true || (depth !== undefined && depth > 0);
-                const res = await executeAutomationRequest(tools, 'list', {
-                    path,
-                    recursive: effectiveRecursive,
-                    depth
-                });
-                const assets = (Array.isArray(res.assets) ? res.assets :
-                    (Array.isArray(res.result) ? res.result : (res.result?.assets || [])));
-                const folders = Array.isArray(res.folders) ? res.folders : (res.result?.folders || []);
-                const totalCount = assets.length;
-                const limitedAssets = assets.slice(0, limit);
-                const remaining = Math.max(0, totalCount - limit);
-                let message = `Found ${totalCount} assets`;
-                if (folders.length > 0) {
-                    message += ` and ${folders.length} folders`;
-                }
-                message += `: ${limitedAssets.map((a) => a.path || a.package || a.name || 'unknown').join(', ')}`;
-                if (folders.length > 0 && limitedAssets.length < limit) {
-                    const remainingLimit = limit - limitedAssets.length;
-                    if (remainingLimit > 0) {
-                        const limitedFolders = folders.slice(0, remainingLimit);
-                        if (limitedAssets.length > 0)
-                            message += ', ';
-                        message += `Folders: [${limitedFolders.join(', ')}]`;
-                        if (folders.length > remainingLimit)
-                            message += '...';
-                    }
-                }
-                if (remaining > 0) {
-                    message += `... and ${remaining} others`;
-                }
-                return ResponseFactory.success({
-                    assets: limitedAssets,
-                    folders: folders,
-                    totalCount: totalCount,
-                    count: limitedAssets.length
-                }, message);
-            }
-            case 'create_folder': {
-                const params = normalizeArgs(args, [
-                    { key: 'path', aliases: ['directoryPath'], required: true }
-                ]);
-                const folderPath = extractString(params, 'path').trim();
-                if (!folderPath.startsWith('/')) {
-                    return ResponseFactory.error('VALIDATION_ERROR', `Invalid folder path: '${folderPath}'. Path must start with '/'`);
-                }
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    path: folderPath,
-                    subAction: 'create_folder'
-                });
-                return ResponseFactory.success(res, 'Folder created successfully');
-            }
-            case 'import': {
-                const params = normalizeArgs(args, [
-                    { key: 'sourcePath', required: true },
-                    { key: 'destinationPath', required: true },
-                    { key: 'overwrite', default: false },
-                    { key: 'save', default: true }
-                ]);
-                const sourcePath = extractString(params, 'sourcePath');
-                const destinationPath = extractString(params, 'destinationPath');
-                const overwrite = extractOptionalBoolean(params, 'overwrite') ?? false;
-                const save = extractOptionalBoolean(params, 'save') ?? true;
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    sourcePath,
-                    destinationPath,
-                    overwrite,
-                    save,
-                    subAction: 'import'
-                });
-                if (res && typeof res.success === 'boolean' && res.success === false) {
-                    const errorCode = typeof res.error === 'string' ? res.error.toUpperCase() : 'IMPORT_FAILED';
-                    const message = typeof res.message === 'string' ? res.message : 'Asset import failed';
-                    return cleanObject({
-                        success: false,
-                        error: errorCode,
-                        message: message,
-                        sourcePath,
-                        destinationPath,
-                        data: res
-                    });
-                }
-                return ResponseFactory.success(res, 'Asset imported successfully');
-            }
-            case 'duplicate_asset':
-            case 'duplicate': {
-                const params = normalizeArgs(args, [
-                    { key: 'sourcePath', aliases: ['assetPath'], required: true },
-                    { key: 'destinationPath' },
-                    { key: 'newName' }
-                ]);
-                const sourcePath = extractString(params, 'sourcePath');
-                let destinationPath = extractOptionalString(params, 'destinationPath');
-                const newName = extractOptionalString(params, 'newName');
-                if (newName) {
-                    if (!destinationPath) {
-                        const lastSlash = sourcePath.lastIndexOf('/');
-                        const parentDir = lastSlash > 0 ? sourcePath.substring(0, lastSlash) : '/Game';
-                        destinationPath = `${parentDir}/${newName}`;
-                    }
-                    else if (!destinationPath.endsWith(newName)) {
-                        if (destinationPath.endsWith('/')) {
-                            destinationPath = `${destinationPath}${newName}`;
-                        }
-                    }
-                }
-                if (!destinationPath) {
-                    throw new Error('destinationPath or newName is required for duplicate action');
-                }
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    sourcePath,
-                    destinationPath,
-                    subAction: 'duplicate'
-                });
-                return ResponseFactory.success(res, 'Asset duplicated successfully');
-            }
-            case 'rename_asset':
-            case 'rename': {
-                const params = normalizeArgs(args, [
-                    { key: 'sourcePath', aliases: ['assetPath'], required: true },
-                    { key: 'destinationPath' },
-                    { key: 'newName' }
-                ]);
-                const sourcePath = extractString(params, 'sourcePath');
-                let destinationPath = extractOptionalString(params, 'destinationPath');
-                const newName = extractOptionalString(params, 'newName');
-                if (!destinationPath && newName) {
-                    const lastSlash = sourcePath.lastIndexOf('/');
-                    const parentDir = lastSlash > 0 ? sourcePath.substring(0, lastSlash) : '/Game';
-                    destinationPath = `${parentDir}/${newName}`;
-                }
-                if (!destinationPath)
-                    throw new Error('Missing destinationPath or newName');
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    sourcePath,
-                    destinationPath,
-                    subAction: 'rename'
-                });
-                if (res && res.success === false) {
-                    const msg = (res.message || '').toLowerCase();
-                    if (msg.includes('already exists') || msg.includes('exists')) {
-                        return cleanObject({
-                            success: false,
-                            error: 'ASSET_ALREADY_EXISTS',
-                            message: res.message || 'Asset already exists at destination',
-                            sourcePath,
-                            destinationPath
-                        });
-                    }
-                }
-                return cleanObject(res);
-            }
-            case 'move_asset':
-            case 'move': {
-                const params = normalizeArgs(args, [
-                    { key: 'sourcePath', aliases: ['assetPath'], required: true },
-                    { key: 'destinationPath' }
-                ]);
-                const sourcePath = extractString(params, 'sourcePath');
-                let destinationPath = extractOptionalString(params, 'destinationPath');
-                const assetName = sourcePath.split('/').pop();
-                if (assetName && destinationPath && !destinationPath.endsWith(assetName)) {
-                    destinationPath = `${destinationPath.replace(/\/$/, '')}/${assetName}`;
-                }
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    sourcePath,
-                    destinationPath: destinationPath ?? '',
-                    subAction: 'move'
-                });
-                return ResponseFactory.success(res, 'Asset moved successfully');
-            }
-            case 'delete_assets':
-            case 'delete_asset':
-            case 'delete': {
-                let paths = [];
-                const argsTyped = args;
-                if (Array.isArray(argsTyped.paths)) {
-                    paths = argsTyped.paths.filter((p) => typeof p === 'string' && p.trim().length > 0);
-                }
-                else if (Array.isArray(argsTyped.assetPaths) || Array.isArray(argsTyped.asset_paths)) {
-                    paths = (argsTyped.assetPaths || argsTyped.asset_paths);
-                }
-                else {
-                    const single = argsTyped.assetPath || argsTyped.asset_path || argsTyped.path;
-                    if (typeof single === 'string' && single.trim()) {
-                        paths = [single.trim()];
-                    }
-                }
-                if (paths.length === 0) {
-                    return ResponseFactory.error('INVALID_ARGUMENT', 'No paths provided for delete action. Provide assetPath (string) or assetPaths (array).');
-                }
-                const normalizedPaths = paths.map(p => {
-                    let normalized = p.replace(/\\/g, '/').trim();
-                    const lastSlash = normalized.lastIndexOf('/');
-                    if (lastSlash >= 0) {
-                        const afterSlash = normalized.substring(lastSlash + 1);
-                        const dotIndex = afterSlash.indexOf('.');
-                        if (dotIndex > 0) {
-                            normalized = normalized.substring(0, lastSlash + 1 + dotIndex);
-                        }
-                    }
-                    return normalized;
-                });
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    paths: normalizedPaths,
-                    subAction: 'delete'
-                });
-                if (res && typeof res.success === 'boolean' && res.success === false) {
-                    const errorCode = typeof res.error === 'string' ? res.error.toUpperCase() : 'OPERATION_FAILED';
-                    const message = typeof res.message === 'string' ? res.message : 'Asset deletion failed';
-                    return cleanObject({
-                        success: false,
-                        error: errorCode,
-                        message: message,
-                        paths: normalizedPaths,
-                        data: res
-                    });
-                }
-                return ResponseFactory.success(res, 'Assets deleted successfully');
-            }
-            case 'generate_lods': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true },
-                    { key: 'lodCount', required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const lodCount = typeof params.lodCount === 'number' ? params.lodCount : Number(params.lodCount);
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    assetPath,
-                    lodCount,
-                    subAction: 'generate_lods'
-                });
-                return ResponseFactory.success(res, 'LODs generated successfully');
-            }
-            case 'create_thumbnail': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true },
-                    { key: 'width' },
-                    { key: 'height' }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const width = extractOptionalNumber(params, 'width');
-                const height = extractOptionalNumber(params, 'height');
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    assetPath,
-                    width,
-                    height,
-                    subAction: 'generate_thumbnail'
-                });
-                return ResponseFactory.success(res, 'Thumbnail created successfully');
-            }
-            case 'set_tags': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true },
-                    { key: 'tags', required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const tags = extractOptionalArray(params, 'tags') ?? [];
-                if (!assetPath) {
-                    return ResponseFactory.error('INVALID_ARGUMENT', 'assetPath is required');
-                }
-                const res = await executeAutomationRequest(tools, 'set_tags', {
-                    assetPath,
-                    tags
-                });
-                return ResponseFactory.success(res, 'Tags set successfully');
-            }
-            case 'get_metadata': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    assetPath,
-                    subAction: 'get_metadata'
-                });
-                const tags = res.tags || {};
-                const metadata = res.metadata || {};
-                const merged = { ...tags, ...metadata };
-                const tagCount = Object.keys(merged).length;
-                const cleanRes = cleanObject(res);
-                cleanRes.message = `Metadata retrieved (${tagCount} items)`;
-                cleanRes.tags = tags;
-                if (Object.keys(metadata).length > 0) {
-                    cleanRes.metadata = metadata;
-                }
-                return ResponseFactory.success(cleanRes, cleanRes.message);
-            }
-            case 'set_metadata': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true },
-                    { key: 'metadata', required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const metadata = params.metadata;
-                const res = await executeAutomationRequest(tools, 'set_metadata', { ...args, assetPath, metadata });
-                return ResponseFactory.success(res, 'Metadata set successfully');
-            }
-            case 'validate':
-            case 'validate_asset': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    assetPath,
-                    subAction: 'validate'
-                });
-                return ResponseFactory.success(res, 'Asset validation complete');
-            }
-            case 'generate_report': {
-                const params = normalizeArgs(args, [
-                    { key: 'directory' },
-                    { key: 'reportType' },
-                    { key: 'outputPath' }
-                ]);
-                const directory = extractOptionalString(params, 'directory') ?? '';
-                const reportType = extractOptionalString(params, 'reportType');
-                const outputPath = extractOptionalString(params, 'outputPath');
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    directory,
-                    reportType,
-                    outputPath,
-                    subAction: 'generate_report'
-                });
-                return ResponseFactory.success(res, 'Report generated successfully');
-            }
-            case 'create_material_instance': {
-                const params = normalizeArgs(args, [
-                    { key: 'name', required: true },
-                    { key: 'parentMaterial', required: true },
-                    { key: 'savePath', aliases: ['path'] }
-                ]);
-                const name = extractString(params, 'name');
-                const parentMaterial = extractString(params, 'parentMaterial');
-                const savePath = extractOptionalString(params, 'savePath');
-                const res = await executeAutomationRequest(tools, 'create_material_instance', { ...args, name, parentMaterial, savePath }, 'Automation bridge not available for create_material_instance');
-                const result = res ?? {};
-                const errorCode = typeof result.error === 'string' ? result.error.toUpperCase() : '';
-                const message = typeof result.message === 'string' ? result.message : '';
-                const argsTyped = args;
-                if (errorCode === 'PARENT_NOT_FOUND' || message.toLowerCase().includes('parent material not found')) {
-                    return cleanObject({
-                        success: false,
-                        error: 'PARENT_NOT_FOUND',
-                        message: message || 'Parent material not found',
-                        path: result.path,
-                        parentMaterial: argsTyped.parentMaterial
-                    });
-                }
-                return ResponseFactory.success(res, 'Material instance created successfully');
-            }
-            case 'search_assets': {
-                const params = normalizeArgs(args, [
-                    { key: 'searchText' },
-                    { key: 'classNames' },
-                    { key: 'packagePaths' },
-                    { key: 'recursivePaths' },
-                    { key: 'recursiveClasses' },
-                    { key: 'limit' },
-                    { key: 'offset' }
-                ]);
-                const searchText = extractOptionalString(params, 'searchText');
-                const classNames = extractOptionalArray(params, 'classNames');
-                const packagePaths = extractOptionalArray(params, 'packagePaths');
-                const recursivePaths = extractOptionalBoolean(params, 'recursivePaths') ?? (searchText ? true : undefined);
-                const recursiveClasses = extractOptionalBoolean(params, 'recursiveClasses');
-                const limit = extractOptionalNumber(params, 'limit');
-                const offset = extractOptionalNumber(params, 'offset');
-                const pathSecurityError = validatePathsSecurity(packagePaths, 'packagePaths');
-                if (pathSecurityError)
-                    return pathSecurityError;
-                const res = await executeAutomationRequest(tools, 'asset_query', {
-                    searchText,
-                    classNames,
-                    packagePaths,
-                    recursivePaths,
-                    recursiveClasses,
-                    limit,
-                    offset,
-                    subAction: 'search_assets'
-                });
-                return ResponseFactory.success(res, 'Assets found');
-            }
-            case 'find_by_tag': {
-                const params = normalizeArgs(args, [
-                    { key: 'tag', required: true },
-                    { key: 'value' }
-                ]);
-                const tag = extractString(params, 'tag');
-                const value = extractOptionalString(params, 'value');
-                const argsTyped = args;
-                const assetPathCheck = validatePathSecurity(argsTyped.assetPath, 'assetPath');
-                if (assetPathCheck)
-                    return assetPathCheck;
-                const pathCheck = validatePathSecurity(argsTyped.path, 'path');
-                if (pathCheck)
-                    return pathCheck;
-                const res = await executeAutomationRequest(tools, 'asset_query', {
-                    tag,
-                    value,
-                    subAction: 'find_by_tag'
-                });
-                return ResponseFactory.success(res, 'Assets found by tag');
-            }
-            case 'get_dependencies': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true },
-                    { key: 'recursive' }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const recursive = extractOptionalBoolean(params, 'recursive');
-                const res = await executeAutomationRequest(tools, 'manage_asset', {
-                    assetPath,
-                    recursive,
-                    subAction: 'get_dependencies'
-                });
-                return ResponseFactory.success(res, 'Dependencies retrieved');
-            }
-            case 'get_source_control_state': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const res = await executeAutomationRequest(tools, 'asset_query', {
-                    assetPath,
-                    subAction: 'get_source_control_state'
-                });
-                return ResponseFactory.success(res, 'Source control state retrieved');
-            }
-            case 'source_control_enable': {
-                const params = normalizeArgs(args, [
-                    { key: 'provider', default: 'None' }
-                ]);
-                const provider = extractOptionalString(params, 'provider') ?? 'None';
-                const res = await executeAutomationRequest(tools, 'source_control_enable', {
-                    provider
-                });
-                return ResponseFactory.success(res, 'Source control enabled');
-            }
-            case 'analyze_graph': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true },
-                    { key: 'maxDepth' }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const maxDepth = extractOptionalNumber(params, 'maxDepth');
-                const res = await executeAutomationRequest(tools, 'get_asset_graph', {
-                    assetPath,
-                    maxDepth
-                });
-                return ResponseFactory.success(res, 'Graph analysis complete');
-            }
-            case 'create_render_target': {
-                const params = normalizeArgs(args, [
-                    { key: 'name', required: true },
-                    { key: 'packagePath', aliases: ['path'], default: '/Game' },
-                    { key: 'width' },
-                    { key: 'height' },
-                    { key: 'format' }
-                ]);
-                const name = extractString(params, 'name');
-                const packagePath = extractOptionalString(params, 'packagePath') ?? '/Game';
-                const width = extractOptionalNumber(params, 'width');
-                const height = extractOptionalNumber(params, 'height');
-                const format = extractOptionalString(params, 'format');
-                const res = await executeAutomationRequest(tools, 'manage_render', {
-                    subAction: 'create_render_target',
-                    name,
-                    packagePath,
-                    width,
-                    height,
-                    format,
-                    save: true
-                });
-                return ResponseFactory.success(res, 'Render target created successfully');
-            }
-            case 'nanite_rebuild_mesh': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', aliases: ['meshPath'], required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const res = await executeAutomationRequest(tools, 'manage_render', {
-                    subAction: 'nanite_rebuild_mesh',
-                    assetPath
-                });
-                return ResponseFactory.success(res, 'Nanite mesh rebuilt successfully');
-            }
-            case 'fixup_redirectors': {
-                const argsTyped = args;
-                const directoryRaw = typeof argsTyped.directory === 'string' && argsTyped.directory.trim().length > 0
-                    ? argsTyped.directory.trim()
-                    : (typeof argsTyped.directoryPath === 'string' && argsTyped.directoryPath.trim().length > 0
-                        ? argsTyped.directoryPath.trim()
-                        : '');
-                const payload = { ...args };
-                if (directoryRaw) {
-                    payload.directoryPath = directoryRaw;
-                }
-                const res = await executeAutomationRequest(tools, 'fixup_redirectors', payload);
-                return ResponseFactory.success(res, 'Redirectors fixed up successfully');
-            }
-            case 'add_material_parameter': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true },
-                    { key: 'parameterName', aliases: ['name'], required: true },
-                    { key: 'parameterType', aliases: ['type'] },
-                    { key: 'value', aliases: ['defaultValue'] }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const parameterName = extractString(params, 'parameterName');
-                const parameterType = extractOptionalString(params, 'parameterType');
-                const value = params.value;
-                const res = await executeAutomationRequest(tools, 'add_material_parameter', {
-                    assetPath,
-                    name: parameterName,
-                    type: parameterType,
-                    value
-                });
-                return ResponseFactory.success(res, 'Material parameter added successfully');
-            }
-            case 'list_instances': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const res = await executeAutomationRequest(tools, 'list_instances', {
-                    assetPath
-                });
-                return ResponseFactory.success(res, 'Instances listed successfully');
-            }
-            case 'reset_instance_parameters': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const res = await executeAutomationRequest(tools, 'reset_instance_parameters', {
-                    assetPath
-                });
-                return ResponseFactory.success(res, 'Instance parameters reset successfully');
-            }
-            case 'exists': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const res = await executeAutomationRequest(tools, 'exists', {
-                    assetPath
-                });
-                return ResponseFactory.success(res, 'Asset existence check complete');
-            }
-            case 'get_material_stats': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const res = await executeAutomationRequest(tools, 'get_material_stats', {
-                    assetPath
-                });
-                return ResponseFactory.success(res, 'Material stats retrieved');
-            }
-            case 'add_material_node': {
-                const materialNodeAliases = {
-                    'Multiply': 'MaterialExpressionMultiply',
-                    'Add': 'MaterialExpressionAdd',
-                    'Subtract': 'MaterialExpressionSubtract',
-                    'Divide': 'MaterialExpressionDivide',
-                    'Power': 'MaterialExpressionPower',
-                    'Clamp': 'MaterialExpressionClamp',
-                    'Constant': 'MaterialExpressionConstant',
-                    'Constant2Vector': 'MaterialExpressionConstant2Vector',
-                    'Constant3Vector': 'MaterialExpressionConstant3Vector',
-                    'Constant4Vector': 'MaterialExpressionConstant4Vector',
-                    'TextureSample': 'MaterialExpressionTextureSample',
-                    'TextureCoordinate': 'MaterialExpressionTextureCoordinate',
-                    'Panner': 'MaterialExpressionPanner',
-                    'Rotator': 'MaterialExpressionRotator',
-                    'Lerp': 'MaterialExpressionLinearInterpolate',
-                    'LinearInterpolate': 'MaterialExpressionLinearInterpolate',
-                    'Sine': 'MaterialExpressionSine',
-                    'Cosine': 'MaterialExpressionCosine',
-                    'Append': 'MaterialExpressionAppendVector',
-                    'AppendVector': 'MaterialExpressionAppendVector',
-                    'ComponentMask': 'MaterialExpressionComponentMask',
-                    'Fresnel': 'MaterialExpressionFresnel',
-                    'Time': 'MaterialExpressionTime',
-                    'ScalarParameter': 'MaterialExpressionScalarParameter',
-                    'VectorParameter': 'MaterialExpressionVectorParameter',
-                    'StaticSwitchParameter': 'MaterialExpressionStaticSwitchParameter'
-                };
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', aliases: ['materialPath'], required: true },
-                    { key: 'nodeType', aliases: ['type'], required: true, map: materialNodeAliases },
-                    { key: 'posX' },
-                    { key: 'posY' }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const nodeType = extractString(params, 'nodeType');
-                const posX = extractOptionalNumber(params, 'posX');
-                const posY = extractOptionalNumber(params, 'posY');
-                const res = await executeAutomationRequest(tools, 'add_material_node', {
-                    assetPath,
-                    nodeType,
-                    posX,
-                    posY
-                });
-                return ResponseFactory.success(res, 'Material node added successfully');
-            }
-            case 'connect_material_pins': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', aliases: ['materialPath'], required: true },
-                    { key: 'sourceNodeId', aliases: ['sourceNode'], required: true },
-                    { key: 'sourcePin', aliases: ['fromPin', 'outputPin'], required: true },
-                    { key: 'targetNodeId', aliases: ['targetNode'], required: true },
-                    { key: 'targetPin', aliases: ['toPin', 'inputPin'], required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const sourceNodeId = extractString(params, 'sourceNodeId');
-                const sourcePin = extractString(params, 'sourcePin');
-                const targetNodeId = extractString(params, 'targetNodeId');
-                const targetPin = extractString(params, 'targetPin');
-                const res = await executeAutomationRequest(tools, 'connect_material_pins', {
-                    assetPath,
-                    sourceNodeId,
-                    sourcePin,
-                    targetNodeId,
-                    targetPin
-                });
-                return ResponseFactory.success(res, 'Material pins connected successfully');
-            }
-            case 'remove_material_node': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', aliases: ['materialPath'], required: true },
-                    { key: 'nodeId', required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const nodeId = extractString(params, 'nodeId');
-                const res = await executeAutomationRequest(tools, 'remove_material_node', {
-                    assetPath,
-                    nodeId
-                });
-                return ResponseFactory.success(res, 'Material node removed successfully');
-            }
-            case 'break_material_connections': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', aliases: ['materialPath'], required: true },
-                    { key: 'nodeId' },
-                    { key: 'pinName' }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const nodeId = extractOptionalString(params, 'nodeId');
-                const pinName = extractOptionalString(params, 'pinName');
-                const res = await executeAutomationRequest(tools, 'break_material_connections', {
-                    assetPath,
-                    nodeId,
-                    pinName
-                });
-                return ResponseFactory.success(res, 'Material connections broken successfully');
-            }
-            case 'get_material_node_details': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', aliases: ['materialPath'], required: true },
-                    { key: 'nodeId', required: false },
-                    { key: 'expressionIndex' }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const nodeId = extractOptionalString(params, 'nodeId');
-                const expressionIndex = extractOptionalNumber(params, 'expressionIndex');
-                const res = await executeAutomationRequest(tools, 'get_material_node_details', {
-                    assetPath,
-                    nodeId,
-                    expressionIndex
-                });
-                return ResponseFactory.success(res, 'Material node details retrieved');
-            }
-            case 'rebuild_material': {
-                const params = normalizeArgs(args, [
-                    { key: 'assetPath', aliases: ['materialPath'], required: true }
-                ]);
-                const assetPath = extractString(params, 'assetPath');
-                const res = await executeAutomationRequest(tools, 'rebuild_material', {
-                    assetPath
-                });
-                return ResponseFactory.success(res, 'Material rebuilt successfully');
-            }
-            case 'bulk_rename': {
-                const argsTyped = args;
-                const folderPath = argsTyped.folderPath ?? argsTyped.path;
-                const assetPaths = argsTyped.assetPaths ?? argsTyped.paths;
-                const folderPathSecurity = validatePathSecurity(typeof folderPath === 'string' ? folderPath : undefined, 'folderPath');
-                if (folderPathSecurity)
-                    return folderPathSecurity;
-                const pathParamSecurity = validatePathSecurity(typeof argsTyped.path === 'string' ? argsTyped.path : undefined, 'path');
-                if (pathParamSecurity)
-                    return pathParamSecurity;
-                const assetPathsSecurity = validatePathsSecurity(assetPaths, 'assetPaths');
-                if (assetPathsSecurity)
-                    return assetPathsSecurity;
-                if (!folderPath && (!assetPaths || (Array.isArray(assetPaths) && assetPaths.length === 0))) {
-                    return ResponseFactory.error('INVALID_ARGUMENT', 'Either folderPath or assetPaths is required for bulk_rename');
-                }
-                const res = await executeAutomationRequest(tools, 'bulk_rename', {
-                    folderPath,
-                    assetPaths,
-                    searchText: argsTyped.pattern,
-                    replaceText: argsTyped.replacement,
-                    prefix: argsTyped.prefix,
-                    suffix: argsTyped.suffix
-                });
-                return ResponseFactory.success(res, 'Bulk rename completed');
-            }
-            case 'bulk_delete': {
-                const argsTyped = args;
-                const folderPath = argsTyped.folderPath ?? argsTyped.path;
-                const assetPaths = argsTyped.assetPaths ?? argsTyped.paths;
-                if (!folderPath && (!assetPaths || (Array.isArray(assetPaths) && assetPaths.length === 0))) {
-                    return ResponseFactory.error('INVALID_ARGUMENT', 'Either folderPath or assetPaths is required for bulk_delete');
-                }
-                const res = await executeAutomationRequest(tools, 'bulk_delete', {
-                    ...args,
-                    folderPath,
-                    assetPaths
-                });
-                return ResponseFactory.success(res, 'Bulk delete completed');
-            }
-            default: {
-                if (!isValidAssetAction(action)) {
-                    return cleanObject({
-                        success: false,
-                        error: 'UNKNOWN_ACTION',
-                        message: `Unknown asset action: ${action}. Valid actions are: ${Array.from(VALID_ASSET_ACTIONS).join(', ')}`,
-                        action: action || 'manage_asset',
-                        assetPath: args.assetPath ?? args.path
-                    });
-                }
-                const res = await executeAutomationRequest(tools, action || 'manage_asset', { ...args, subAction: action });
-                const result = res ?? {};
-                const errorCode = typeof result.error === 'string' ? result.error.toUpperCase() : '';
-                const message = typeof result.message === 'string' ? result.message : '';
-                const argsTyped = args;
-                if (errorCode === 'UNKNOWN_ACTION' || errorCode === 'INVALID_SUBACTION' ||
-                    message.toLowerCase().includes('unknown action') || message.toLowerCase().includes('unknown subaction')) {
-                    return cleanObject({
-                        success: false,
-                        error: 'UNKNOWN_ACTION',
-                        message: `Unknown asset action: ${action}`,
-                        action: action || 'manage_asset',
-                        assetPath: argsTyped.assetPath ?? argsTyped.path
-                    });
-                }
-                if (typeof result.success === 'boolean' && result.success === false) {
-                    return cleanObject({
-                        success: false,
-                        error: errorCode || 'OPERATION_FAILED',
-                        message: message || 'Asset operation failed',
-                        action: action || 'manage_asset',
-                        assetPath: argsTyped.assetPath ?? argsTyped.path,
-                        data: result
-                    });
-                }
-                return ResponseFactory.success(res, 'Asset action executed successfully');
-            }
-        }
-    }
-    catch (error) {
-        return ResponseFactory.error(error);
-    }
-}
-//# sourceMappingURL=asset-handlers.js.map