@directivegames/genesys.sdk 3.2.2

package/src/templates/scripts/genesys/mcp/editor-functions.ts

@@ -0,0 +1,151 @@
+
+import path from 'path';
+
+import * as ENGINE from 'genesys.js';
+import getPort from 'get-port';
+import { nanoid } from 'nanoid';
+import { WebSocket, WebSocketServer } from 'ws';
+import { z } from 'zod';
+
+import { StorageProvider } from '../storageProvider.js';
+
+const clients = new Map<string, WebSocket>();
+
+// prefer 8765 to 8770
+const port = await getPort({port: [8765, 8766, 8767, 8768, 8769, 8770]});
+const wss = new WebSocketServer({ port });
+const portFile = path.join(ENGINE.PROJECT_PATH_PREFIX, `${process.argv[2] ?? ''}.mcp-port`);
+
+wss.on('error', error => {
+  console.error('WebSocket server error:', error);
+});
+
+wss.on('listening', () => {
+  new StorageProvider().uploadFile(ENGINE.AssetPath.fromString(portFile), port.toString());
+});
+
+interface ClientResponse {
+  requestId: string;
+  data: any;
+}
+const pendingRequests = new Map<string, (data: any) => void>();
+
+wss.on('connection', (ws) => {
+  let clientId: string | null = null;
+
+  ws.on('message', (message) => {
+    try {
+      const data = JSON.parse(message.toString());
+
+      // Client registers itself
+      if (data.type === 'register' && typeof data.clientId === 'string') {
+        clientId = data.clientId;
+        clients.set(clientId!, ws);
+        // console.log(`Client registered: ${clientId}`);
+      }
+      else {
+        const resolver = pendingRequests.get(data.requestId);
+        if (resolver) {
+          resolver(data);
+          pendingRequests.delete(data.requestId);
+        }
+      }
+    } catch (err) {
+      // console.error('Invalid message:', message.toString());
+    }
+  });
+
+  ws.on('close', () => {
+    if (clientId) {
+      clients.delete(clientId);
+      // console.log(`Client disconnected: ${clientId}`);
+    }
+  });
+});
+
+// when cursor exits
+process.stdin.on('end', shutdown);
+process.stdin.on('close', shutdown);
+
+// normally when process exits
+process.on('SIGTERM', shutdown);
+process.on('SIGINT', shutdown); // Ctrl+C
+process.on('SIGQUIT', shutdown);
+
+function shutdown() {
+  wss.close(() => {
+    new StorageProvider().deleteFile(ENGINE.AssetPath.fromString(portFile));
+    process.exit(0);
+  });
+
+  wss.clients.forEach((client) => {
+    if (client.readyState === WebSocket.OPEN) {
+      client.terminate(); // force close
+    }
+  });
+  clients.clear();
+}
+
+export const EditorIdSchema = z.string().optional().describe(`
+ID of the editor that should respond.
+If not provided, will proceed if there is only one editor connected, will return error if there are multiple editors connected.
+Can always try without providing this, and only ask the user to provide it if there are multiple editors connected.
+`);
+
+export function getClientWebSocket(editorId?: string | null) {
+  if (clients.size === 0) {
+    throw new Error('No editors connected. Please make sure the Genesys editor is running and connected to the MCP.');
+  }
+
+  const editorIds = Array.from(clients.keys());
+  if (!editorId) {
+    if (clients.size > 1) {
+      throw new Error(`Multiple editors connected, please specify editorId. Available editor IDs: ${editorIds}`);
+    }
+
+    // only one editor connected, use its ID
+    editorId = editorIds[0];
+  }
+
+  const ws = clients.get(editorId);
+  if (ws && ws.readyState === WebSocket.OPEN) {
+    return ws;
+  } else {
+    throw new Error(`Editor with ID ${editorId} is not connected or not ready. Please specify a valid editor ID, available editor IDs: ${editorIds}`);
+  }
+}
+
+
+export async function getCurrentScene(editorId?: string | null): Promise<string> {
+  let ws: WebSocket;
+  try {
+    ws = getClientWebSocket(editorId);
+  }
+  catch (error) {
+    return Promise.reject(error);
+  }
+
+  const requestId = nanoid();
+  const message = {
+    command: 'getCurrentScene',
+    requestId,
+  };
+
+  ws.send(JSON.stringify(message));
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      pendingRequests.delete(requestId);
+      reject(new Error('Timeout waiting for client to response with current scene'));
+    }, 500);  // 500 ms timeout
+
+    pendingRequests.set(requestId, (data: any) => {
+      clearTimeout(timeout);
+      if ('currentScene' in data) {
+        resolve(data.currentScene);
+      } else {
+        reject(new Error('Invalid response from editor'));
+      }
+    });
+  });
+}

package/src/templates/scripts/genesys/mcp/editor-tools.ts

@@ -0,0 +1,73 @@
+
+import { z } from 'zod';
+
+import { EditorIdSchema, getClientWebSocket, getCurrentScene } from './editor-functions.js';
+import { mcpLogger } from './utils.js';
+
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { WebSocket } from 'ws';
+
+
+export function addEditorTools(server: McpServer) {
+  server.registerTool(
+    'selectActors',
+    {
+      description: 'Make the editor to select an actor by its UUID.',
+      inputSchema: {
+        actorIds: z.array(z.string()).describe('UUIDs of the actors to select'),
+        editorId: EditorIdSchema,
+      },
+    },
+    async ({actorIds, editorId}) => {
+      using loggerContext = mcpLogger(server);
+
+      let ws: WebSocket;
+      try {
+        ws = getClientWebSocket(editorId);
+      } catch (error) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: `Error connecting to client: ${error}` }]
+        };
+      }
+
+      ws.send(JSON.stringify({
+        command: 'selectActorsByIds',
+        actorIds
+      }));
+
+      return {
+        content: [{ type: 'text', text: 'Success' }]
+      };
+    }
+  );
+
+
+  server.registerTool(
+    'getCurrentScene',
+    {
+      description: 'Get the current scene opened in the editor.',
+      inputSchema: {
+        editorId: EditorIdSchema
+      }
+    },
+    async ({editorId}) => {
+      using loggerContext = mcpLogger(server);
+
+      try {
+        const currentScene = await getCurrentScene(editorId);
+        return {
+          content: [{ type: 'text', text: `Current scene: ${currentScene}` }]
+        };
+      }
+      catch (error) {
+        return {
+          isError: true,
+          content: [{ type: 'text', text: `Failed to get the current scene: ${error}` }]
+        };
+      }
+    }
+  );
+}
+
+

package/src/templates/scripts/genesys/mcp/get-scene-state.ts

@@ -0,0 +1,35 @@
+import { mockBrowserEnvironment } from '../mock.js';
+
+import { loadWorld } from './utils.js';
+
+
+mockBrowserEnvironment();
+
+export async function getSceneState(sceneName: string, specifiedActors?: string[], getDetailedComponentsInfo?: boolean) {
+  using worldResource = await loadWorld(sceneName, { readonly: true, skipLoadingGLTF: false });
+
+  const world = worldResource.world;
+  return world.describe({specifiedActors, includeComponentsDetails: getDetailedComponentsInfo});
+}
+
+// This foramts the json into a yaml style output, so as to get rid of quotes and braces to hopefully save some tokens
+// it's not much compared to a condensed json output. Not using it for now
+function format(obj: any, indent = 0): string {
+  const spaces = '  '.repeat(indent);
+  if (Array.isArray(obj)) {
+    return obj
+      .map(item => `${spaces}- ${format(item, indent + 1).trimStart()}`)
+      .join('\n');
+  } else if (obj && typeof obj === 'object') {
+    return Object.entries(obj)
+      .map(
+        ([key, value]) =>
+          `${spaces}${key}: ${
+            typeof value === 'object' ? `\n${format(value, indent + 1)}` : value
+          }`
+      )
+      .join('\n');
+  } else {
+    return String(obj);
+  }
+}

package/src/templates/scripts/genesys/mcp/run-subprocess.ts

@@ -0,0 +1,30 @@
+import { fork } from 'child_process';
+import path from 'path';
+
+import { getProjectRoot } from '../common.js';
+
+
+export async function runSubProcess(script: string, params: any): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const worker = fork(path.join(getProjectRoot(), 'scripts', 'mcp', script), { silent: true });
+
+    worker.on('message', (msg: string) => {
+      worker.kill();
+      resolve(msg);
+    });
+
+    worker.on('error', (error) => {
+      console.error('Worker error:', error);
+      worker.kill();
+      reject(error);
+    });
+
+    worker.on('exit', (code) => {
+      if (code !== 0) {
+        reject(new Error(`Worker stopped with exit code ${code}`));
+      }
+    });
+
+    worker.send(params);
+  });
+}