unreal-engine-mcp-server 0.4.6 → 0.5.0

package/dist/tools/logs.d.ts

@@ -0,0 +1,45 @@
+import { UnrealBridge } from '../unreal-bridge.js';
+type ReadParams = {
+    filterCategory?: string[];
+    filterLevel?: 'Error' | 'Warning' | 'Log' | 'Verbose' | 'VeryVerbose' | 'All';
+    lines?: number;
+    logPath?: string;
+    includePrefixes?: string[];
+    excludeCategories?: string[];
+};
+type Entry = {
+    timestamp?: string;
+    category?: string;
+    level?: string;
+    message: string;
+};
+export declare class LogTools {
+    private _bridge;
+    private env;
+    private _log;
+    private cachedLogPath?;
+    constructor(_bridge: UnrealBridge);
+    readOutputLog(params: ReadParams): Promise<{
+        success: boolean;
+        error: string;
+        logPath?: undefined;
+        entries?: undefined;
+        filteredCount?: undefined;
+    } | {
+        success: boolean;
+        logPath: string;
+        entries: Entry[];
+        filteredCount: number;
+        error?: undefined;
+    }>;
+    private resolveLogPath;
+    private resolveFromProjectEnv;
+    private findLatestLogInDir;
+    private fileExists;
+    private cacheLogPath;
+    private tailFile;
+    private parseLine;
+    private isInternalLogEntry;
+}
+export {};
+//# sourceMappingURL=logs.d.ts.map

package/dist/tools/logs.js

@@ -0,0 +1,210 @@
+import { loadEnv } from '../types/env.js';
+import { Logger } from '../utils/logger.js';
+import { promises as fs } from 'fs';
+import path from 'path';
+export class LogTools {
+    _bridge;
+    env = loadEnv();
+    _log = new Logger('LogTools');
+    cachedLogPath;
+    constructor(_bridge) {
+        this._bridge = _bridge;
+    }
+    async readOutputLog(params) {
+        this._log.debug('Reading output log', { params, connected: this._bridge.isConnected });
+        const target = await this.resolveLogPath(params.logPath);
+        if (!target) {
+            return { success: false, error: 'Log file not found' };
+        }
+        const maxLines = typeof params.lines === 'number' && params.lines > 0 ? Math.min(params.lines, 2000) : 200;
+        let text = '';
+        try {
+            text = await this.tailFile(target, maxLines);
+        }
+        catch (err) {
+            return { success: false, error: String(err?.message || err) };
+        }
+        const rawLines = text.split(/\r?\n/).filter(l => l.length > 0);
+        const parsed = rawLines.map(l => this.parseLine(l));
+        const mappedLevel = params.filterLevel || 'All';
+        const includeCats = Array.isArray(params.filterCategory) && params.filterCategory.length ? new Set(params.filterCategory) : undefined;
+        const includePrefixes = Array.isArray(params.includePrefixes) && params.includePrefixes.length ? params.includePrefixes : undefined;
+        const excludeCats = Array.isArray(params.excludeCategories) && params.excludeCategories.length ? new Set(params.excludeCategories) : undefined;
+        const filtered = parsed.filter(e => {
+            if (!e)
+                return false;
+            if (mappedLevel && mappedLevel !== 'All') {
+                const lv = (e.level || 'Log');
+                if (lv === 'Display') {
+                    if (mappedLevel !== 'Log')
+                        return false;
+                }
+                else if (lv !== mappedLevel) {
+                    return false;
+                }
+            }
+            if (includeCats && e.category && !includeCats.has(e.category))
+                return false;
+            if (includePrefixes && includePrefixes.length && e.category) {
+                if (!includePrefixes.some(p => (e.category ?? '').startsWith(p)))
+                    return false;
+            }
+            if (excludeCats && e.category && excludeCats.has(e.category))
+                return false;
+            return true;
+        });
+        const includeInternal = Boolean((includeCats && includeCats.has('LogPython')) ||
+            (includePrefixes && includePrefixes.some(p => 'LogPython'.startsWith(p))));
+        const sanitized = includeInternal ? filtered : filtered.filter(entry => !this.isInternalLogEntry(entry));
+        return { success: true, logPath: target.replace(/\\/g, '/'), entries: sanitized, filteredCount: sanitized.length };
+    }
+    async resolveLogPath(override) {
+        if (override && typeof override === 'string' && override.trim()) {
+            try {
+                const st = await fs.stat(override);
+                if (st.isFile()) {
+                    return this.cacheLogPath(path.resolve(override));
+                }
+            }
+            catch { }
+        }
+        if (this.cachedLogPath && (await this.fileExists(this.cachedLogPath))) {
+            return this.cachedLogPath;
+        }
+        const envLog = await this.resolveFromProjectEnv();
+        if (envLog) {
+            return envLog;
+        }
+        const fallback = await this.findLatestLogInDir(path.join(process.cwd(), 'Saved', 'Logs'));
+        if (fallback) {
+            return fallback;
+        }
+        return undefined;
+    }
+    async resolveFromProjectEnv() {
+        const projectPath = this.env.UE_PROJECT_PATH;
+        if (projectPath && typeof projectPath === 'string' && projectPath.trim()) {
+            const projectDir = path.dirname(projectPath);
+            const logsDir = path.join(projectDir, 'Saved', 'Logs');
+            const envLog = await this.findLatestLogInDir(logsDir);
+            if (envLog) {
+                return envLog;
+            }
+        }
+        return undefined;
+    }
+    async findLatestLogInDir(dir) {
+        if (!dir)
+            return undefined;
+        try {
+            const entries = await fs.readdir(dir);
+            const candidates = [];
+            for (const name of entries) {
+                if (!name.toLowerCase().endsWith('.log'))
+                    continue;
+                const fp = path.join(dir, name);
+                try {
+                    const st = await fs.stat(fp);
+                    candidates.push({ p: fp, m: st.mtimeMs });
+                }
+                catch { }
+            }
+            if (candidates.length) {
+                candidates.sort((a, b) => b.m - a.m);
+                return this.cacheLogPath(candidates[0].p);
+            }
+        }
+        catch { }
+        return undefined;
+    }
+    async fileExists(filePath) {
+        try {
+            const st = await fs.stat(filePath);
+            return st.isFile();
+        }
+        catch {
+            return false;
+        }
+    }
+    cacheLogPath(p) {
+        this.cachedLogPath = p;
+        return p;
+    }
+    async tailFile(filePath, maxLines) {
+        const handle = await fs.open(filePath, 'r');
+        try {
+            const stat = await handle.stat();
+            const chunkSize = 128 * 1024;
+            let position = stat.size;
+            let remaining = '';
+            const lines = [];
+            while (position > 0 && lines.length < maxLines) {
+                const readSize = Math.min(chunkSize, position);
+                position -= readSize;
+                const buf = Buffer.alloc(readSize);
+                await handle.read(buf, 0, readSize, position);
+                remaining = buf.toString('utf8') + remaining;
+                const parts = remaining.split(/\r?\n/);
+                remaining = parts.shift() || '';
+                while (parts.length) {
+                    const line = parts.pop();
+                    if (line === undefined)
+                        break;
+                    if (line.length === 0)
+                        continue;
+                    lines.unshift(line);
+                    if (lines.length >= maxLines)
+                        break;
+                }
+            }
+            if (lines.length < maxLines && remaining) {
+                lines.unshift(remaining);
+            }
+            return lines.slice(0, maxLines).join('\n');
+        }
+        finally {
+            try {
+                await handle.close();
+            }
+            catch { }
+        }
+    }
+    parseLine(line) {
+        const m1 = line.match(/^\[?(\d{4}\.\d{2}\.\d{2}-\d{2}\.\d{2}\.\d{2}:\d+)\]?\s*\[(.*?)\]\s*(.*)$/);
+        if (m1) {
+            const rest = m1[3];
+            const m2 = rest.match(/^(\w+):\s*(Error|Warning|Display|Log|Verbose|VeryVerbose):\s*(.*)$/);
+            if (m2) {
+                return { timestamp: m1[1], category: m2[1], level: m2[2] === 'Display' ? 'Log' : m2[2], message: m2[3] };
+            }
+            const m3 = rest.match(/^(\w+):\s*(.*)$/);
+            if (m3) {
+                return { timestamp: m1[1], category: m3[1], level: 'Log', message: m3[2] };
+            }
+            return { timestamp: m1[1], message: rest };
+        }
+        const m = line.match(/^(\w+):\s*(Error|Warning|Display|Log|Verbose|VeryVerbose):\s*(.*)$/);
+        if (m) {
+            return { category: m[1], level: m[2] === 'Display' ? 'Log' : m[2], message: m[3] };
+        }
+        const mAlt = line.match(/^(\w+):\s*(.*)$/);
+        if (mAlt) {
+            return { category: mAlt[1], level: 'Log', message: mAlt[2] };
+        }
+        return { message: line };
+    }
+    isInternalLogEntry(entry) {
+        if (!entry)
+            return false;
+        const category = entry.category?.toLowerCase() || '';
+        const message = entry.message?.trim() || '';
+        if (category === 'logpython' && message.startsWith('RESULT:')) {
+            return true;
+        }
+        if (!entry.category && message.startsWith('[') && message.includes('LogPython: RESULT:')) {
+            return true;
+        }
+        return false;
+    }
+}
+//# sourceMappingURL=logs.js.map

package/dist/tools/materials.d.ts

@@ -1,52 +1,119 @@
 import { UnrealBridge } from '../unreal-bridge.js';
+import { AutomationBridge } from '../automation/index.js';
 export declare class MaterialTools {
     private bridge;
-    constructor(bridge: UnrealBridge);
+    private automationBridge?;
+    constructor(bridge: UnrealBridge, automationBridge?: AutomationBridge | undefined);
+    setAutomationBridge(automationBridge?: AutomationBridge): void;
     createMaterial(name: string, path: string): Promise<{
-        success: boolean;
-        error: string;
-        message?: undefined;
-        path?: undefined;
-        warnings?: undefined;
-        details?: undefined;
-    } | {
         success: boolean;
         error: string;
         message: string;
         path?: undefined;
         warnings?: undefined;
-        details?: undefined;
     } | {
         success: boolean;
-        path: string;
-        message: string;
-        error?: undefined;
-        warnings?: undefined;
-        details?: undefined;
-    } | {
-        success: boolean;
-        path: string;
-        message: string;
-        warnings: string[] | undefined;
-        details: string[] | undefined;
+        path: any;
+        message: any;
+        warnings: any;
         error?: undefined;
     } | {
         success: boolean;
-        error: string;
-        warnings: string[] | undefined;
-        details: string[] | undefined;
+        error: any;
         message?: undefined;
         path?: undefined;
+        warnings?: undefined;
     }>;
     applyMaterialToActor(actorPath: string, materialPath: string, slotIndex?: number): Promise<{
         success: boolean;
         message: string;
+        transport: any;
+        warnings: any[] | undefined;
         error?: undefined;
+    } | {
+        success: boolean;
+        error: any;
+        transport: any;
+        message?: undefined;
+        warnings?: undefined;
     } | {
         success: boolean;
         error: string;
         message?: undefined;
+        transport?: undefined;
+        warnings?: undefined;
     }>;
-    private assetExists;
+    createMaterialInstance(name: string, path: string, parentMaterial: string, parameters?: Record<string, any>): Promise<any>;
+    addNode(params: {
+        materialPath: string;
+        nodeType: string;
+        x: number;
+        y: number;
+        name?: string;
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_MATERIAL_PATH";
+        readonly message: "Material path is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_NODE_TYPE";
+        readonly message: "Node type is required";
+    } | undefined>;
+    removeNode(params: {
+        materialPath: string;
+        nodeId: string;
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_MATERIAL_PATH";
+        readonly message: "Material path is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_NODE_ID";
+        readonly message: "Node ID is required";
+    } | undefined>;
+    connectNodes(params: {
+        materialPath: string;
+        sourceNodeId: string;
+        targetNodeId: string;
+        inputName: string;
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_MATERIAL_PATH";
+        readonly message: "Material path is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_SOURCE_NODE";
+        readonly message: "Source node ID is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_INPUT_NAME";
+        readonly message: "Input name is required";
+    } | undefined>;
+    breakConnections(params: {
+        materialPath: string;
+        nodeId: string;
+        pinName?: string;
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_MATERIAL_PATH";
+        readonly message: "Material path is required";
+    } | {
+        readonly success: false;
+        readonly error: "INVALID_NODE_ID";
+        readonly message: "Node ID is required";
+    } | undefined>;
+    getNodeDetails(params: {
+        materialPath: string;
+        nodeId?: string;
+        timeoutMs?: number;
+    }): Promise<import("../automation/types.js").AutomationBridgeResponseMessage | {
+        readonly success: false;
+        readonly error: "INVALID_MATERIAL_PATH";
+        readonly message: "Material path is required";
+    } | undefined>;
 }
 //# sourceMappingURL=materials.d.ts.map