blueprint-extractor-mcp 8.0.1 → 8.1.1

package/README.md

@@ -86,6 +86,10 @@ codex mcp add --env UE_REMOTE_CONTROL_PORT=30010 \
 <tr><td><b>OpenCode</b></td></tr>
 <tr><td>
 
+```bash
+npm install --prefix ~/.config/opencode --save-exact blueprint-extractor-mcp@latest
+```
+
 ```jsonc
 // ~/.config/opencode/opencode.json
 {
@@ -93,7 +97,7 @@ codex mcp add --env UE_REMOTE_CONTROL_PORT=30010 \
   "mcp": {
     "blueprint-extractor": {
       "type": "local",
-      "command": ["npx", "-y", "blueprint-extractor-mcp@latest"],
+      "command": ["/absolute/path/to/.config/opencode/node_modules/.bin/blueprint-extractor-mcp"],
       "enabled": true,
       "environment": {
         "UE_REMOTE_CONTROL_PORT": "30010"
@@ -106,7 +110,7 @@ codex mcp add --env UE_REMOTE_CONTROL_PORT=30010 \
 </td></tr>
 </table>
 
-> On Windows, wrap `npx` with `cmd /c` if your shell requires it.
+> On Windows, point `command` at `C:\Users\you\.config\opencode\node_modules\.bin\blueprint-extractor-mcp.cmd`.
 
 <br>
 

package/dist/helpers/formatting.js

@@ -104,7 +104,7 @@ export function extractExtraContent(result) {
     if (!isPlainObject(result) || !Array.isArray(result.content)) {
         return [];
     }
-    return result.content.filter((candidate) => (isContentBlock(candidate) && candidate.type !== 'text'));
+    return result.content.filter((candidate) => (isContentBlock(candidate)));
 }
 export function maybeBoolean(...values) {
     for (const value of values) {

package/dist/helpers/tool-results.js

@@ -1,5 +1,17 @@
 import { isPlainObject } from './formatting.js';
 export function createToolResultNormalizers({ taskAwareTools, classifyRecoverableToolFailure, }) {
+    function serializeSuccessEnvelope(envelope) {
+        try {
+            return JSON.stringify(envelope);
+        }
+        catch {
+            return JSON.stringify({
+                success: true,
+                operation: typeof envelope.operation === 'string' ? envelope.operation : 'unknown_operation',
+                message: 'Unable to serialize tool result payload.',
+            });
+        }
+    }
     function extractNonTextContent(existingResult) {
         if (!existingResult || !Array.isArray(existingResult.content)) {
             return [];
@@ -132,7 +144,10 @@ export function createToolResultNormalizers({ taskAwareTools, classifyRecoverabl
             ...(taskAwareTools.has(toolName) ? { execution: inferExecutionMetadata(toolName, basePayload) } : {}),
         };
         return {
-            content: extraContent,
+            content: [
+                { type: 'text', text: serializeSuccessEnvelope(envelope) },
+                ...extraContent,
+            ],
             structuredContent: envelope,
         };
     }

package/dist/prompts/prompt-catalog.d.ts

@@ -1,4 +1,4 @@
-import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { McpServer, RegisteredPrompt } from '@modelcontextprotocol/sdk/server/mcp.js';
 import { z } from 'zod';
 export type PromptCatalogEntry = {
     title: string;
@@ -105,4 +105,4 @@ export declare const designSpecSchemaExample: {
     };
 };
 export declare const promptCatalog: Record<string, PromptCatalogEntry>;
-export declare function registerPromptCatalog(server: Pick<McpServer, 'registerPrompt'>): void;
+export declare function registerPromptCatalog(server: Pick<McpServer, 'registerPrompt'>): Map<string, RegisteredPrompt>;

package/dist/prompts/prompt-catalog.js

@@ -342,8 +342,9 @@ export const promptCatalog = {
     },
 };
 export function registerPromptCatalog(server) {
+    const registeredPrompts = new Map();
     for (const [name, prompt] of Object.entries(promptCatalog)) {
-        server.registerPrompt(name, {
+        const registeredPrompt = server.registerPrompt(name, {
             title: prompt.title,
             description: prompt.description,
             argsSchema: prompt.args,
@@ -357,5 +358,7 @@ export function registerPromptCatalog(server) {
                     },
                 }],
         }));
+        registeredPrompts.set(name, registeredPrompt);
     }
+    return registeredPrompts;
 }

package/dist/register-server-resources.d.ts

@@ -1,4 +1,4 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpServer, type RegisteredPrompt } from '@modelcontextprotocol/sdk/server/mcp.js';
 import type { AutomationControllerLike } from './automation-controller.js';
 type JsonSubsystemCaller = (method: string, params: Record<string, unknown>) => Promise<Record<string, unknown>>;
 type RegisterServerResourcesOptions = {
@@ -6,5 +6,8 @@ type RegisterServerResourcesOptions = {
     automationController: AutomationControllerLike;
     callSubsystemJson: JsonSubsystemCaller;
 };
-export declare function registerServerResources({ server, automationController, callSubsystemJson, }: RegisterServerResourcesOptions): void;
+type RegisterServerResourcesResult = {
+    registeredPrompts: Map<string, RegisteredPrompt>;
+};
+export declare function registerServerResources({ server, automationController, callSubsystemJson, }: RegisterServerResourcesOptions): RegisterServerResourcesResult;
 export {};

package/dist/register-server-resources.js

@@ -8,5 +8,6 @@ export function registerServerResources({ server, automationController, callSubs
         automationController,
         callSubsystemJson,
     });
-    registerPromptCatalog(server);
+    const registeredPrompts = registerPromptCatalog(server);
+    return { registeredPrompts };
 }

package/dist/server-factory.js

@@ -39,6 +39,31 @@ export function createBlueprintExtractorServer(client, projectController = new P
         instructions: serverInstructions,
     });
     const defaultOutputSchema = toolResultSchema.catchall(z.unknown());
+    let promptsEnabled = true;
+    function setPromptSurfaceEnabled(registeredPrompts, enabled) {
+        if (promptsEnabled === enabled) {
+            return false;
+        }
+        for (const registeredPrompt of registeredPrompts.values()) {
+            if (enabled) {
+                registeredPrompt.enable();
+            }
+            else {
+                registeredPrompt.disable();
+            }
+        }
+        promptsEnabled = enabled;
+        return true;
+    }
+    function isOpenCodeClient(clientVersion) {
+        if (!clientVersion || typeof clientVersion !== 'object') {
+            return false;
+        }
+        return ['name', 'title', 'description', 'websiteUrl'].some((field) => {
+            const value = clientVersion[field];
+            return typeof value === 'string' && /opencode/i.test(value);
+        });
+    }
     // Direct editor path — preserves callSubsystemJson error-checking layer and
     // avoids recursive executor routing while resolving commandlet fallback inputs.
     const directCallSubsystemJson = (method, params, options) => (callSubsystemJsonWithClient(effectiveClient, method, params, options));
@@ -105,11 +130,14 @@ export function createBlueprintExtractorServer(client, projectController = new P
             workspaceProjectPath: await activeEditorSession?.getWorkspaceProjectPath(),
         });
     }
-    registerServerResources({
+    const { registeredPrompts } = registerServerResources({
         server,
         automationController,
         callSubsystemJson,
     });
+    // OpenCode eagerly fetches every prompt on startup and currently surfaces a
+    // client-side drain-listener warning against larger prompt catalogs.
+    setPromptSurfaceEnabled(registeredPrompts, false);
     registerServerTools({
         server,
         client: effectiveClient,
@@ -200,7 +228,12 @@ export function createBlueprintExtractorServer(client, projectController = new P
     });
     // Wire oninitialized to detect client capabilities
     server.server.oninitialized = () => {
-        const caps = server.server.getClientCapabilities();
+        const lowLevelServer = server.server;
+        const caps = lowLevelServer.getClientCapabilities();
+        const promptSurfaceChanged = setPromptSurfaceEnabled(registeredPrompts, !isOpenCodeClient(lowLevelServer.getClientVersion?.()));
+        if (promptSurfaceChanged && caps?.prompts?.listChanged) {
+            server.sendPromptListChanged();
+        }
         if (caps?.tools?.listChanged) {
             toolSurfaceManager.activateProfile('default');
         }

package/dist/tools/project-control.js

@@ -47,6 +47,9 @@ export function registerProjectControlTools({ server, client, projectController,
         engineRoot: previousEditor?.engineRoot ?? fallback.engineRoot,
         target: previousEditor?.editorTarget ?? fallback.target,
     });
+    const matchesResolvedEditor = (entry, resolved) => (filesystemPathsEqual(entry.projectFilePath, resolved.projectPath)
+        && (!resolved.engineRoot || !entry.engineRoot || filesystemPathsEqual(entry.engineRoot, resolved.engineRoot))
+        && (!resolved.target || !entry.editorTarget || entry.editorTarget === resolved.target));
     const recoverEditorViaHostRelaunch = async (request) => {
         const recovery = {
             strategy: 'host_relaunch_after_failed_graceful_restart',
@@ -452,18 +455,51 @@ export function registerProjectControlTools({ server, client, projectController,
             if (!resolved.engineRoot || !resolved.projectPath) {
                 throw explainProjectResolutionFailure('launch_editor requires engine_root and project_path', resolved);
             }
+            const resolvedProjectPath = resolved.projectPath;
+            const resolvedEngineRoot = resolved.engineRoot;
+            const resolvedTarget = resolved.target;
+            if (activeEditorSession) {
+                const matchingEditors = (await activeEditorSession.listRunningEditors()).filter((entry) => matchesResolvedEditor(entry, {
+                    projectPath: resolvedProjectPath,
+                    engineRoot: resolvedEngineRoot,
+                    target: resolvedTarget,
+                }));
+                if (matchingEditors.length > 1) {
+                    throw new Error(`Multiple running editors already match "${resolvedProjectPath}". `
+                        + 'Call list_running_editors and select_editor instead of launch_editor.');
+                }
+                if (matchingEditors.length === 1) {
+                    try {
+                        const bound = await activeEditorSession.selectEditor({ instanceId: matchingEditors[0].instanceId });
+                        clearProjectAutomationContext();
+                        const activeEditor = toLabeledActiveEditor(bound);
+                        return jsonToolSuccess({
+                            success: true,
+                            operation: 'launch_editor',
+                            launched: false,
+                            reusedExistingEditor: true,
+                            message: 'Bound the existing matching editor instead of launching a new process.',
+                            inputResolution: buildInputResolution(resolved),
+                            activeEditor,
+                        });
+                    }
+                    catch {
+                        // Fall through to a real launch when the registry entry is stale or not yet responsive.
+                    }
+                }
+            }
             const launched = await projectController.launchEditor({
-                engineRoot: resolved.engineRoot,
-                projectPath: resolved.projectPath,
+                engineRoot: resolvedEngineRoot,
+                projectPath: resolvedProjectPath,
             });
             clearProjectAutomationContext();
             let activeEditor;
             if (activeEditorSession) {
                 const bound = await activeEditorSession.bindLaunchedEditor({
                     processId: launched.processId,
-                    projectPath: resolved.projectPath,
-                    engineRoot: resolved.engineRoot,
-                    target: resolved.target,
+                    projectPath: resolvedProjectPath,
+                    engineRoot: resolvedEngineRoot,
+                    target: resolvedTarget,
                     timeoutMs: reconnect_timeout_seconds * 1000,
                 });
                 activeEditor = toLabeledActiveEditor(bound);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blueprint-extractor-mcp",
-  "version": "8.0.1",
+  "version": "8.1.1",
   "description": "MCP server for the Unreal Engine BlueprintExtractor plugin over Remote Control",
   "type": "module",
   "main": "dist/index.js",