robloxstudio-mcp 2.5.0-next.0 → 2.5.0

package/dist/install-plugin-cli.js

@@ -0,0 +1,87 @@
+#!/usr/bin/env node
+
+// src/install-plugin.ts
+import { createWriteStream, existsSync, mkdirSync, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { get } from "https";
+var REPO = "boshyxd/robloxstudio-mcp";
+var ASSET_NAME = "MCPPlugin.rbxmx";
+var TIMEOUT_MS = 3e4;
+var MAX_REDIRECTS = 5;
+function getPluginsFolder() {
+  if (process.platform === "win32") {
+    return join(process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local"), "Roblox", "Plugins");
+  }
+  return join(homedir(), "Documents", "Roblox", "Plugins");
+}
+function httpsGet(url) {
+  return new Promise((resolve, reject) => {
+    const req = get(url, { headers: { "User-Agent": "robloxstudio-mcp" } }, resolve);
+    req.on("error", reject);
+    req.setTimeout(TIMEOUT_MS, () => {
+      req.destroy(new Error(`Request timed out after ${TIMEOUT_MS}ms`));
+    });
+  });
+}
+async function download(url, dest, redirects = 0) {
+  const res = await httpsGet(url);
+  if (res.statusCode === 301 || res.statusCode === 302) {
+    if (redirects >= MAX_REDIRECTS) throw new Error(`Too many redirects (max ${MAX_REDIRECTS})`);
+    const location = res.headers.location;
+    if (!location) throw new Error("Redirect with no location header");
+    return download(location, dest, redirects + 1);
+  }
+  if (res.statusCode !== 200) {
+    throw new Error(`Download failed: HTTP ${res.statusCode}`);
+  }
+  return new Promise((resolve, reject) => {
+    const file = createWriteStream(dest);
+    const cleanup = (err) => {
+      file.close(() => {
+        try {
+          unlinkSync(dest);
+        } catch {
+        }
+        reject(err);
+      });
+    };
+    res.pipe(file);
+    file.on("finish", () => {
+      file.close();
+      resolve();
+    });
+    file.on("error", cleanup);
+    res.on("error", cleanup);
+  });
+}
+async function installPlugin() {
+  const pluginsFolder = getPluginsFolder();
+  if (!existsSync(pluginsFolder)) {
+    mkdirSync(pluginsFolder, { recursive: true });
+  }
+  console.log("Fetching latest release...");
+  const res = await httpsGet(`https://api.github.com/repos/${REPO}/releases/latest`);
+  if (res.statusCode !== 200) {
+    throw new Error(`GitHub API returned HTTP ${res.statusCode}`);
+  }
+  const chunks = [];
+  for await (const chunk of res) {
+    chunks.push(chunk);
+  }
+  const release = JSON.parse(Buffer.concat(chunks).toString());
+  const asset = release.assets?.find((a) => a.name === ASSET_NAME);
+  if (!asset) {
+    throw new Error(`${ASSET_NAME} not found in release ${release.tag_name}`);
+  }
+  const dest = join(pluginsFolder, ASSET_NAME);
+  console.log(`Downloading ${ASSET_NAME} from ${release.tag_name}...`);
+  await download(asset.browser_download_url, dest);
+  console.log(`Installed to ${dest}`);
+}
+
+// src/install-plugin-cli.ts
+installPlugin().catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "robloxstudio-mcp",
-  "version": "2.5.0-next.0",
+  "version": "2.5.0",
   "description": "MCP Server for Roblox Studio Integration - Access Studio data, scripts, and objects through AI tools",
   "main": "dist/index.js",
   "type": "module",
   "bin": {
-    "robloxstudio-mcp": "dist/index.js"
+    "robloxstudio-mcp": "dist/index.js",
+    "robloxstudio-mcp-install-plugin": "dist/install-plugin-cli.js"
   },
   "files": [
     "dist/**/*",

package/studio-plugin/MCPPlugin.rbxmx

@@ -1333,6 +1333,7 @@ return {
             <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
 local CaptureService = game:GetService("CaptureService")
 local AssetService = game:GetService("AssetService")
+local MAX_TILE_SIZE = 1024
 local BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
 local function encodeBase64(buf)
 	local len = buffer.len(buf)
@@ -1362,6 +1363,59 @@ local function encodeBase64(buf)
 	end
 	return table.concat(parts, "")
 end
+local function readPixelsTiled(img, w, h)
+	local BYTES_PER_PIXEL = 4
+	local fullBuf = buffer.create(w * h * BYTES_PER_PIXEL)
+	local fullRowBytes = w * BYTES_PER_PIXEL
+	do
+		local ty = 0
+		local _shouldIncrement = false
+		while true do
+			if _shouldIncrement then
+				ty += MAX_TILE_SIZE
+			else
+				_shouldIncrement = true
+			end
+			if not (ty < h) then
+				break
+			end
+			local tileH = math.min(MAX_TILE_SIZE, h - ty)
+			do
+				local tx = 0
+				local _shouldIncrement_1 = false
+				while true do
+					if _shouldIncrement_1 then
+						tx += MAX_TILE_SIZE
+					else
+						_shouldIncrement_1 = true
+					end
+					if not (tx < w) then
+						break
+					end
+					local tileW = math.min(MAX_TILE_SIZE, w - tx)
+					local tileBuf = img:ReadPixelsBuffer(Vector2.new(tx, ty), Vector2.new(tileW, tileH))
+					local tileRowBytes = tileW * BYTES_PER_PIXEL
+					do
+						local row = 0
+						local _shouldIncrement_2 = false
+						while true do
+							if _shouldIncrement_2 then
+								row += 1
+							else
+								_shouldIncrement_2 = true
+							end
+							if not (row < tileH) then
+								break
+							end
+							buffer.copy(fullBuf, (ty + row) * fullRowBytes + tx * BYTES_PER_PIXEL, tileBuf, row * tileRowBytes, tileRowBytes)
+						end
+					end
+				end
+			end
+		end
+	end
+	return fullBuf
+end
 local function captureScreenshot()
 	local contentId
 	CaptureService:CaptureScreenshot(function(id)
@@ -1385,11 +1439,11 @@ local function captureScreenshot()
 		}
 	end
 	local editableImage = editableResult
-	local size = editableImage.Size
-	local w = math.floor(size.X)
-	local h = math.floor(size.Y)
+	local imgSize = editableImage.Size
+	local w = math.floor(imgSize.X)
+	local h = math.floor(imgSize.Y)
 	local readOk, pixelBuffer = pcall(function()
-		return editableImage:ReadPixelsBuffer(Vector2.zero, editableImage.Size)
+		return readPixelsTiled(editableImage, w, h)
 	end)
 	editableImage:Destroy()
 	if not readOk then
@@ -2937,6 +2991,9 @@ local function getFileTree(requestData)
 		if instance:IsA("LuaSourceContainer") then
 			node.hasSource = true
 			node.scriptType = instance.ClassName
+			if instance:IsA("BaseScript") then
+				node.enabled = instance.Enabled
+			end
 		end
 		for _, child in instance:GetChildren() do
 			local _children = node.children
@@ -2979,13 +3036,16 @@ local function searchFiles(requestData)
 			match = (string.find(_exp, _arg0)) ~= nil
 		end
 		if match then
-			local _arg0 = {
+			local entry = {
 				name = instance.Name,
 				className = instance.ClassName,
 				path = getInstancePath(instance),
 				hasSource = instance:IsA("LuaSourceContainer"),
 			}
-			table.insert(results, _arg0)
+			if instance:IsA("BaseScript") then
+				entry.enabled = instance.Enabled
+			end
+			table.insert(results, entry)
 		end
 		for _, child in instance:GetChildren() do
 			searchRecursive(child)
@@ -3246,14 +3306,17 @@ local function getInstanceChildren(requestData)
 	end
 	local children = {}
 	for _, child in instance:GetChildren() do
-		local _arg0 = {
+		local entry = {
 			name = child.Name,
 			className = child.ClassName,
 			path = getInstancePath(child),
 			hasChildren = #child:GetChildren() > 0,
 			hasSource = child:IsA("LuaSourceContainer"),
 		}
-		table.insert(children, _arg0)
+		if child:IsA("BaseScript") then
+			entry.enabled = child.Enabled
+		end
+		table.insert(children, entry)
 	end
 	return {
 		instancePath = instancePath,
@@ -3694,13 +3757,16 @@ local function grepScripts(requestData)
 				end
 			end
 			if scriptMatchCount > 0 then
-				local _arg0 = {
+				local scriptResult = {
 					instancePath = getInstancePath(instance),
 					name = instance.Name,
 					className = instance.ClassName,
 					matches = scriptMatches,
 				}
-				table.insert(results, _arg0)
+				if instance:IsA("BaseScript") then
+					scriptResult.enabled = instance.Enabled
+				end
+				table.insert(results, scriptResult)
 			end
 		end
 		for _, child in instance:GetChildren() do
@@ -3766,6 +3832,7 @@ local function normalizeEscapes(s)
 	result = (string.gsub(result, "\\n", "\n"))
 	result = (string.gsub(result, "\\t", "\t"))
 	result = (string.gsub(result, "\\r", "\r"))
+	result = (string.gsub(result, '\\"', '"'))
 	result = (string.gsub(result, "\\\\", "\\"))
 	return result
 end
@@ -4449,7 +4516,7 @@ return {
         <Properties>
           <string name="Name">State</string>
           <string name="Source"><![CDATA[-- Compiled with roblox-ts v3.0.0
-local CURRENT_VERSION = "2.5.0-next.0"
+local CURRENT_VERSION = "2.5.0"
 local MAX_CONNECTIONS = 5
 local BASE_PORT = 58741
 local activeTabIndex = 0

package/studio-plugin/src/modules/handlers/CaptureHandlers.ts

@@ -1,6 +1,7 @@
 const CaptureService = game.GetService("CaptureService");
 const AssetService = game.GetService("AssetService");
 
+const MAX_TILE_SIZE = 1024;
 const BASE64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
 function encodeBase64(buf: buffer): string {
@@ -46,6 +47,25 @@ function encodeBase64(buf: buffer): string {
 	return parts.join("");
 }
 
+function readPixelsTiled(img: EditableImage, w: number, h: number): buffer {
+	const BYTES_PER_PIXEL = 4;
+	const fullBuf = buffer.create(w * h * BYTES_PER_PIXEL);
+	const fullRowBytes = w * BYTES_PER_PIXEL;
+
+	for (let ty = 0; ty < h; ty += MAX_TILE_SIZE) {
+		const tileH = math.min(MAX_TILE_SIZE, h - ty);
+		for (let tx = 0; tx < w; tx += MAX_TILE_SIZE) {
+			const tileW = math.min(MAX_TILE_SIZE, w - tx);
+			const tileBuf = img.ReadPixelsBuffer(new Vector2(tx, ty), new Vector2(tileW, tileH));
+			const tileRowBytes = tileW * BYTES_PER_PIXEL;
+			for (let row = 0; row < tileH; row++) {
+				buffer.copy(fullBuf, (ty + row) * fullRowBytes + tx * BYTES_PER_PIXEL, tileBuf, row * tileRowBytes, tileRowBytes);
+			}
+		}
+	}
+	return fullBuf;
+}
+
 function captureScreenshot(): unknown {
 	let contentId: string | undefined;
 
@@ -74,12 +94,12 @@ function captureScreenshot(): unknown {
 	}
 
 	const editableImage = editableResult as EditableImage;
-	const size = editableImage.Size;
-	const w = math.floor(size.X);
-	const h = math.floor(size.Y);
+	const imgSize = editableImage.Size;
+	const w = math.floor(imgSize.X);
+	const h = math.floor(imgSize.Y);
 
 	const [readOk, pixelBuffer] = pcall(() => {
-		return editableImage.ReadPixelsBuffer(Vector2.zero, editableImage.Size);
+		return readPixelsTiled(editableImage, w, h);
 	});
 
 	editableImage.Destroy();

package/studio-plugin/src/modules/handlers/QueryHandlers.ts

@@ -9,6 +9,7 @@ interface TreeNode {
 	children: TreeNode[];
 	hasSource?: boolean;
 	scriptType?: string;
+	enabled?: boolean;
 }
 
 function getFileTree(requestData: Record<string, unknown>) {
@@ -34,6 +35,9 @@ function getFileTree(requestData: Record<string, unknown>) {
 		if (instance.IsA("LuaSourceContainer")) {
 			node.hasSource = true;
 			node.scriptType = instance.ClassName;
+			if (instance.IsA("BaseScript")) {
+				node.enabled = instance.Enabled;
+			}
 		}
 
 		for (const child of instance.GetChildren()) {
@@ -55,7 +59,7 @@ function searchFiles(requestData: Record<string, unknown>) {
 
 	if (!query) return { error: "Query is required" };
 
-	const results: { name: string; className: string; path: string; hasSource: boolean }[] = [];
+	const results: { name: string; className: string; path: string; hasSource: boolean; enabled?: boolean }[] = [];
 
 	function searchRecursive(instance: Instance) {
 		let match = false;
@@ -69,12 +73,16 @@ function searchFiles(requestData: Record<string, unknown>) {
 		}
 
 		if (match) {
-			results.push({
+			const entry: { name: string; className: string; path: string; hasSource: boolean; enabled?: boolean } = {
 				name: instance.Name,
 				className: instance.ClassName,
 				path: getInstancePath(instance),
 				hasSource: instance.IsA("LuaSourceContainer"),
-			});
+			};
+			if (instance.IsA("BaseScript")) {
+				entry.enabled = instance.Enabled;
+			}
+			results.push(entry);
 		}
 
 		for (const child of instance.GetChildren()) {
@@ -300,15 +308,19 @@ function getInstanceChildren(requestData: Record<string, unknown>) {
 	const instance = getInstanceByPath(instancePath);
 	if (!instance) return { error: `Instance not found: ${instancePath}` };
 
-	const children: { name: string; className: string; path: string; hasChildren: boolean; hasSource: boolean }[] = [];
+	const children: { name: string; className: string; path: string; hasChildren: boolean; hasSource: boolean; enabled?: boolean }[] = [];
 	for (const child of instance.GetChildren()) {
-		children.push({
+		const entry: { name: string; className: string; path: string; hasChildren: boolean; hasSource: boolean; enabled?: boolean } = {
 			name: child.Name,
 			className: child.ClassName,
 			path: getInstancePath(child),
 			hasChildren: child.GetChildren().size() > 0,
 			hasSource: child.IsA("LuaSourceContainer"),
-		});
+		};
+		if (child.IsA("BaseScript")) {
+			entry.enabled = child.Enabled;
+		}
+		children.push(entry);
 	}
 
 	return { instancePath, children, count: children.size() };
@@ -568,6 +580,7 @@ function grepScripts(requestData: Record<string, unknown>) {
 		instancePath: string;
 		name: string;
 		className: string;
+		enabled?: boolean;
 		matches: LineMatch[];
 	}
 
@@ -644,12 +657,16 @@ function grepScripts(requestData: Record<string, unknown>) {
 			}
 
 			if (scriptMatchCount > 0) {
-				results.push({
+				const scriptResult: ScriptResult = {
 					instancePath: getInstancePath(instance),
 					name: instance.Name,
 					className: instance.ClassName,
 					matches: scriptMatches,
-				});
+				};
+				if (instance.IsA("BaseScript")) {
+					scriptResult.enabled = instance.Enabled;
+				}
+				results.push(scriptResult);
 			}
 		}
 

package/studio-plugin/src/modules/handlers/ScriptHandlers.ts

@@ -11,6 +11,7 @@ function normalizeEscapes(s: string): string {
 	result = result.gsub("\\n", "\n")[0];
 	result = result.gsub("\\t", "\t")[0];
 	result = result.gsub("\\r", "\r")[0];
+	result = result.gsub('\\"', '"')[0];
 	result = result.gsub("\\\\", "\\")[0];
 	return result;
 }