robloxstudio-mcp 2.6.0-next.1 → 2.6.0-next.2

package/dist/index.js

@@ -100,14 +100,17 @@ var init_install_plugin = __esm({
 });
 
 // ../core/dist/server.js
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { Server as Server2 } from "@modelcontextprotocol/sdk/server/index.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
+import { CallToolRequestSchema as CallToolRequestSchema2, ErrorCode as ErrorCode2, ListToolsRequestSchema as ListToolsRequestSchema2, McpError as McpError2 } from "@modelcontextprotocol/sdk/types.js";
 
 // ../core/dist/http-server.js
 import express from "express";
 import cors from "cors";
 import http from "http";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import { CallToolRequestSchema, ErrorCode, ListToolsRequestSchema, McpError } from "@modelcontextprotocol/sdk/types.js";
 var TOOL_HANDLERS = {
   get_file_tree: (tools, body) => tools.getFileTree(body.path),
   search_files: (tools, body) => tools.searchFiles(body.query, body.searchType),
@@ -155,10 +158,11 @@ var TOOL_HANDLERS = {
   remove_tag: (tools, body) => tools.removeTag(body.instancePath, body.tagName),
   get_tagged: (tools, body) => tools.getTagged(body.tagName),
   get_selection: (tools) => tools.getSelection(),
-  execute_luau: (tools, body) => tools.executeLuau(body.code),
-  start_playtest: (tools, body) => tools.startPlaytest(body.mode),
+  execute_luau: (tools, body) => tools.executeLuau(body.code, body.target),
+  start_playtest: (tools, body) => tools.startPlaytest(body.mode, body.numPlayers),
   stop_playtest: (tools) => tools.stopPlaytest(),
-  get_playtest_output: (tools) => tools.getPlaytestOutput(),
+  get_playtest_output: (tools, body) => tools.getPlaytestOutput(body.target),
+  get_connected_instances: (tools) => tools.getConnectedInstances(),
   export_build: (tools, body) => tools.exportBuild(body.instancePath, body.outputId, body.style),
   create_build: (tools, body) => tools.createBuild(body.id, body.style, body.palette, body.parts, body.bounds),
   generate_build: (tools, body) => tools.generateBuild(body.id, body.style, body.palette, body.code, body.seed),
@@ -204,15 +208,24 @@ var TOOL_HANDLERS = {
     padding: body.padding,
     backdropColor: body.backdropColor
   }),
-  capture_screenshot: (tools) => tools.captureScreenshot()
+  capture_screenshot: (tools) => tools.captureScreenshot(),
+  simulate_mouse_input: (tools, body) => tools.simulateMouseInput(body.action, body.x, body.y, body.button, body.scrollDirection, body.target),
+  simulate_keyboard_input: (tools, body) => tools.simulateKeyboardInput(body.keyCode, body.action, body.duration, body.target),
+  character_navigation: (tools, body) => tools.characterNavigation(body.position, body.instancePath, body.waitForCompletion, body.timeout, body.target),
+  find_and_replace_in_scripts: (tools, body) => tools.findAndReplaceInScripts(body.pattern, body.replacement, {
+    caseSensitive: body.caseSensitive,
+    usePattern: body.usePattern,
+    path: body.path,
+    classFilter: body.classFilter,
+    dryRun: body.dryRun,
+    maxReplacements: body.maxReplacements
+  })
 };
-function createHttpServer(tools, bridge, allowedTools) {
+function createHttpServer(tools, bridge, allowedTools, serverConfig) {
   const app = express();
-  let pluginConnected = false;
   let mcpServerActive = false;
   let lastMCPActivity = 0;
   let mcpServerStartTime = 0;
-  let lastPluginActivity = 0;
   const proxyInstances = /* @__PURE__ */ new Set();
   const setMCPServerActive = (active) => {
     mcpServerActive = active;
@@ -235,44 +248,78 @@ function createHttpServer(tools, bridge, allowedTools) {
     return Date.now() - lastMCPActivity < 3e4;
   };
   const isPluginConnected = () => {
-    return pluginConnected && Date.now() - lastPluginActivity < 3e4;
+    return bridge.getInstances().length > 0;
   };
   app.use(cors());
   app.use(express.json({ limit: "50mb" }));
   app.use(express.urlencoded({ limit: "50mb", extended: true }));
   app.get("/health", (req, res) => {
+    const instances = bridge.getInstances();
     res.json({
       status: "ok",
       service: "robloxstudio-mcp",
-      pluginConnected,
+      version: serverConfig?.version,
+      pluginConnected: instances.length > 0,
+      instanceCount: instances.length,
+      instances: instances.map((i) => ({
+        instanceId: i.instanceId,
+        role: i.role,
+        lastActivity: i.lastActivity,
+        connectedAt: i.connectedAt
+      })),
       mcpServerActive: isMCPServerActive(),
       uptime: mcpServerActive ? Date.now() - mcpServerStartTime : 0,
-      proxyInstanceCount: proxyInstances.size
+      pendingRequests: bridge.getPendingRequestCount(),
+      proxyInstanceCount: proxyInstances.size,
+      streamableHttp: !!serverConfig
     });
   });
   app.post("/ready", (req, res) => {
-    pluginConnected = true;
-    lastPluginActivity = Date.now();
-    res.json({ success: true });
+    const { instanceId, role } = req.body;
+    if (instanceId && role) {
+      const assignedRole = bridge.registerInstance(instanceId, role);
+      res.json({ success: true, assignedRole });
+    } else {
+      bridge.registerInstance("legacy", "edit");
+      res.json({ success: true, assignedRole: "edit" });
+    }
   });
   app.post("/disconnect", (req, res) => {
-    pluginConnected = false;
-    bridge.clearAllPendingRequests();
+    const { instanceId } = req.body;
+    if (instanceId) {
+      bridge.unregisterInstance(instanceId);
+    } else {
+      bridge.unregisterInstance("legacy");
+      bridge.clearAllPendingRequests();
+    }
     res.json({ success: true });
   });
   app.get("/status", (req, res) => {
+    const instances = bridge.getInstances();
     res.json({
-      pluginConnected: isPluginConnected(),
+      pluginConnected: instances.length > 0,
+      instanceCount: instances.length,
+      instances: instances.map((i) => ({ instanceId: i.instanceId, role: i.role })),
       mcpServerActive: isMCPServerActive(),
       lastMCPActivity,
       uptime: mcpServerActive ? Date.now() - mcpServerStartTime : 0
     });
   });
+  app.get("/instances", (req, res) => {
+    res.json({ instances: bridge.getInstances() });
+  });
   app.get("/poll", (req, res) => {
-    if (!pluginConnected) {
-      pluginConnected = true;
+    const instanceId = req.query.instanceId;
+    if (instanceId) {
+      bridge.updateInstanceActivity(instanceId);
+    }
+    let callerRole = "edit";
+    if (instanceId) {
+      const inst = bridge.getInstances().find((i) => i.instanceId === instanceId);
+      if (inst) {
+        callerRole = inst.role;
+      }
     }
-    lastPluginActivity = Date.now();
     if (!isMCPServerActive()) {
       res.status(503).json({
         error: "MCP server not connected",
@@ -282,7 +329,7 @@ function createHttpServer(tools, bridge, allowedTools) {
       });
       return;
     }
-    const pendingRequest = bridge.getPendingRequest();
+    const pendingRequest = bridge.getPendingRequest(callerRole);
     if (pendingRequest) {
       res.json({
         request: pendingRequest.request,
@@ -310,7 +357,7 @@ function createHttpServer(tools, bridge, allowedTools) {
     res.json({ success: true });
   });
   app.post("/proxy", async (req, res) => {
-    const { endpoint, data, proxyInstanceId } = req.body;
+    const { endpoint, data, target, proxyInstanceId } = req.body;
     if (!endpoint) {
       res.status(400).json({ error: "endpoint is required" });
       return;
@@ -319,12 +366,76 @@ function createHttpServer(tools, bridge, allowedTools) {
       proxyInstances.add(proxyInstanceId);
     }
     try {
-      const response = await bridge.sendRequest(endpoint, data);
+      const response = await bridge.sendRequest(endpoint, data, target || "edit");
       res.json({ response });
     } catch (err) {
       res.status(500).json({ error: err.message || "Proxy request failed" });
     }
   });
+  if (serverConfig) {
+    const filteredTools = serverConfig.tools.filter((t) => !allowedTools || allowedTools.has(t.name));
+    app.post("/mcp", async (req, res) => {
+      try {
+        trackMCPActivity();
+        const server = new Server({ name: serverConfig.name, version: serverConfig.version }, { capabilities: { tools: {} } });
+        server.setRequestHandler(ListToolsRequestSchema, async () => ({
+          tools: filteredTools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            inputSchema: t.inputSchema
+          }))
+        }));
+        server.setRequestHandler(CallToolRequestSchema, async (request) => {
+          const { name, arguments: args } = request.params;
+          if (allowedTools && !allowedTools.has(name)) {
+            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+          }
+          const handler = TOOL_HANDLERS[name];
+          if (!handler) {
+            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+          }
+          try {
+            return await handler(tools, args || {});
+          } catch (error) {
+            if (error instanceof McpError)
+              throw error;
+            throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
+          }
+        });
+        const transport = new StreamableHTTPServerTransport({
+          sessionIdGenerator: void 0
+        });
+        await server.connect(transport);
+        await transport.handleRequest(req, res, req.body);
+        res.on("close", () => {
+          transport.close();
+          server.close();
+        });
+      } catch (error) {
+        if (!res.headersSent) {
+          res.status(500).json({
+            jsonrpc: "2.0",
+            error: { code: -32603, message: "Internal server error" },
+            id: null
+          });
+        }
+      }
+    });
+    app.get("/mcp", (req, res) => {
+      res.writeHead(405).end(JSON.stringify({
+        jsonrpc: "2.0",
+        error: { code: -32e3, message: "Method not allowed." },
+        id: null
+      }));
+    });
+    app.delete("/mcp", (req, res) => {
+      res.writeHead(405).end(JSON.stringify({
+        jsonrpc: "2.0",
+        error: { code: -32e3, message: "Method not allowed." },
+        id: null
+      }));
+    });
+  }
   app.use("/mcp/*", (req, res, next) => {
     trackMCPActivity();
     next();
@@ -388,9 +499,9 @@ var StudioHttpClient = class {
   constructor(bridge) {
     this.bridge = bridge;
   }
-  async request(endpoint, data) {
+  async request(endpoint, data, target = "edit") {
     try {
-      const response = await this.bridge.sendRequest(endpoint, data);
+      const response = await this.bridge.sendRequest(endpoint, data, target);
       return response;
     } catch (error) {
       if (error instanceof Error && error.message === "Request timeout") {
@@ -1027,9 +1138,11 @@ function resolveSingleRenderSavePath(instancePath, instanceName, options) {
 }
 var RobloxStudioTools = class _RobloxStudioTools {
   client;
+  bridge;
   openCloudClient;
   constructor(bridge) {
     this.client = new StudioHttpClient(bridge);
+    this.bridge = bridge;
     this.openCloudClient = new OpenCloudClient();
   }
   async getFileTree(path2 = "") {
@@ -1548,11 +1661,11 @@ var RobloxStudioTools = class _RobloxStudioTools {
       ]
     };
   }
-  async executeLuau(code) {
+  async executeLuau(code, target) {
     if (!code) {
       throw new Error("Code is required for execute_luau");
     }
-    const response = await this.client.request("/api/execute-luau", { code });
+    const response = await this.client.request("/api/execute-luau", { code }, target || "edit");
     return {
       content: [
         {
@@ -1562,11 +1675,15 @@ var RobloxStudioTools = class _RobloxStudioTools {
       ]
     };
   }
-  async startPlaytest(mode) {
+  async startPlaytest(mode, numPlayers) {
     if (mode !== "play" && mode !== "run") {
       throw new Error('mode must be "play" or "run"');
     }
-    const response = await this.client.request("/api/start-playtest", { mode });
+    const data = { mode };
+    if (numPlayers !== void 0) {
+      data.numPlayers = numPlayers;
+    }
+    const response = await this.client.request("/api/start-playtest", data);
     return {
       content: [
         {
@@ -1587,8 +1704,8 @@ var RobloxStudioTools = class _RobloxStudioTools {
       ]
     };
   }
-  async getPlaytestOutput() {
-    const response = await this.client.request("/api/get-playtest-output", {});
+  async getPlaytestOutput(target) {
+    const response = await this.client.request("/api/get-playtest-output", {}, target || "edit");
     return {
       content: [
         {
@@ -1598,6 +1715,17 @@ var RobloxStudioTools = class _RobloxStudioTools {
       ]
     };
   }
+  async getConnectedInstances() {
+    const instances = this.bridge.getInstances();
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ instances, count: instances.length })
+        }
+      ]
+    };
+  }
   async undo() {
     const response = await this.client.request("/api/undo", {});
     return {
@@ -2209,7 +2337,7 @@ var RobloxStudioTools = class _RobloxStudioTools {
   async batchRenderModels(parentPath, outputDir, options) {
     return this.batchRenderObjects(parentPath, outputDir, options);
   }
-  async simulateMouseInput(action, x, y, button, scrollDirection) {
+  async simulateMouseInput(action, x, y, button, scrollDirection, target) {
     if (!action) {
       throw new Error("action is required for simulate_mouse_input");
     }
@@ -2219,7 +2347,7 @@ var RobloxStudioTools = class _RobloxStudioTools {
       y,
       button,
       scrollDirection
-    });
+    }, target || "edit");
     return {
       content: [{
         type: "text",
@@ -2227,7 +2355,7 @@ var RobloxStudioTools = class _RobloxStudioTools {
       }]
     };
   }
-  async simulateKeyboardInput(keyCode, action, duration) {
+  async simulateKeyboardInput(keyCode, action, duration, target) {
     if (!keyCode) {
       throw new Error("keyCode is required for simulate_keyboard_input");
     }
@@ -2235,7 +2363,7 @@ var RobloxStudioTools = class _RobloxStudioTools {
       keyCode,
       action,
       duration
-    });
+    }, target || "edit");
     return {
       content: [{
         type: "text",
@@ -2243,7 +2371,7 @@ var RobloxStudioTools = class _RobloxStudioTools {
       }]
     };
   }
-  async characterNavigation(position, instancePath, waitForCompletion, timeout) {
+  async characterNavigation(position, instancePath, waitForCompletion, timeout, target) {
     if (!position && !instancePath) {
       throw new Error("Either position or instancePath is required for character_navigation");
     }
@@ -2252,7 +2380,7 @@ var RobloxStudioTools = class _RobloxStudioTools {
       instancePath,
       waitForCompletion,
       timeout
-    });
+    }, target || "edit");
     return {
       content: [{
         type: "text",
@@ -2302,10 +2430,59 @@ var RobloxStudioTools = class _RobloxStudioTools {
 
 // ../core/dist/bridge-service.js
 import { v4 as uuidv4 } from "uuid";
+var STALE_INSTANCE_MS = 3e4;
 var BridgeService = class {
   pendingRequests = /* @__PURE__ */ new Map();
+  instances = /* @__PURE__ */ new Map();
+  nextClientIndex = 1;
   requestTimeout = 3e4;
-  async sendRequest(endpoint, data) {
+  registerInstance(instanceId, role) {
+    let assignedRole = role;
+    if (role === "client") {
+      assignedRole = `client-${this.nextClientIndex}`;
+      this.nextClientIndex++;
+    }
+    this.instances.set(instanceId, {
+      instanceId,
+      role: assignedRole,
+      lastActivity: Date.now(),
+      connectedAt: Date.now()
+    });
+    return assignedRole;
+  }
+  unregisterInstance(instanceId) {
+    this.instances.delete(instanceId);
+    for (const [id, req] of this.pendingRequests.entries()) {
+      const targetRole = req.target;
+      const hasHandler = Array.from(this.instances.values()).some((i) => i.role === targetRole);
+      if (!hasHandler) {
+        clearTimeout(req.timeoutId);
+        this.pendingRequests.delete(id);
+        req.reject(new Error(`Target instance "${targetRole}" disconnected`));
+      }
+    }
+  }
+  getInstances() {
+    return Array.from(this.instances.values());
+  }
+  getPendingRequestCount() {
+    return this.pendingRequests.size;
+  }
+  updateInstanceActivity(instanceId) {
+    const inst = this.instances.get(instanceId);
+    if (inst) {
+      inst.lastActivity = Date.now();
+    }
+  }
+  cleanupStaleInstances() {
+    const now = Date.now();
+    for (const [id, inst] of this.instances.entries()) {
+      if (now - inst.lastActivity > STALE_INSTANCE_MS) {
+        this.unregisterInstance(id);
+      }
+    }
+  }
+  async sendRequest(endpoint, data, target = "edit") {
     const requestId = uuidv4();
     return new Promise((resolve, reject) => {
       const timeoutId = setTimeout(() => {
@@ -2318,6 +2495,7 @@ var BridgeService = class {
         id: requestId,
         endpoint,
         data,
+        target,
         timestamp: Date.now(),
         resolve,
         reject,
@@ -2326,9 +2504,11 @@ var BridgeService = class {
       this.pendingRequests.set(requestId, request);
     });
   }
-  getPendingRequest() {
+  getPendingRequest(callerRole = "edit") {
     let oldestRequest = null;
     for (const request of this.pendingRequests.values()) {
+      if (request.target !== callerRole)
+        continue;
       if (!oldestRequest || request.timestamp < oldestRequest.timestamp) {
         oldestRequest = request;
       }
@@ -2390,14 +2570,14 @@ var ProxyBridgeService = class extends BridgeService {
     this.primaryBaseUrl = primaryBaseUrl;
     this.proxyInstanceId = uuidv42();
   }
-  async sendRequest(endpoint, data) {
+  async sendRequest(endpoint, data, target = "edit") {
     const controller = new AbortController();
     const timeoutId = setTimeout(() => controller.abort(), this.proxyRequestTimeout);
     try {
       const response = await fetch(`${this.primaryBaseUrl}/proxy`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ endpoint, data, proxyInstanceId: this.proxyInstanceId }),
+        body: JSON.stringify({ endpoint, data, target, proxyInstanceId: this.proxyInstanceId }),
         signal: controller.signal
       });
       clearTimeout(timeoutId);
@@ -2434,7 +2614,7 @@ var RobloxStudioMCPServer = class {
   constructor(config) {
     this.config = config;
     this.allowedToolNames = new Set(config.tools.map((t) => t.name));
-    this.server = new Server({
+    this.server = new Server2({
       name: config.name,
       version: config.version
     }, {
@@ -2447,7 +2627,7 @@ var RobloxStudioMCPServer = class {
     this.setupToolHandlers();
   }
   setupToolHandlers() {
-    this.server.setRequestHandler(ListToolsRequestSchema, async () => {
+    this.server.setRequestHandler(ListToolsRequestSchema2, async () => {
       return {
         tools: this.config.tools.map((t) => ({
           name: t.name,
@@ -2456,10 +2636,10 @@ var RobloxStudioMCPServer = class {
         }))
       };
     });
-    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    this.server.setRequestHandler(CallToolRequestSchema2, async (request) => {
       const { name, arguments: args } = request.params;
       if (!this.allowedToolNames.has(name)) {
-        throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+        throw new McpError2(ErrorCode2.MethodNotFound, `Unknown tool: ${name}`);
       }
       try {
         switch (name) {
@@ -2545,13 +2725,15 @@ var RobloxStudioMCPServer = class {
           case "get_selection":
             return await this.tools.getSelection();
           case "execute_luau":
-            return await this.tools.executeLuau(args?.code);
+            return await this.tools.executeLuau(args?.code, args?.target);
           case "start_playtest":
-            return await this.tools.startPlaytest(args?.mode);
+            return await this.tools.startPlaytest(args?.mode, args?.numPlayers);
           case "stop_playtest":
             return await this.tools.stopPlaytest();
           case "get_playtest_output":
-            return await this.tools.getPlaytestOutput();
+            return await this.tools.getPlaytestOutput(args?.target);
+          case "get_connected_instances":
+            return await this.tools.getConnectedInstances();
           case "export_build":
             return await this.tools.exportBuild(args?.instancePath, args?.outputId, args?.style);
           case "create_build":
@@ -2619,11 +2801,11 @@ var RobloxStudioMCPServer = class {
           case "capture_screenshot":
             return await this.tools.captureScreenshot();
           case "simulate_mouse_input":
-            return await this.tools.simulateMouseInput(args?.action, args?.x, args?.y, args?.button, args?.scrollDirection);
+            return await this.tools.simulateMouseInput(args?.action, args?.x, args?.y, args?.button, args?.scrollDirection, args?.target);
           case "simulate_keyboard_input":
-            return await this.tools.simulateKeyboardInput(args?.keyCode, args?.action, args?.duration);
+            return await this.tools.simulateKeyboardInput(args?.keyCode, args?.action, args?.duration, args?.target);
           case "character_navigation":
-            return await this.tools.characterNavigation(args?.position, args?.instancePath, args?.waitForCompletion, args?.timeout);
+            return await this.tools.characterNavigation(args?.position, args?.instancePath, args?.waitForCompletion, args?.timeout, args?.target);
           case "find_and_replace_in_scripts":
             return await this.tools.findAndReplaceInScripts(args?.pattern, args?.replacement, {
               caseSensitive: args?.caseSensitive,
@@ -2634,12 +2816,12 @@ var RobloxStudioMCPServer = class {
               maxReplacements: args?.maxReplacements
             });
           default:
-            throw new McpError(ErrorCode.MethodNotFound, `Unknown tool: ${name}`);
+            throw new McpError2(ErrorCode2.MethodNotFound, `Unknown tool: ${name}`);
         }
       } catch (error) {
-        if (error instanceof McpError)
+        if (error instanceof McpError2)
           throw error;
-        throw new McpError(ErrorCode.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
+        throw new McpError2(ErrorCode2.InternalError, `Tool execution failed: ${error instanceof Error ? error.message : String(error)}`);
       }
     });
   }
@@ -2652,11 +2834,12 @@ var RobloxStudioMCPServer = class {
     let boundPort = 0;
     let promotionInterval;
     try {
-      primaryApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames);
+      primaryApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames, this.config);
       const result = await listenWithRetry(primaryApp, host, basePort, 5);
       httpHandle = result.server;
       boundPort = result.port;
       console.error(`HTTP server listening on ${host}:${boundPort} for Studio plugin (primary mode)`);
+      console.error(`Streamable HTTP MCP endpoint: http://localhost:${boundPort}/mcp`);
     } catch {
       bridgeMode = "proxy";
       primaryApp = void 0;
@@ -2669,7 +2852,7 @@ var RobloxStudioMCPServer = class {
         try {
           this.bridge = new BridgeService();
           this.tools = new RobloxStudioTools(this.bridge);
-          primaryApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames);
+          primaryApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames, this.config);
           const result = await listenWithRetry(primaryApp, host, basePort, 5);
           httpHandle = result.server;
           boundPort = result.port;
@@ -2689,7 +2872,7 @@ var RobloxStudioMCPServer = class {
     let legacyHandle;
     let legacyApp;
     if (boundPort !== LEGACY_PORT && bridgeMode === "primary") {
-      legacyApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames);
+      legacyApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames, this.config);
       try {
         const result = await listenWithRetry(legacyApp, host, LEGACY_PORT, 1);
         legacyHandle = result.server;
@@ -2727,13 +2910,16 @@ var RobloxStudioMCPServer = class {
     }, 5e3);
     const cleanupInterval = setInterval(() => {
       this.bridge.cleanupOldRequests();
+      this.bridge.cleanupStaleInstances();
     }, 5e3);
-    const shutdown = () => {
+    const shutdown = async () => {
       console.error("Shutting down MCP server...");
       clearInterval(activityInterval);
       clearInterval(cleanupInterval);
       if (promotionInterval)
         clearInterval(promotionInterval);
+      await this.server.close().catch(() => {
+      });
       if (httpHandle)
         httpHandle.close();
       if (legacyHandle)
@@ -3534,6 +3720,10 @@ var TOOL_DEFINITIONS = [
         code: {
           type: "string",
           description: "Luau code to execute"
+        },
+        target: {
+          type: "string",
+          description: 'Instance target: "edit" (default), "server", "client-1", "client-2", etc.'
         }
       },
       required: ["code"]
@@ -3592,7 +3782,7 @@ var TOOL_DEFINITIONS = [
   {
     name: "start_playtest",
     category: "read",
-    description: "Start playtest. Captures print/warn/error via LogService. Poll with get_playtest_output, end with stop_playtest.",
+    description: "Start playtest. Captures print/warn/error via LogService. Poll with get_playtest_output, end with stop_playtest. Use numPlayers for multi-client testing (server + N clients).",
     inputSchema: {
       type: "object",
       properties: {
@@ -3600,6 +3790,10 @@ var TOOL_DEFINITIONS = [
           type: "string",
           enum: ["play", "run"],
           description: "Play mode"
+        },
+        numPlayers: {
+          type: "number",
+          description: "Number of client players (1-8). Triggers server + clients mode via TestService."
         }
       },
       required: ["mode"]
@@ -3618,6 +3812,21 @@ var TOOL_DEFINITIONS = [
     name: "get_playtest_output",
     category: "read",
     description: "Poll output buffer without stopping. Returns isRunning and captured messages.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        target: {
+          type: "string",
+          description: 'Instance target: "edit" (default), "server", "client-1", "client-2", etc.'
+        }
+      }
+    }
+  },
+  // === Multi-Instance ===
+  {
+    name: "get_connected_instances",
+    category: "read",
+    description: "List all connected plugin instances with their roles. Use during multi-client playtest to discover server and client instances for targeted commands.",
     inputSchema: {
       type: "object",
       properties: {}
@@ -4241,6 +4450,10 @@ part(0,2,0,2,1,1,"b")`,
           type: "string",
           enum: ["up", "down"],
           description: 'Scroll direction (only for "scroll" action)'
+        },
+        target: {
+          type: "string",
+          description: 'Instance target: "edit" (default), "server", "client-1", "client-2", etc.'
         }
       },
       required: ["action", "x", "y"]
@@ -4265,6 +4478,10 @@ part(0,2,0,2,1,1,"b")`,
         duration: {
           type: "number",
           description: 'Hold duration in seconds for "tap" action (default: 0.1). Use longer values for sustained input like walking.'
+        },
+        target: {
+          type: "string",
+          description: 'Instance target: "edit" (default), "server", "client-1", "client-2", etc.'
         }
       },
       required: ["keyCode"]
@@ -4294,6 +4511,10 @@ part(0,2,0,2,1,1,"b")`,
         timeout: {
           type: "number",
           description: "Max seconds to wait for navigation to complete (default: 25)"
+        },
+        target: {
+          type: "string",
+          description: 'Instance target: "edit" (default), "server", "client-1", "client-2", etc.'
         }
       }
     }