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

package/dist/proxy/native-proxy.js

@@ -1,7 +1,7 @@
 import { request } from 'node:http';
-import { readFileSync, writeFileSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { CapabilityTokenProvider } from '../automation/capability-token-provider.js';
 import { PACKAGE } from '../constants.js';
@@ -16,7 +16,7 @@ const PLACEHOLDER_TOOL = {
 export function startNativeProxy(options = {}) {
     const upstream = options.upstream ?? process.env.UNREAL_MCP_URL ?? 'http://127.0.0.1:3000/mcp';
     const cacheFile = options.cacheFile ?? process.env.UNREAL_MCP_PROXY_CACHE
-        ?? join(tmpdir(), `unreal-mcp-proxy-${new URL(upstream).port || '80'}.json`);
+        ?? join(process.env.LOCALAPPDATA ?? process.env.XDG_CACHE_HOME ?? join(homedir(), '.cache'), 'unreal-mcp', `proxy-${new URL(upstream).port || '80'}.json`);
     const output = options.output ?? process.stdout;
     const log = new Logger('NativeProxy');
     const tokenProvider = new CapabilityTokenProvider(undefined, log);
@@ -39,7 +39,8 @@ export function startNativeProxy(options = {}) {
     const remember = (patch) => {
         cache = { ...cache, ...patch };
         try {
-            writeFileSync(cacheFile, JSON.stringify(cache));
+            mkdirSync(dirname(cacheFile), { recursive: true, mode: 0o700 });
+            writeFileSync(cacheFile, JSON.stringify(cache), { mode: 0o600 });
         }
         catch (error) {
             log.warn(`cache not written: ${String(error)}`);

package/dist/server/gateway/gateway-execute-dispatch.js

@@ -34,7 +34,8 @@ export function projectCanonicalOutput(result, schema) {
         const details = existing ? { ...existing } : {};
         const fold = (source) => {
             for (const [name, value] of Object.entries(source)) {
-                if (name === 'data' || name === 'requestId' || name === 'type' || name in schema.properties)
+                if (name === 'data' || name === 'requestId' || name === 'type' || name === 'liveRevisions' || name === 'message'
+                    || name in schema.properties)
                     continue;
                 if (!(name in details))
                     details[name] = value;

package/dist/server/gateway/gateway-execute-envelope.js

@@ -162,7 +162,7 @@ export function executeSuccessEnvelope(input, context) {
         capabilityId,
         data: publishedData,
         handles: extractHandles(input.result),
-        changes: extractChanges(input.result),
+        changes: input.record.behavior.effect === 'read' ? [] : extractChanges(input.result),
         task: extractTask(input.result),
         warnings: input.warnings,
         ...correlationFields(context),
@@ -171,9 +171,13 @@ export function executeSuccessEnvelope(input, context) {
         validation: { outputSchema: 'passed' },
         liveRevisions
     });
+    const handlerMessage = typeof input.result === 'object' && input.result !== null && 'message' in input.result
+        ? input.result.message
+        : undefined;
     return definedOnly({
         success: true,
         operation: 'execute',
+        message: typeof handlerMessage === 'string' && handlerMessage !== '' ? redactText(handlerMessage) : undefined,
         correlationId: context.correlationId,
         catalogRevision: catalogRevision(),
         ...capabilityFields(input.record),

package/dist/server/gateway/gateway-execute-lookup.js

@@ -69,7 +69,7 @@ function lookupByLegacyPair(requestedTool, action, index) {
             kind: 'failed',
             failure: {
                 errorCode: 'UNKNOWN_ACTION',
-                message: `Unknown action for ${tool}.${guide.hint} Call describe before execute.`,
+                message: `Unknown action ${action === undefined ? '' : `'${action}' `}for ${tool}.${guide.hint} Call describe before execute.`,
                 availableActions: available,
                 suggestions: guide.suggestions,
                 nextCall: guide.nextCall

package/dist/server/gateway/gateway-execute.js

@@ -10,6 +10,7 @@ import { dispatchAndValidate } from './gateway-execute-dispatch.js';
 import { checkConsentAuthorization, checkExpectedCatalogRevision, checkScopeAuthorization, matchedFoldedGrant } from './gateway-execute-policy.js';
 import { ConsentGrantSchema } from '../../tools/catalog/capabilities/semantic/authorization.js';
 import { buildReceiptContext } from './gateway-receipt-context.js';
+import { noteTaskDone, noteTaskRunning } from './gateway-task-results.js';
 import { conflictMessage, IDEMPOTENCY_CONFLICT_CODE, LOCAL_PRINCIPAL, markReplayed, runWithIdempotency, sharedExecuteLedger } from './gateway-execute-idempotency.js';
 export async function executeGatewayCall(args, context, correlationId) {
     const options = isRecord(args.options) ? args.options : undefined;
@@ -106,7 +107,7 @@ export async function executeGatewayCall(args, context, correlationId) {
             action: target.legacy.action
         })
     }, receiptContext), (recorded) => markReplayed(recorded, receiptContext.correlationId));
-    if (receiptContext.idempotencyId === undefined || checked.timeoutMs !== undefined)
+    if (checked.timeoutMs !== undefined)
         return await settled;
     return await answerWhileRunning(settled, target.record, receiptContext, context);
 }
@@ -119,12 +120,24 @@ async function answerWhileRunning(settled, record, receiptContext, context) {
     const first = await Promise.race([settled, running]).finally(() => clearTimeout(timer));
     if (first !== undefined)
         return first;
-    settled.then((receipt) => context.logger.info(`${record.id} finished after its still-running answer (success=${String(receipt.success)}).`), (error) => context.logger.warn(`${record.id} failed after its still-running answer: ${error instanceof Error ? error.message : String(error)}`));
+    const taskId = receiptContext.correlationId;
+    noteTaskRunning(taskId);
+    settled.then((receipt) => {
+        noteTaskDone(taskId, receipt);
+        context.logger.info(`${record.id} finished after its still-running answer (success=${String(receipt.success)}).`);
+    }, (error) => {
+        const text = error instanceof Error ? error.message : String(error);
+        noteTaskDone(taskId, { success: false, errorCode: 'EXECUTION_ERROR', message: text });
+        context.logger.warn(`${record.id} failed after its still-running answer: ${text}`);
+    });
+    const again = receiptContext.idempotencyId === undefined
+        ? 'do not send this call again: it would run twice.'
+        : 'the same call with the same idempotencyKey also answers with it instead of running again.';
     const message = `Still running after ${STILL_RUNNING_AFTER_MS / 1000} s. Unreal keeps going; this answer does not stop it. `
-        + 'Send this call again with the same idempotencyKey once it is done: it answers with the result instead of running again.';
+        + `Read its result with manage_tools get_task_result taskId ${taskId} once it is done; ${again}`;
     return executeSuccessEnvelope({
         record,
-        result: { success: true, message, task: { taskId: receiptContext.correlationId, state: 'running' } },
+        result: { success: true, message, task: { taskId, state: 'running' } },
         canonicalOutput: { message },
         warnings: []
     }, receiptContext);

package/dist/server/gateway/gateway-schema-validate.js

@@ -131,10 +131,14 @@ function validateObject(value, schema, pointer) {
     if (Array.isArray(schema.required)) {
         for (const name of schema.required) {
             if (typeof name === 'string' && !Object.hasOwn(value, name)) {
+                const stray = schema.additionalProperties === false
+                    ? Object.keys(value).filter((key) => properties === undefined || !Object.hasOwn(properties, key))
+                    : [];
+                const missing = describeMissingParameter(name, properties);
                 return {
                     reason: 'missing-required',
                     pointer: `${pointer}/${name}`,
-                    message: describeMissingParameter(name, properties)
+                    message: stray.length === 0 ? missing : `${missing}; sent ${stray.join(', ')}, which this action does not take`
                 };
             }
         }
@@ -227,9 +231,9 @@ export function applyDeclaredDefaults(params, schema) {
     return withDefaults;
 }
 export const VECTOR_KEY_SETS = [
+    ['pitch', 'yaw', 'roll'],
     ['x', 'y', 'z', 'w'],
     ['x', 'y', 'z'],
-    ['pitch', 'yaw', 'roll'],
     ['r', 'g', 'b', 'a'],
     ['width', 'height'],
     ['x', 'y']
@@ -255,6 +259,11 @@ function objectToVector(value) {
     }
     return undefined;
 }
+function isShadowedByLongerSet(keys, declared) {
+    return VECTOR_KEY_SETS.some((longer) => longer.length > keys.length
+        && keys.every((key) => longer.includes(key))
+        && longer.some((key) => !keys.includes(key) && declared.includes(key)));
+}
 function vectorToObject(values, propertySchema) {
     const declared = isRecord(propertySchema.properties) ? Object.keys(propertySchema.properties) : [];
     if (declared.length === 0)
@@ -263,6 +272,8 @@ function vectorToObject(values, propertySchema) {
         const required = keys.length === 4 ? keys.length - 1 : keys.length;
         if (!keys.slice(0, required).every((key) => declared.includes(key)))
             continue;
+        if (isShadowedByLongerSet(keys, declared))
+            continue;
         const consumed = keys.filter((key) => declared.includes(key));
         if (values.length < required || values.length > consumed.length)
             continue;

package/dist/server/gateway/gateway-task-results.d.ts

@@ -0,0 +1,6 @@
+export declare const MAX_KEPT_TASKS = 32;
+export declare function noteTaskRunning(taskId: string): void;
+export declare function noteTaskDone(taskId: string, reply: Record<string, unknown>): void;
+export declare function describeTask(taskId: string): Record<string, unknown>;
+export declare function resetTasksForTest(): void;
+//# sourceMappingURL=gateway-task-results.d.ts.map

package/dist/server/gateway/gateway-task-results.js

@@ -0,0 +1,40 @@
+import { compactGatewayReply } from '../../utils/responses/gateway-reply-compaction.js';
+export const MAX_KEPT_TASKS = 32;
+const tasks = new Map();
+function remember(taskId, entry) {
+    tasks.delete(taskId);
+    tasks.set(taskId, entry);
+    while (tasks.size > MAX_KEPT_TASKS) {
+        const oldest = tasks.keys().next().value;
+        if (oldest === undefined)
+            break;
+        tasks.delete(oldest);
+    }
+}
+export function noteTaskRunning(taskId) {
+    remember(taskId, { state: 'running' });
+}
+export function noteTaskDone(taskId, reply) {
+    remember(taskId, { state: 'done', reply });
+}
+export function describeTask(taskId) {
+    const entry = tasks.get(taskId);
+    if (entry === undefined) {
+        return {
+            success: false,
+            errorCode: 'TASK_NOT_FOUND',
+            error: `No task ${taskId}: only a call answered "still running" since the server started is kept, the last ${MAX_KEPT_TASKS} of them.`
+        };
+    }
+    if (entry.state === 'running') {
+        return { success: true, taskId, state: 'running', message: `Task ${taskId} is still running.` };
+    }
+    const outcome = { ...compactGatewayReply(entry.reply) };
+    delete outcome.operation;
+    outcome.success = entry.reply.success === true;
+    return { success: true, taskId, state: 'done', outcome, message: `Task ${taskId} is done.` };
+}
+export function resetTasksForTest() {
+    tasks.clear();
+}
+//# sourceMappingURL=gateway-task-results.js.map

package/dist/server/tool-registry-manage-tools.js

@@ -1,6 +1,7 @@
 import { CATALOG_REVISION } from '../tools/catalog/capabilities/generated/canonical-registry.generated.js';
 import { dynamicToolManager } from '../tools/dynamic/dynamic-tool-manager.js';
 import { getString } from './gateway/gateway-shared.js';
+import { describeTask } from './gateway/gateway-task-results.js';
 const VALID_TOOL_CATEGORIES = ['core', 'world', 'gameplay', 'utility', 'all'];
 function getStringArray(args, key) {
     const val = args[key];
@@ -29,6 +30,8 @@ export async function handleManageToolsCall(args) {
             return setCategoryEnabled(args, false);
         case 'get_status':
             return getStatus();
+        case 'get_task_result':
+            return describeTask(getString(args, 'taskId') ?? '');
         case 'reset': {
             const result = dynamicToolManager.reset();
             return {
@@ -40,7 +43,7 @@ export async function handleManageToolsCall(args) {
         default:
             return {
                 success: false,
-                error: `Unknown action: ${action}. Available: list_tools, list_categories, enable_tools, disable_tools, enable_category, disable_category, get_status, reset`,
+                error: `Unknown action: ${action}. Available: list_tools, list_categories, enable_tools, disable_tools, enable_category, disable_category, get_status, get_task_result, reset`,
                 errorCode: 'UNKNOWN_ACTION'
             };
     }

package/dist/tools/catalog/capabilities/generated/canonical-registry.generated.d.ts

@@ -1,6 +1,6 @@
 import type { CapabilityRecord } from '../model.js';
-export declare const CANONICAL_CAPABILITY_RECORD_COUNT = 393;
-export declare const CATALOG_REVISION = "28be41e4be57ba03";
+export declare const CANONICAL_CAPABILITY_RECORD_COUNT = 405;
+export declare const CATALOG_REVISION = "6a9b00e40ef5b820";
 export declare const CANONICAL_CAPABILITY_RECORDS: readonly CapabilityRecord[];
 export type { CapabilityRecord };
 //# sourceMappingURL=canonical-registry.generated.d.ts.map

package/dist/tools/catalog/capabilities/generated/canonical-registry.generated.js

@@ -1,6 +1,6 @@
 import registry from './canonical-registry.generated.json' with { type: 'json' };
 import { parseCapabilityCatalog } from '../parser.js';
-export const CANONICAL_CAPABILITY_RECORD_COUNT = 393;
-export const CATALOG_REVISION = "28be41e4be57ba03";
+export const CANONICAL_CAPABILITY_RECORD_COUNT = 405;
+export const CATALOG_REVISION = "6a9b00e40ef5b820";
 export const CANONICAL_CAPABILITY_RECORDS = parseCapabilityCatalog(registry.records);
 //# sourceMappingURL=canonical-registry.generated.js.map