unreal-engine-mcp-server 0.6.0-beta-e → 0.6.0

package/dist/tools/catalog/capabilities/records/shared/record-presets.js

@@ -1,41 +0,0 @@
-export const SCHEMA_URI = 'https://json-schema.org/draft/2020-12/schema';
-export function schema(properties, required = [], requiredOneOf) {
-    return {
-        $schema: SCHEMA_URI,
-        type: 'object',
-        properties,
-        required: [...required],
-        additionalProperties: false,
-        ...(requiredOneOf === undefined ? {} : { requiredOneOf: [...requiredOneOf] }),
-    };
-}
-const ACTION_PROP = { type: 'string', description: 'The action to execute on the parent tool.' };
-export function actionInputSchema(inputProps, required = [], requiredOneOf) {
-    return schema({ action: ACTION_PROP, ...inputProps }, [...new Set(['action', ...required])], requiredOneOf);
-}
-export const OUTPUT_HEADER = Object.freeze({
-    success: { type: 'boolean', description: 'Whether the action succeeded.' },
-    message: { type: 'string', description: 'Human-readable result message.' },
-    details: { type: 'object', 'x-unreal-reflection-boundary': true, description: 'Additional handler result fields not named by the contract.' },
-});
-export function outputSchema(props, required = []) {
-    return schema({ ...OUTPUT_HEADER, ...props }, ['success', ...required]);
-}
-export const EMPTY_OUTPUT = outputSchema({});
-export function policy(effect) {
-    return {
-        requiredScope: effect,
-        consent: effect === 'destructive' ? 'explicit' : 'none',
-        dataAccess: effect === 'read' ? 'project-read' : 'project-write',
-    };
-}
-export function behavior(effect, opts = {}) {
-    const idempotency = opts.idempotency ?? (effect === 'read' ? 'idempotent' : 'non-idempotent');
-    return {
-        effect,
-        idempotency,
-        longRunning: opts.longRunning ?? false,
-        safeToRetry: opts.safeToRetry ?? (idempotency === 'idempotent' && effect !== 'destructive'),
-    };
-}
-//# sourceMappingURL=record-presets.js.map

package/dist/tools/catalog/capabilities/records/shared/schema-props.d.ts

@@ -1,8 +0,0 @@
-import type { JsonObject } from '../../model.js';
-export declare const str: (desc: string) => JsonObject;
-export declare const num: (desc: string) => JsonObject;
-export declare const bool: (desc: string) => JsonObject;
-export declare const int: (desc: string) => JsonObject;
-export declare const strArr: (itemDesc: string, desc: string) => JsonObject;
-export declare const vec3: (desc: string) => JsonObject;
-//# sourceMappingURL=schema-props.d.ts.map

package/dist/tools/catalog/capabilities/records/shared/schema-props.js

@@ -1,13 +0,0 @@
-export const str = (desc) => ({ type: 'string', description: desc });
-export const num = (desc) => ({ type: 'number', description: desc });
-export const bool = (desc) => ({ type: 'boolean', description: desc });
-export const int = (desc) => ({ type: 'integer', description: desc });
-export const strArr = (itemDesc, desc) => ({ type: 'array', items: str(itemDesc), description: desc });
-export const vec3 = (desc) => ({
-    type: 'array',
-    items: { type: 'number' },
-    minItems: 3,
-    maxItems: 3,
-    description: desc,
-});
-//# sourceMappingURL=schema-props.js.map

package/dist/tools/catalog/capabilities/records/system-control/console.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const CONSOLE_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=console.d.ts.map

package/dist/tools/catalog/capabilities/records/system-control/console.js

@@ -1,149 +0,0 @@
-import { ANY_EDITOR_STATE, buildCoreRecord } from '../core/builder.js';
-const PT = 'system_control';
-export const CONSOLE_RECORDS = [
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'show_fps',
-        domain: 'console',
-        family: 'console',
-        summary: 'Toggle the FPS HUD overlay via the stat fps console command.',
-        whenToUse: ['The frames-per-second counter should be shown or hidden.'],
-        whenNotToUse: ['Detailed per-category stats are needed (use show_stats).'],
-        inputProps: { enabled: { type: 'boolean', description: 'Show (true) or hide (false) the FPS overlay.' } },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'console_command',
-        exampleInput: { action: 'show_fps', enabled: true },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'profile',
-        domain: 'console',
-        family: 'console',
-        summary: 'Toggle a profiling stat display (CPU, GPU, memory, render/game thread) via console command.',
-        whenToUse: ['A specific engine profiling stat overlay must be enabled.'],
-        whenNotToUse: ['A structured profiling capture is needed (use start_profiling).'],
-        inputProps: {
-            profileType: { type: 'string', enum: ['CPU', 'GPU', 'Memory', 'RenderThread', 'GameThread', 'All'], description: 'Profiling domain to display.' },
-            enabled: { type: 'boolean', description: 'Enable (true) or disable (false) the display.' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'console_command',
-        exampleInput: { action: 'profile', profileType: 'GPU' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'set_quality',
-        domain: 'console',
-        family: 'console',
-        summary: 'Set an engine scalability quality CVar (sg.*Quality) for a category and level.',
-        whenToUse: ['A scalability quality group must be changed at runtime.'],
-        whenNotToUse: ['Full scalability state must be set atomically (use set_scalability).'],
-        inputProps: {
-            category: { type: 'string', description: 'Scalability category (shadow, texture, effect, postprocess, foliage, shading, viewdistance, ...).' },
-            level: { type: 'number', description: 'Quality level 0-4 (low to cinematic).' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'console_command',
-        exampleInput: { action: 'set_quality', category: 'shadow', level: 3 },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'execute_command',
-        editorStates: ANY_EDITOR_STATE,
-        domain: 'console',
-        family: 'console',
-        summary: 'Execute a single validated console command string on the engine.',
-        whenToUse: ['An arbitrary console command must be run and its result returned.'],
-        whenNotToUse: ['A dedicated system_control action exists for the operation.'],
-        inputProps: { command: { type: 'string', description: 'The console command string to execute.' } },
-        required: ['command'],
-        effect: 'write',
-        dispatchAction: 'console_command',
-        exampleInput: { action: 'execute_command', command: 'stat unit' },
-        exampleOutput: { success: true, message: 'Command executed', command: 'stat unit', output: 'Stat: 0.5ms' },
-        outputProps: { command: { type: 'string', description: 'The command that was executed.' }, output: { type: 'string', maxLength: 4096, description: 'Bounded console output captured from the command.' } },
-        outputRequired: ['command'],
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'console_command',
-        editorStates: ANY_EDITOR_STATE,
-        domain: 'console',
-        family: 'console',
-        summary: 'Execute a validated, non-empty console command (empty input is rejected).',
-        whenToUse: ['A console command must be run with explicit empty-input rejection.'],
-        whenNotToUse: ['The command is empty or whitespace-only.'],
-        inputProps: { command: { type: 'string', description: 'The non-empty console command to execute.' } },
-        required: ['command'],
-        effect: 'write',
-        dispatchAction: 'console_command',
-        exampleInput: { action: 'console_command', command: 'r.ScreenPercentage 100' },
-        exampleOutput: { success: true, message: 'Command executed', command: 'r.ScreenPercentage 100', output: '' },
-        outputProps: { command: { type: 'string', description: 'The command that was executed.' }, output: { type: 'string', maxLength: 4096, description: 'Bounded console output captured from the command.' } },
-        outputRequired: ['command'],
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'set_cvar',
-        domain: 'console',
-        family: 'console',
-        topics: ['console variable', 'cvar', 'set console variable', 'engine setting', 'rendering setting'],
-        summary: 'Set a console variable value, derived from name/cvar/key/command plus value.',
-        whenToUse: ['A single CVar must be set to a value.'],
-        whenNotToUse: ['The target is a scalability group (use set_quality) or a full command (use execute_command).'],
-        inputProps: {
-            name: { type: 'string', description: 'CVar name (alternatively cvar, key, or command).' },
-            cvar: { type: 'string', description: 'Alternate CVar name field.' },
-            key: { type: 'string', description: 'Alternate CVar name field.' },
-            command: { type: 'string', description: 'Alternate CVar name field (parsed as name + value).' },
-            value: { type: 'string', description: 'Value to assign to the CVar.' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'console_command',
-        exampleInput: { action: 'set_cvar', name: 'r.VSync', value: '1' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'set_resolution',
-        domain: 'console',
-        family: 'console',
-        summary: 'Set the screen resolution via the r.SetRes console command.',
-        whenToUse: ['The editor window resolution must be changed.'],
-        whenNotToUse: ['Only the render resolution scale is needed (use set_resolution_scale).'],
-        inputProps: {
-            resolution: { type: 'string', description: 'Resolution as WxH (e.g. 1920x1080).' },
-            width: { type: 'number', description: 'Width in pixels.' },
-            height: { type: 'number', description: 'Height in pixels.' },
-            windowed: { type: 'boolean', description: 'Windowed (true) or fullscreen (false).' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'console_command',
-        exampleInput: { action: 'set_resolution', width: 1920, height: 1080, windowed: true },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'set_fullscreen',
-        domain: 'console',
-        family: 'console',
-        summary: 'Toggle fullscreen mode via r.SetRes or r.FullScreenMode console command.',
-        whenToUse: ['The editor must switch between windowed and fullscreen modes.'],
-        whenNotToUse: ['A specific resolution is required without mode change (use set_resolution).'],
-        inputProps: {
-            resolution: { type: 'string', description: 'Resolution as WxH (e.g. 1920x1080).' },
-            width: { type: 'number', description: 'Width in pixels.' },
-            height: { type: 'number', description: 'Height in pixels.' },
-            enabled: { type: 'boolean', description: 'Fullscreen (true) or windowed (false).' },
-            windowed: { type: 'boolean', description: 'The inverse of enabled: true for windowed. Refused when it contradicts enabled.' },
-        },
-        required: [],
-        effect: 'write',
-        dispatchAction: 'console_command',
-        exampleInput: { action: 'set_fullscreen', enabled: true, width: 1920, height: 1080 },
-    }),
-];
-//# sourceMappingURL=console.js.map

package/dist/tools/catalog/capabilities/records/system-control/index.d.ts

@@ -1,4 +0,0 @@
-import { type CapabilityRecordSource } from '../../model.js';
-export declare const SYSTEM_CONTROL_UNFOLDED_SOURCES: readonly CapabilityRecordSource[];
-export declare const SYSTEM_CONTROL_SOURCES: readonly CapabilityRecordSource[];
-//# sourceMappingURL=index.d.ts.map

package/dist/tools/catalog/capabilities/records/system-control/index.js

@@ -1,18 +0,0 @@
-import { CONSOLE_RECORDS } from './console.js';
-import { INSIGHTS_RECORDS } from './insights.js';
-import { PERFORMANCE_RECORDS } from './performance.js';
-import { PLUGIN_RECORDS } from './plugins.js';
-import { SYSTEM_OPS_RECORDS } from './system-ops.js';
-import { WIDGET_AUDIO_VIEWPORT_RECORDS } from './widget-audio-viewport.js';
-import { applyFolds } from '../shared/fold.js';
-import { SYSTEM_CONTROL_FOLDS } from '../folds/system-control.folds.js';
-export const SYSTEM_CONTROL_UNFOLDED_SOURCES = [
-    ...CONSOLE_RECORDS,
-    ...PERFORMANCE_RECORDS,
-    ...SYSTEM_OPS_RECORDS,
-    ...PLUGIN_RECORDS,
-    ...INSIGHTS_RECORDS,
-    ...WIDGET_AUDIO_VIEWPORT_RECORDS,
-];
-export const SYSTEM_CONTROL_SOURCES = applyFolds(SYSTEM_CONTROL_UNFOLDED_SOURCES, SYSTEM_CONTROL_FOLDS, 'system_control');
-//# sourceMappingURL=index.js.map

package/dist/tools/catalog/capabilities/records/system-control/insights.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const INSIGHTS_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=insights.d.ts.map

package/dist/tools/catalog/capabilities/records/system-control/insights.js

@@ -1,194 +0,0 @@
-import { buildCoreRecord } from '../core/builder.js';
-const PT = 'system_control';
-const DOM = 'insights';
-const FAM = 'insights';
-export const INSIGHTS_RECORDS = [
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'start_session',
-        domain: DOM,
-        family: FAM,
-        summary: 'Start an Unreal Insights trace session.',
-        whenToUse: ['A new trace session must be started.'],
-        whenNotToUse: ['A session is already running (use pause/resume/stop).'],
-        inputProps: {
-            channels: { type: 'string', description: 'Trace channels (validated: letters, digits, underscore, comma, space, hyphen).' },
-            connectionType: { type: 'string', enum: ['file', 'network'], description: 'Trace connection type; network is restricted to loopback.' },
-            host: { type: 'string', description: 'Trace host (loopback for network).' },
-            port: { type: 'number', description: 'Trace port.' },
-            traceFile: { type: 'string', description: 'File mode: .utrace file name, resolved inside Saved/Profiling (default a generated McpInsights_<time>.utrace).' },
-            overwrite: { type: 'boolean', description: 'Replace an existing trace file of that name (default false: an existing file is refused).' },
-            launchViewer: { type: 'boolean', description: 'Open the Unreal Insights application on the trace: default true for control=launch_viewer (start_unreal_insights), false for the other variants.' },
-        },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        dispatchAction: 'manage_insights',
-        exampleInput: { action: 'start_session', connectionType: 'file' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'start_unreal_insights',
-        domain: DOM,
-        family: FAM,
-        summary: 'Open the Unreal Insights application on a trace: starts a trace session when none is running (the same inputs as start_session) and launches the viewer; pass launchViewer: false to only start the trace.',
-        whenToUse: ['The Insights GUI must be launched for trace analysis.'],
-        whenNotToUse: ['Only a trace session is needed (use start_session).'],
-        inputProps: {
-            channels: { type: 'string', description: 'Trace channels (validated: letters, digits, underscore, comma, space, hyphen).' },
-            connectionType: { type: 'string', enum: ['file', 'network'], description: 'Trace connection type; network is restricted to loopback.' },
-            traceFile: { type: 'string', description: 'File mode: .utrace file name, resolved inside Saved/Profiling (default a generated name).' },
-            host: { type: 'string', description: 'Trace host (loopback for network).' },
-            port: { type: 'number', description: 'Trace port.' },
-            overwrite: { type: 'boolean', description: 'Overwrite existing trace files.' },
-            launchViewer: { type: 'boolean', description: 'Open the Unreal Insights application on the trace: default true for control=launch_viewer (start_unreal_insights), false for the other variants.' },
-        },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        dispatchAction: 'manage_insights',
-        exampleInput: { action: 'start_unreal_insights' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'capture_insights_trace',
-        domain: DOM,
-        family: FAM,
-        summary: 'Capture an Unreal Insights trace to a .utrace file under Saved/Profiling (use start_session for a network trace).',
-        whenToUse: ['A trace must be captured for later analysis.'],
-        whenNotToUse: ['A live session without capture is sufficient (use start_session).'],
-        inputProps: {
-            traceFile: { type: 'string', description: '.utrace file name, resolved inside Saved/Profiling (default a generated name).' },
-            channels: { type: 'string', description: 'Trace channels (validated).' },
-            overwrite: { type: 'boolean', description: 'Overwrite existing trace files.' },
-            launchViewer: { type: 'boolean', description: 'Open the Unreal Insights application on the trace: default true for control=launch_viewer (start_unreal_insights), false for the other variants.' },
-        },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        dispatchAction: 'manage_insights',
-        exampleInput: { action: 'capture_insights_trace', traceFile: 'cap.utrace' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'get_trace_status',
-        domain: DOM,
-        family: FAM,
-        summary: 'Query the current trace session status.',
-        whenToUse: ['The active trace session status must be read.'],
-        whenNotToUse: ['A new session must be started (use start_session).'],
-        inputProps: {},
-        required: [],
-        outputProps: {
-            connected: { type: 'boolean', description: 'Whether a trace consumer is connected.' },
-            destination: { type: 'string', description: 'Trace destination string.' },
-            sessionGuid: { type: 'string', description: 'Session guid (when connected).' },
-            traceGuid: { type: 'string', description: 'Trace guid (when connected).' },
-            activeChannels: { type: 'string', description: 'Active trace channels.' },
-            connectionType: { type: 'string', description: 'Connection type: none, file, network, relay, or secure_network.' },
-            traceSystemStatus: { type: 'string', description: 'Trace system status (e.g. available, tracing_to_file).' },
-            paused: { type: 'boolean', description: 'Whether tracing is paused.' },
-            statusQuerySupported: { type: 'boolean', description: 'Whether this engine version supports status queries.' },
-        },
-        outputRequired: [],
-        effect: 'read',
-        dispatchAction: 'manage_insights',
-        exampleInput: { action: 'get_trace_status' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'pause_session',
-        domain: DOM,
-        family: FAM,
-        summary: 'Pause the active trace session.',
-        whenToUse: ['Trace capture must be temporarily suspended.'],
-        whenNotToUse: ['The session should be stopped entirely (use stop_session).'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        dispatchAction: 'manage_insights',
-        exampleInput: { action: 'pause_session' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'resume_session',
-        domain: DOM,
-        family: FAM,
-        summary: 'Resume a paused trace session.',
-        whenToUse: ['A paused trace session must continue capturing.'],
-        whenNotToUse: ['No session is paused.'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        dispatchAction: 'manage_insights',
-        exampleInput: { action: 'resume_session' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'stop_session',
-        domain: DOM,
-        family: FAM,
-        summary: 'Stop the active trace session.',
-        whenToUse: ['The trace session must be terminated.'],
-        whenNotToUse: ['The session should only be paused (use pause_session).'],
-        inputProps: {},
-        required: [],
-        effect: 'write',
-        dispatchAction: 'manage_insights',
-        exampleInput: { action: 'stop_session' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'write_snapshot',
-        domain: DOM,
-        family: FAM,
-        summary: 'Write a trace snapshot to a snapshot path.',
-        whenToUse: ['A point-in-time trace snapshot must be written to disk.'],
-        whenNotToUse: ['The snapshot should be sent to a running trace (use send_snapshot).'],
-        inputProps: {
-            snapshotPath: { type: 'string', description: 'Snapshot .utrace file name, resolved inside Saved/Profiling (default a generated name).' },
-            overwrite: { type: 'boolean', description: 'Overwrite existing trace files.' },
-        },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        dispatchAction: 'manage_insights',
-        exampleInput: { action: 'write_snapshot', snapshotPath: 'snap.utrace' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'send_snapshot',
-        domain: DOM,
-        family: FAM,
-        summary: 'Send a trace snapshot to a trace server (Unreal Insights) on this machine.',
-        whenToUse: ['A snapshot must be forwarded to an active trace session.'],
-        whenNotToUse: ['The snapshot should be persisted to disk (use write_snapshot).'],
-        inputProps: {
-            host: { type: 'string', description: 'Trace server host, loopback only (default localhost).' },
-            port: { type: 'number', description: 'Trace server port (default the trace system default).' },
-        },
-        required: [],
-        effect: 'write',
-        costLatency: 'interactive',
-        dispatchAction: 'manage_insights',
-        exampleInput: { action: 'send_snapshot' },
-    }),
-    buildCoreRecord({
-        parentTool: PT,
-        action: 'analyze_trace',
-        domain: DOM,
-        family: FAM,
-        summary: 'Read a captured trace file\'s metadata: whether it exists, its size, extension, .utrace flag and modified time.',
-        whenToUse: ['A captured .utrace file must be checked for existence, size and modified time.'],
-        whenNotToUse: ['A live session status is needed (use get_trace_status).'],
-        inputProps: { traceFile: { type: 'string', description: 'Trace file to analyze.' } },
-        required: [],
-        effect: 'read',
-        costLatency: 'interactive',
-        costResources: 'medium',
-        dispatchAction: 'manage_insights',
-        exampleInput: { action: 'analyze_trace', traceFile: 'cap.utrace' },
-    }),
-];
-//# sourceMappingURL=insights.js.map

package/dist/tools/catalog/capabilities/records/system-control/performance.d.ts

@@ -1,3 +0,0 @@
-import type { CapabilityRecordSource } from '../../model.js';
-export declare const PERFORMANCE_RECORDS: readonly CapabilityRecordSource[];
-//# sourceMappingURL=performance.d.ts.map