@chrrxs/robloxstudio-mcp 2.10.1 → 2.11.1

package/dist/index.js

@@ -372,6 +372,9 @@ var init_http_server = __esm({
       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),
+      get_memory_breakdown: (tools, body) => tools.getMemoryBreakdown(body.target, body.tags),
+      export_rbxm: (tools, body) => tools.exportRbxm(body.instance_paths, body.output_path, body.target),
+      import_rbxm: (tools, body) => tools.importRbxm(body.source, body.parent_path, body.target),
       find_and_replace_in_scripts: (tools, body) => tools.findAndReplaceInScripts(body.pattern, body.replacement, {
         caseSensitive: body.caseSensitive,
         usePattern: body.usePattern,
@@ -2777,6 +2780,139 @@ ${code}`
           }]
         };
       }
+      async getMemoryBreakdown(target, tags) {
+        const tgt = target ?? "all";
+        const data = {};
+        if (tags !== void 0)
+          data.tags = tags;
+        if (tgt !== "all") {
+          const response = await this.client.request("/api/get-memory-breakdown", data, tgt);
+          return { content: [{ type: "text", text: JSON.stringify(response) }] };
+        }
+        const targets = this.bridge.getInstances().filter((i) => i.role !== "edit-proxy").map((i) => i.role);
+        const responses = await Promise.allSettled(targets.map(async (t) => ({
+          peer: t,
+          result: await this.client.request("/api/get-memory-breakdown", data, t)
+        })));
+        const body = {};
+        for (let i = 0; i < responses.length; i++) {
+          const r = responses[i];
+          const peer = targets[i];
+          if (r.status === "fulfilled") {
+            body[peer] = r.value.result;
+          } else {
+            body[peer] = { error: "disconnected" };
+          }
+        }
+        return { content: [{ type: "text", text: JSON.stringify(body) }] };
+      }
+      async exportRbxm(instancePaths, outputPath, target) {
+        if (!Array.isArray(instancePaths) || instancePaths.length === 0) {
+          throw new Error("instance_paths must be a non-empty array for export_rbxm");
+        }
+        if (!outputPath || typeof outputPath !== "string") {
+          throw new Error("output_path is required for export_rbxm");
+        }
+        const tgt = target || "edit";
+        if (tgt !== "edit" && tgt !== "server") {
+          throw new Error(`export_rbxm target must be "edit" or "server" (got: ${tgt})`);
+        }
+        const response = await this.client.request("/api/export-rbxm", { instance_paths: instancePaths }, tgt);
+        if (response.error) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: response.error }) }] };
+        }
+        if (!response.base64) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: "plugin returned no base64 payload" }) }] };
+        }
+        const bytes = Buffer.from(response.base64, "base64");
+        const resolved = path.resolve(outputPath);
+        try {
+          fs.mkdirSync(path.dirname(resolved), { recursive: true });
+          fs.writeFileSync(resolved, bytes);
+        } catch (err) {
+          return { content: [{ type: "text", text: JSON.stringify({ error: `failed to write ${resolved}: ${err.message}` }) }] };
+        }
+        return {
+          content: [{
+            type: "text",
+            text: JSON.stringify({
+              bytes_written: bytes.length,
+              instance_count: response.instance_count ?? instancePaths.length,
+              output_path: resolved
+            })
+          }]
+        };
+      }
+      async importRbxm(source, parentPath, target) {
+        if (!source || typeof source !== "object") {
+          throw new Error("source is required for import_rbxm");
+        }
+        if (!parentPath || typeof parentPath !== "string") {
+          throw new Error("parent_path is required for import_rbxm");
+        }
+        const tgt = target || "edit";
+        if (tgt !== "edit" && tgt !== "server") {
+          throw new Error(`import_rbxm target must be "edit" or "server" (got: ${tgt})`);
+        }
+        const modes = ["path", "url", "base64"].filter((k) => source[k] !== void 0);
+        if (modes.length !== 1) {
+          throw new Error(`source must contain exactly one of { path, url, base64 } (got: ${modes.join(", ") || "none"})`);
+        }
+        let bytes;
+        let sourceLabel;
+        if (source.path !== void 0) {
+          const resolved = path.resolve(source.path);
+          try {
+            bytes = fs.readFileSync(resolved);
+          } catch (err) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `failed to read ${resolved}: ${err.message}` }) }] };
+          }
+          sourceLabel = resolved;
+        } else if (source.url !== void 0) {
+          let parsedUrl;
+          try {
+            parsedUrl = new URL(source.url);
+          } catch {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `import_rbxm url is not a valid URL: ${source.url}` }) }] };
+          }
+          if (parsedUrl.protocol !== "http:" && parsedUrl.protocol !== "https:") {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `import_rbxm url must use http(s); got ${parsedUrl.protocol}` }) }] };
+          }
+          const MAX_IMPORT_BYTES = 50 * 1024 * 1024;
+          try {
+            const res = await fetch(source.url);
+            if (!res.ok) {
+              const snippet = (await res.text()).slice(0, 500);
+              return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url} returned ${res.status}: ${snippet}` }) }] };
+            }
+            const claimed = Number(res.headers.get("content-length") ?? "0");
+            if (claimed > MAX_IMPORT_BYTES) {
+              return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url}: content-length ${claimed} exceeds ${MAX_IMPORT_BYTES} byte cap` }) }] };
+            }
+            const arr = await res.arrayBuffer();
+            if (arr.byteLength > MAX_IMPORT_BYTES) {
+              return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url}: downloaded ${arr.byteLength} bytes exceeds ${MAX_IMPORT_BYTES} byte cap` }) }] };
+            }
+            bytes = Buffer.from(arr);
+          } catch (err) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `fetch ${source.url} failed: ${err.message}` }) }] };
+          }
+          sourceLabel = source.url;
+        } else {
+          try {
+            bytes = Buffer.from(source.base64, "base64");
+          } catch (err) {
+            return { content: [{ type: "text", text: JSON.stringify({ error: `base64 decode failed: ${err.message}` }) }] };
+          }
+          sourceLabel = `base64(${bytes.length}B)`;
+        }
+        const response = await this.client.request("/api/import-rbxm", {
+          base64: bytes.toString("base64"),
+          parent_path: parentPath,
+          source_label: sourceLabel
+        }, tgt);
+        return { content: [{ type: "text", text: JSON.stringify(response) }] };
+      }
       async captureScreenshot() {
         const response = await this.client.request("/api/capture-screenshot", {});
         if (response.error) {
@@ -3067,7 +3203,7 @@ var init_server = __esm({
         let promotionInterval;
         try {
           primaryApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames, this.config);
-          const result = await listenWithRetry(primaryApp, host, basePort, 5);
+          const result = await listenWithRetry(primaryApp, host, basePort, 1);
           httpHandle = result.server;
           boundPort = result.port;
           console.error(`HTTP server listening on ${host}:${boundPort} for Studio plugin (primary mode)`);
@@ -3078,25 +3214,25 @@ var init_server = __esm({
           const proxyBridge = new ProxyBridgeService(`http://localhost:${basePort}`);
           this.bridge = proxyBridge;
           this.tools = new RobloxStudioTools(this.bridge);
-          console.error(`All ports ${basePort}-${basePort + 4} in use - entering proxy mode (forwarding to localhost:${basePort})`);
+          console.error(`Port ${basePort} in use - entering proxy mode (forwarding to localhost:${basePort})`);
           const promotionIntervalMs = parseInt(process.env.ROBLOX_STUDIO_PROXY_PROMOTION_INTERVAL_MS || "5000");
           promotionInterval = setInterval(async () => {
+            const candidateBridge = new BridgeService();
+            const candidateTools = new RobloxStudioTools(candidateBridge);
+            const candidateApp = createHttpServer(candidateTools, candidateBridge, this.allowedToolNames, this.config);
             try {
-              this.bridge = new BridgeService();
-              this.tools = new RobloxStudioTools(this.bridge);
-              primaryApp = createHttpServer(this.tools, this.bridge, this.allowedToolNames, this.config);
-              const result = await listenWithRetry(primaryApp, host, basePort, 5);
+              const result = await listenWithRetry(candidateApp, host, basePort, 1);
+              this.bridge = candidateBridge;
+              this.tools = candidateTools;
               httpHandle = result.server;
               boundPort = result.port;
+              primaryApp = candidateApp;
               bridgeMode = "primary";
               primaryApp.setMCPServerActive(true);
               console.error(`Promoted from proxy to primary on port ${boundPort}`);
               if (promotionInterval)
                 clearInterval(promotionInterval);
             } catch {
-              this.bridge = new ProxyBridgeService(`http://localhost:${basePort}`);
-              this.tools = new RobloxStudioTools(this.bridge);
-              primaryApp = void 0;
             }
           }, promotionIntervalMs);
         }
@@ -4746,6 +4882,86 @@ part(0,2,0,2,1,1,"b")`,
           required: ["instancePath", "attributes"]
         }
       },
+      // === Per-peer memory breakdown ===
+      {
+        name: "get_memory_breakdown",
+        category: "read",
+        description: `Read per-category memory usage by iterating Enum.DeveloperMemoryTag and calling Stats:GetMemoryUsageMbForTag per item (workaround for Stats:GetMemoryUsageMbAllCategories being gated by Capabilities: InternalTest and not callable from plugin context), plus Stats:GetTotalMemoryUsageMb for the rollup. target="all" (default) returns { peer: { total_mb, categories, timestamp } } for every connected peer except edit-proxy; single-peer targets return that peer's object directly. Optional tags whitelist filters to only those DeveloperMemoryTag entries; unknown tags come back with value 0 and are listed in unknown_tags so cross-version drift doesn't error. timestamp is Unix milliseconds (DateTime.now().UnixTimestampMillis). Per-peer MemoryTrackingEnabled=false surfaces as { error } on that peer only.`,
+        inputSchema: {
+          type: "object",
+          properties: {
+            target: {
+              type: "string",
+              description: 'Peer to read from: "edit", "server", "client-N", or "all" (default).'
+            },
+            tags: {
+              type: "array",
+              items: { type: "string" },
+              description: "Optional DeveloperMemoryTag whitelist. Unknown tag names return 0 + unknown_tags list."
+            }
+          }
+        }
+      },
+      // === SerializationService round-trip ===
+      {
+        name: "export_rbxm",
+        category: "read",
+        description: "Serialize one or more instances to a .rbxm file on disk via SerializationService:SerializeInstancesAsync (engine v668+, PluginSecurity). Throws if any path resolves to nil, a service, or a non-creatable instance.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            instance_paths: {
+              type: "array",
+              items: { type: "string" },
+              description: 'DataModel paths to serialize (e.g. ["Workspace.TestRig", "ServerStorage.Templates.NPC"])'
+            },
+            output_path: {
+              type: "string",
+              description: "Absolute filesystem path where the .rbxm should be written"
+            },
+            target: {
+              type: "string",
+              enum: ["edit", "server"],
+              description: 'Which DataModel to read from (default: "edit"). "server" serializes live runtime state during a playtest.'
+            }
+          },
+          required: ["instance_paths", "output_path"]
+        }
+      },
+      {
+        name: "import_rbxm",
+        category: "write",
+        description: "Deserialize a .rbxm via SerializationService:DeserializeInstancesAsync (engine v668+, PluginSecurity) and parent the resulting instances under parent_path. All-or-nothing parenting: if any single instance fails to parent, every already-parented sibling is unparented and the call errors. Wrapped in ChangeHistoryService for edit target so one Ctrl+Z reverses the whole import.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            source: {
+              type: "object",
+              description: "Exactly one of { path }, { url }, or { base64 }. path = read from local disk; url = http(s) only, fetched by the MCP server process, capped at 50 MiB; base64 = raw bytes inline.",
+              properties: {
+                path: { type: "string" },
+                url: { type: "string" },
+                base64: { type: "string" }
+              },
+              oneOf: [
+                { required: ["path"] },
+                { required: ["url"] },
+                { required: ["base64"] }
+              ]
+            },
+            parent_path: {
+              type: "string",
+              description: 'DataModel path of the Instance to parent imported instances under (e.g. "ServerStorage.Imported")'
+            },
+            target: {
+              type: "string",
+              enum: ["edit", "server"],
+              description: 'Which DataModel to import into (default: "edit"). "server" parents into the live play-server DM.'
+            }
+          },
+          required: ["source", "parent_path"]
+        }
+      },
       // === Find and Replace ===
       {
         name: "find_and_replace_in_scripts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chrrxs/robloxstudio-mcp",
-  "version": "2.10.1",
+  "version": "2.11.1",
   "description": "MCP Server for Roblox Studio Integration (fork of boshyxd/robloxstudio-mcp with per-peer execute_luau + stop_playtest fixes)",
   "main": "dist/index.js",
   "type": "module",