Skip to main content
Glama

Server Configuration

Describes the environment variables required to run the server.

NameRequiredDescriptionDefault
TUFAN_PROJECTNoProject root for sync/git (use forward slashes). Defaults to cwd.
TUFAN_TOOLSETNoSet to core for lean mode — expose only the 29 everyday core tools (default full = all 87).
TUFAN_AUTOPUSHNoSet to 1 to also push after each commit.
TUFAN_GROUP_IDNoUpload owner group override for import_file / generate_asset (defaults to the logged-in Studio user).
TUFAN_READONLYNoSet to 1 for safe/inspector mode — write tools hidden, script_source/tag readable but write-blocked.
TUFAN_ASSET_DIRNoWhere generated assets download (default ~/.tufan-blox-bridge/assets/).
TUFAN_MESHY_KEYNoMeshy AI API key for meshy_generate / meshy_task / generate_asset (needs a paid Meshy plan).
TUFAN_AUTOCOMMITNoSet to 1 to auto-commit each Studio→file edit (also toggle-able in the widget).
TUFAN_CREATOR_IDNoUpload owner override for import_file / generate_asset (defaults to the logged-in Studio user).
TUFAN_BLENDER_PATHNoPath to blender.exe for the Blender tools (default: auto-detect newest install, then PATH).
TUFAN_PROJECTS_DIRNoBase dir override for auto-registered projects.
TUFAN_OPENCLOUD_KEYNoOpen Cloud API key for import_file / generate_asset (assets Read+Write scopes).
TUFAN_MESHY_AUTOCONFIRMNoSet to 1 to skip the per-call Meshy credit-spend confirmation gate.

Instructions

Guidance the server publishes about itself, which clients place ahead of the tool catalog so the model reads it before choosing anything.

Tufan works on the EDIT copy of a place in Roblox Studio. Pair it with Roblox's official Studio MCP (the Roblox_Studio server) and route by job:

  • Screenshots: official screen_capture. Tufan has no screenshot tool.

  • Play tests: official start_stop_play, character_navigation, user_keyboard_input, user_mouse_input.

  • Real-time debugging in a running game: official execute_luau with datamodel_type Client or Server, plus get_console_output. Tufan's get_recent_errors also streams live errors.

  • Everything else, use Tufan: editing scripts and instances, bulk builds (batch, create_tree, mass_edit), snapshot/restore, git, backdoor and performance scans, asset import, DataStore and production logs.

  • Big jobs: Roblox allows the plugin about 500 HTTP requests a minute, roughly 240 Tufan calls. Prefer batch, create_tree and mass_edit over many single calls; past the limit calls wait instead of failing. If the official server isn't connected, tell the user instead of treating a Tufan result as proof of how the running game behaves.

Capabilities

Features and capabilities supported by this server

Protocol revision2025-11-25

CapabilityDetails
tools
{
  "listChanged": true
}

Tools

Functions exposed to the LLM to take actions

NameDescription
pingA

Check that a Studio place is connected and answering, and return its name, PlaceId and session id. Read-only. Use it to confirm the plugin is connected before other calls, or to diagnose timeouts; list_places shows every connected place at once.

is_runningA

Whether a simulation is running in the target Studio: a Play session, Run mode, or plain edit mode. Read-only state check — use it to confirm you're in edit mode before mutating. To START/STOP a play session or send input, use Roblox's official Studio MCP.

list_placesA

List the Roblox Studio places connected to the bridge right now, with placeId, name, gameId and project folder. Read-only. Call it first when several places are open, then pass a placeId or name as the place argument of other tools; with one place open, tools target it automatically. To check a single connection, ping is enough.

pull_placeA

Re-read every script in a connected place and rewrite its mirror folder on disk (/projects/_) to match Studio. It runs automatically on connect, so use it only when the files look out of date. Mirror files are overwritten; when git is on, uncommitted mirror changes are committed first so they can be recovered. Unpublished places (PlaceId 0) have no mirror.

copy_script_acrossA

Copy one script's Source from one connected place into another, for example to share a module between two games. Both places must be open in Studio. The destination script is overwritten if it exists, or created with any missing folders if it doesn't. Use list_places to get the place names or ids.

script_sourceA

Read a script's full Source, or replace all of it. Reading is read-only; writing overwrites the whole script (open editor tabs update too) and is blocked in read-only mode. For small changes prefer patch_script (anchored find/replace) or edit_script_lines (a line range), which don't resend the file. To search across scripts use grep_scripts.

grep_scriptsA

Search the Source of every script in the place and return matching lines as path:line: text. Read-only; stops at 500 matches. Use it to find where something is defined or used before editing. To find instances by name use search_objects; to replace text everywhere use find_and_replace_in_scripts.

edit_script_linesA

Replace a range of lines in one script with new text, without resending the whole Source; returns the new line count. Overwrites those lines. Line numbers shift after each edit, so re-read with script_source or grep_scripts before a second edit. When you can quote the text to change, patch_script is safer because it doesn't depend on line numbers.

find_and_replace_in_scriptsA

Replace a piece of plain text in every script of the place at once, for renames across the codebase. Overwrites every match in every script. Run with dryRun true first to see which scripts and how many matches would change. For changes inside one script use patch_script.

patch_scriptA

Apply several literal find-and-replace hunks to one script in a single call, in order, without resending the file. All or nothing: if a required hunk's text is missing, it errors and writes nothing, so a stale patch can't half-apply. Use dryRun to check first. The safest way to edit code you can quote; for a line range use edit_script_lines, and for the same change in many scripts use find_and_replace_in_scripts.

find_duplicatesA

Find groups of scripts whose Source is exactly identical, biggest group first: copy-pasted code to move into one shared ModuleScript. Read-only. Only exact copies match; near-duplicates with small edits are not reported. To search for a specific snippet use grep_scripts.

create_instanceA

Create one new instance in the edit copy and return its path. Recorded as one Studio undo step. A property that fails to set is skipped without an error, so read it back with get_properties when it matters. For several instances use create_tree (a nested hierarchy) or batch (mixed operations), which run in one call.

delete_instanceA

Destroy an instance and all of its descendants in the edit copy. Recorded as one Studio undo step, so history undo brings it back while the undo stack lasts. For a checkpoint that outlives the undo stack, take a snapshot first. Fails if the path does not resolve.

clone_instanceA

Copy an instance with all its descendants and return the copy's path. Recorded as one Studio undo step. Instances with Archivable=false cannot be cloned. For many copies at once use batch with several clone operations.

move_instanceA

Move an instance (with its descendants) under a different parent and return its new path. Recorded as one Studio undo step. To change only the name use rename_instance; to keep the original and place a copy, use clone_instance.

rename_instanceA

Change an instance's Name and return its new path. Recorded as one Studio undo step. Scripts that find the instance by its old name will stop finding it, so search with grep_scripts first when renaming something code refers to.

create_treeA

Build a whole nested hierarchy from one spec in a single call and one Studio undo step, and return the root path and instance count. Best for UIs and models (a panel and all its children at once). Properties that fail to set are skipped silently. For one instance use create_instance; for mixed creates, edits and deletes use batch.

historyA

Step Studio's own undo history back or forward one entry, exactly like Ctrl+Z or Ctrl+Y. It affects the latest change by anyone, including the user, not only Tufan's. Each Tufan write (and each batch, create_tree or mass_edit) is one entry. For anything older than the undo stack, use restore (snapshots) or restore_from_mirror.

get_propertiesA

Read property values of one instance as JSON. Read-only. Without names it returns Name, ClassName, all attributes and a common set (Position, Size, CFrame, Color, Material, Transparency, Anchored, Text, Visible, Enabled, Value, Source and more) that applies to the class; Roblox has no API to list every property, so pass names for anything else. For identity, children, tags and attributes in one call use describe; for attributes only use get_attributes.

set_propertyA

Set one property on one instance in the edit copy, recorded as one Studio undo step. Fails with the Roblox error if the property is read-only or the value has the wrong type. For more than one change use mass_edit (one call, one undo step); for attributes use set_attribute.

mass_editA

Apply many property changes, across any number of instances, in one call recorded as one Studio undo step. Each edit is tried on its own: failures (unresolved path, bad property or value) are listed with their index and reason, and the rest still apply. Prefer it over repeated set_property calls, since Roblox limits the plugin to about 500 requests a minute. For attributes use mass_set_attribute.

search_by_propertyA

Find every instance under a root whose property equals a given value, and list their paths. Read-only. Use it for questions like "which parts are still Anchored=false" or "which labels use Font Arial". To find by name or class use search_objects; to search the Roblox marketplace use search_assets.

get_attributesA

Read every attribute set on one instance as a JSON object of name to value. Read-only; returns {} when there are none. For attributes together with properties, tags and children use describe.

set_attributeA

Create or overwrite one attribute on one instance, recorded as one Studio undo step. For several attributes use mass_set_attribute; for built-in properties use set_property.

mass_set_attributeA

Set many attributes, across any number of instances, in one call recorded as one Studio undo step. Each edit is tried on its own; failures are listed with their index and reason while the rest still apply. The attribute version of mass_edit; for one attribute set_attribute is enough.

get_descendantsA

List every descendant of an instance, one line each with its class and full path, down to a depth limit. Read-only. Gives exact paths you can pass to other tools, but nothing is folded, so it gets long on big models: prefer get_tree to map a large area, and describe for one instance in detail.

get_treeA

Map the hierarchy under an instance with as few tokens as possible: runs of same-class siblings fold into one "ClassName ×N" line, so a 4,000-part model costs about one line. Read-only. Start here to understand a place or a large model. For exact paths of every descendant use get_descendants; for one instance's properties, tags and children use describe.

search_objectsA

Find instances by name, class or both under a root and list their paths. Read-only; stops at 200 results and says so, so narrow the search when that happens. Use matchMode exact or wholeWord to cut the noise of substring matches. To match a property value (every part with Material=Wood) use search_by_property; to search the Roblox marketplace use search_assets.

get_servicesA

List the top-level services of the open place (Workspace, ReplicatedStorage, StarterGui and so on). Read-only. Use it to orient in an unfamiliar place, then get_tree on the service you care about.

run_luauA

Execute Luau in the Studio plugin context (EDIT mode — runs against the edit DataModel, not a running playtest's server/client). Captures the return value and printed output. Full plugin API access. For code that must run INSIDE a live play session, use Roblox's official Studio MCP (execute_luau); for code that must run against the PUBLISHED game on Roblox's servers, use cloud_luau instead.

get_recent_errorsA

Read the errors and warnings Studio has produced, including during a play test, with script and line parsed out. Read-only. It reads the feed the plugin already pushed, so it answers instantly even while Studio is busy. Pass the cursor from the previous reply as since to get only new events. For all Output text (prints and info) use get_output_log; for your published game's live servers use get_server_logs.

get_output_logA

Read recent lines from Studio's Output window, prints included, newest last. Read-only. The plugin keeps the last 1,500 messages, play test output included. Use it to see what a script printed; for errors only, with script and line parsed, get_recent_errors is faster.

search_assetsA

Search the Roblox Creator Store (Studio's Toolbox) by keyword and list matching asset ids with name and creator. Read-only; calls Roblox's public web APIs and needs no Studio. Follow up with get_asset_details or get_asset_thumbnail, then insert_asset. Roblox no longer reports whether a model contains scripts, so run scan_backdoors after inserting a free model. To find instances already in the place use search_objects.

get_asset_detailsA

Fetch public marketplace details for one asset id as JSON: name, creator, asset type, description, created and updated dates, and whether it is for sale. Read-only; uses Roblox's public economy API. It does not say whether a model contains scripts, so run scan_backdoors after inserting one. To see the asset, use get_asset_thumbnail.

get_asset_thumbnailA

Return an asset's thumbnail as a PNG image, so you can see what it looks like before inserting it. Read-only; uses Roblox's public thumbnail API and works for any public asset, owned or not. For text details use get_asset_details. This shows catalog art only; to see the open place use the official Studio MCP's screen_capture.

search_materialsA

List the custom MaterialVariants defined in this place's MaterialService, with each one's base material. Read-only. Use it to find a material name to set on parts with set_property or mass_edit. For marketplace assets use search_assets; for other instances use search_objects.

insert_assetA

Insert a marketplace asset into the edit copy by id and return its path. Recorded as one Studio undo step. Roblox only lets Studio load assets the signed-in user owns, or Roblox-made ones, so most third-party free models fail until the user adds them to their inventory in the Toolbox. Run scan_backdoors after inserting a free model. For a file on this computer use import_file; to generate a new model with AI use generate_asset.

git_statusA

Show the git status of a place's mirror repo: current branch, commits ahead or behind the remote, and each changed file. Read-only. Run it before git_commit to see what will be committed, or before git_pull to make sure nothing is uncommitted. For line-level changes use git_diff.

git_commitA

Stage and commit changes in a place's mirror repo, creating a restore point for scripts and saved instances. Only adds history; nothing is overwritten. Commits every change unless paths is given. Commit before risky edits so git_restore, git_revert and git_recover have something to go back to; git_push then copies it off this machine.

git_logA

List recent commits in a place's mirror repo, newest first: short hash, date and message. Read-only; says so when there are no commits yet. Use it to find the ref for git_show, git_diff, git_restore or git_revert.

git_diffA

Show a unified diff in a place's mirror repo. Read-only. With no refs it shows uncommitted changes; with from it compares that commit to the working files; with from and to it compares two commits. For a commit's summary use git_show; for which files changed use git_status.

git_restoreA

Overwrite one file in the mirror with its committed version: HEAD by default, or an older commit given as source. Uncommitted edits to that file are lost and cannot be recovered, so check git_diff first. The file sync then carries the restored script into Studio. For a file that was deleted use git_recover; for instances checkpointed in the place use restore.

git_recoverA

Bring back a deleted file: searches all history for the last commit where the file still had content and writes it back into the mirror. Use it when a script is gone and you don't know which commit had it; if you know the commit, git_restore with source does the same. Says so if the file was never committed.

git_showA

Show one commit's author, date, message and changed-file summary, or, with path, the full content of one file as it was in that commit. Read-only. Use it to inspect an old version before restoring it with git_restore. For line-by-line changes use git_diff.

git_revertA

Undo one earlier commit by adding a new commit with the opposite changes; history is kept, and the files in the mirror change accordingly. Use it to roll back a bad change that is already committed. Fails on a merge conflict. To undo uncommitted edits to one file, use git_restore instead.

git_branchA

List the local branches of a place's mirror repo (current one marked *), or create a new branch from the current commit and switch to it. Listing is read-only; creating is blocked in read-only mode. Uncommitted changes carry over to the new branch.

git_remoteA

List the git remotes of a place's mirror repo, or add one. Adding a remote such as a private GitHub repo lets git_push keep a copy off this machine. Adding is blocked in read-only mode and fails if the name already exists.

git_pushA

Push the current branch's commits to its remote, as an off-machine backup of the place's scripts and saved instances. Sends data to the remote (for example GitHub) using your local git credentials. Needs a remote with an upstream branch: add one with git_remote first. Commit with git_commit before pushing.

git_pullA

Fetch the remote's commits and merge them into the mirror, for example to restore a place's files on a new machine. Merged changes overwrite files in the mirror, and the file sync carries them into Studio. Commit or check git_status first; a conflict stops the merge.

get_selectionA

Return what the user has selected in Studio right now, one line per instance with class and path. Read-only. Use it when the user says "this" or "the selected part" instead of guessing a path.

set_selectionA

Replace the user's Studio selection with the given instances, to point them at something or prepare for a Studio command. Changes only the selection, never the instances. Paths that do not resolve are skipped; the reply says how many were selected. An empty list clears the selection.

tagA

Read, add or remove CollectionService tags on one instance. get is read-only; add and remove change the instance and are blocked in read-only mode. Tags are how scripts find groups of objects (CollectionService:GetTagged). To list every instance with a tag, use get_tagged.

get_taggedA

List the paths of every instance in the place that carries a CollectionService tag. Read-only. Use it to check what a tag-driven script will act on. For one instance's tags use tag with action get.

scan_backdoorsA

Tufan Power Tool: deep-scan a place for backdoors / exploits / obfuscation. Checks script source (require-of-Value, require-by-asset-id, loadstring, HttpGet, getfenv, exploit APIs, Discord webhooks, anti-debug, high-entropy blobs) AND the spots a script-only scanner misses — instance attributes and StringValues hiding encoded payloads. Findings sorted high→low severity. NOTE: this scans the PLACE tree; it cannot read installed Studio plugins' own source (a Roblox limit) — use list_studio_plugins to see what plugins are installed (the remote-code-plugin vector).

list_studio_pluginsA

List Studio plugins installed locally on this machine (local .rbxm plugins + marketplace InstalledPlugins). Use this to spot the blind spot scan_backdoors can't reach: a third-party plugin running remote code. Server-side; no Studio call.

http_getA

Fetch a URL (GET) and return the response body as text. For grabbing docs, JSON APIs, or reference data while working. Body is capped at ~100 KB; 15s timeout.

batchA

Run MANY operations in ONE round-trip and ONE undo entry. The single biggest speed win for multi-step builds (a 40-instance UI = 1 call, not 40). Each op is { op, args } where args is exactly what that tool takes (omit place). Returns a per-op result list. Set stopOnError to halt at the first failure. Supported ops: create_instance, delete_instance, clone_instance, move_instance, rename_instance, mass_create, mass_duplicate, create_tree, set_property, mass_set_property, mass_edit, set_attribute, mass_set_attribute, add_tag, remove_tag, set_script_source, edit_script_lines, find_and_replace_in_scripts, set_selection, get_properties, get_children, get_script_source. (create_tree / mass_* already batch one kind; use batch to mix different ops.)

scan_perfA

Audit the place for runtime frame-killers in one pass (part/physics load, StreamingEnabled, CSG unions, precise meshes, shadow lights, particles, and scripts with un-yielded while true do loops). Returns a ranked fix list. Read-only. For a general census of the place use project_health; for UI that breaks on other screens use scan_responsive.

describeA

Full context of one instance in a SINGLE call: identity, key properties, attributes, tags, a class-bucketed child summary, attached scripts (with line counts), and world bounds. Replaces the 5-6 round-trips (get_properties + get_children + get_attributes + get_tags + script grep) it used to take to understand a node. Read-only. For a whole area use get_tree; for property values describe doesn't show, use get_properties with names.

snapshotA

Checkpoint an instance and everything under it before a risky edit, so restore can put it back exactly. Stores a live clone in ServerStorage._TufanSnapshots, which survives after Studio's undo stack has moved on and is saved with the place. Saving under an existing snapshot name replaces that snapshot. Archivable=false descendants are included. Use this for instances in the place; for script files on disk use git_commit, and for GUIs or models lost to a delete use restore_from_mirror.

restoreA

Put a snapshot checkpoint back: destroys the child with the original name under the original parent, then clones the checkpoint into its place. Recorded as one Studio undo step, and the snapshot is kept so you can restore it again. Use list_snapshots to find names. For script files tracked in git use git_restore or git_recover; for instances saved by the disk mirror use restore_from_mirror.

list_snapshotsA

List the snapshots saved in this place: name, class, descendant count and the path each one restores to. Read-only. Call it before restore or delete_snapshot to get the exact name; returns "(no snapshots)" when there are none.

delete_snapshotA

Permanently delete one saved snapshot from ServerStorage._TufanSnapshots to free space or tidy up. Only the checkpoint is removed; the live instance it was taken from is not touched. The deletion is not recorded as a Studio undo step, so treat it as final. Fails if no snapshot has that name; use list_snapshots to check names first.

mirror_historyA

What the on-disk mirror can bring back. The plugin saves every direct child of StarterGui, ReplicatedStorage, ServerStorage, StarterPack and Lighting as a .rbxm next to the script files (seconds after a change), and keeps a frozen copy in .history whenever one is removed, loses descendants (a delete or Ctrl+Z) or is overwritten after a quiet spell; scripts get the same. Lists the live mirror files and the history copies whose path matches path (a unit or anything inside it). Read-only. Restore one with restore_from_mirror; for snapshots taken inside the place use list_snapshots, and for committed script history use git_log.

restore_from_mirrorA

Bring one instance back into the edit copy from the on-disk mirror or its .history, by Studio path (e.g. StarterGui.MineGui, StarterGui.FarmGui.Toasts, ReplicatedStorage.Mining.SomeModule). Works for anything inside a mirrored unit and for scripts. Without version it tries the live mirror file first, then history copies newest first, and uses the first one that still holds the path. One undo entry. Refuses to overwrite an existing same-named instance unless replace=true. Use mirror_history to pick a version.

make_responsiveA

Make a UI subtree resolution-proof. Converts Offset→Scale across ALL the properties that break responsiveness — Position, Size, CanvasSize, CellSize, CellPadding, UIPadding, UICorner CornerRadius (validated formula: ÷ parent AbsoluteSize per axis; CornerRadius ÷ min-axis). Skips runtime-driven elements (tagged Draggable/Resizable, or in exclude) so it never shatters draggable/resizable panels. ALWAYS dryRun first to preview. modes: scale (default, Offset→Scale) · offset (reverse) · fit (root fills parent: Size {1,1} + Pos 0 + Anchor 0) · uiscale (keep Offset, add a UIScale + a real viewport-fit driver). Flags: aspectRatio (add UIAspectRatioConstraint at current aspect, skips layout-managed kids), minSize (UISizeConstraint 44×44 on buttons).

scan_responsiveA

Audit a UI subtree for what breaks on other resolutions — across the tree AND the scripts. Flags Offset-locked Position/Size/CanvasSize/CellSize/CellPadding/Padding/CornerRadius, sub-44 tap targets, and runtime pixel-positioning in code. Recognizes intentional draggable/resizable elements (tagged) and instead checks their drag logic (clamps to viewport?). Read-only. Run it before make_responsive to see what needs fixing, and again after to confirm.

project_healthA

One-look census of the game (installed plugins and Studio UI excluded): instance / script / part counts, total Luau size, particle + light counts, a per-service descendant breakdown, tag count, and StreamingEnabled. The fast 'what is this game?' overview before diving in. Read-only. For performance problems use scan_perf; for security use scan_backdoors; to explore the hierarchy use get_tree.

import_fileA

Import a LOCAL file into Roblox: uploads it to the user's own account via the Open Cloud Assets API (needs TUFAN_OPENCLOUD_KEY), then inserts it into the open place. Supports .rbxm/.rbxmx/.fbx/.gltf/.glb (Model), .mp3/.ogg/.wav/.flac (Audio → Sound instance; wav/flac acceptance may vary), .png/.jpg/.bmp/.tga (Decal instance). NOT .obj — convert to .fbx/.glb first. Max 20 MB. Audio uploads are quota-limited (10/month, 100/month if ID-verified) and queue for moderation — they often outlive waitSeconds; when that happens the call returns an operationId, and re-calling with { operationId } resumes WITHOUT re-uploading or burning quota. Models typically finish in seconds. For an EXISTING marketplace asset by id, use insert_asset instead; to AI-generate a new mesh from a prompt/image, use generate_asset instead.

scene_stateA

Spatial snapshot of the scene as the editor camera sees it: camera intrinsics (CFrame, FOV, viewport) + a curated list of visible objects, each with world position/orientation/size AND its on-screen pixel (x,y,depth,onScreen) via WorldToScreenPoint. This is what grounds a screenshot — it lets you say "object X is at screen (px,py) = world (x,y,z)". A Model counts as one object (bounding box); closest objects first. Pair with the official Roblox_Studio MCP's screen_capture. Read-only.

pickA

Raycast from a screen point into the scene and report what's under it: the hit instance (+ nearest Model ancestor), world position, surface normal, distance, and the part's CFrame/size/orientation. Give x,y in pixels OR nx,ny in 0..1 OR nothing for the viewport center. Powers "what is that?" and tracing (sample points along a screen path). Read-only.

objects_in_regionA

List parts whose bounds overlap a region: a box (center+size), a sphere (center+radius), or 'around' an instance (its bounding box, optionally padded). Spatial query for "what's near X / inside this area". Returns part paths + world pos + size. Read-only. Give center with size (box) or radius (sphere), or around instead. To find what is under a screen point use pick; to find by name use search_objects.

place_onA

Compute and apply an accurate placement: raycast to a surface (a screen point, a target instance's TOP via onTarget, or straight down via ground), then sit the object FLUSH on it — offset by the object's bounding box so it doesn't clip or float. Optional alignToNormal (rotate to the surface) and snap (grid studs). Use dryRun to get the computed CFrame without moving. Moves a Part (CFrame) or a Model (PivotTo, bbox-center flush). Write tool.

blender_processA

Run a canned headless-Blender operation on a local 3D file (.glb/.gltf/.fbx/.obj/.blend in; .glb/.fbx out — input is never modified). Actions: inspect (Roblox-readiness lint: tri counts vs the 20k limit, materials-per-mesh, UV sets, texture sizes vs the 1024 cap), decimate (reduce to target tris, default 20000), split_by_material (one object per material — Roblox imports one MeshPart per material object), split_chunks (bisect oversized meshes into ≤target-tri pieces), fracture (Cell Fracture shards for destructibles — needs the Cell Fracture extension installed), set_origins (per-object geometry-median origins), convert (re-export, e.g. obj→glb for import_file), downscale_textures (cap textures at texLimit, default 1024), thumbnail (render a 512px PNG preview of the model — SEE an asset before uploading/spending; returned as an image). Needs Blender installed (free) — auto-detected or TUFAN_BLENDER_PATH.

blender_runA

POWER TOOL: run an arbitrary bpy (Python) script in headless Blender on this machine. The script gets helper globals from the Tufan preamble: ARGS (parsed k=v argv), IN/OUT (from inputFile/outputFile), emit(dict) → returns structured JSON to the caller, plus load_input()/import_any()/export_any()/mesh_objs()/tri_count()/inspect_report()/apply_all_modifiers()/select_only(). End with emit({...}) to return data. Python exceptions come back as clean tracebacks. Use blender_process for the common canned operations; this is for everything else (procedural geometry, custom cleanup, baking, batch edits). Executes native code locally — hidden in read-only mode. Needs Blender installed (auto-detected or TUFAN_BLENDER_PATH).

meshy_generateA

Generate a 3D model with Meshy AI from a text prompt (two-stage: geometry preview → texture refine, auto-chained) or a single image (imageUrl or local imagePath). Downloads the resulting GLB + PBR maps to the local work dir (~/.tufan-blox-bridge/assets//) and reports the paths — pair with blender_process (lint/fix) and import_file (upload+insert), or use generate_asset for the whole pipeline in one call. SPENDS MESHY CREDITS (~30 ≈ $0.60 per textured asset): the first call returns a cost estimate and asks for confirm:true unless TUFAN_MESHY_AUTOCONFIRM=1. Generation takes minutes; if waitSeconds runs out you get a taskId to resume with (no re-spend). Needs TUFAN_MESHY_KEY (paid Meshy plan).

meshy_taskA

Inspect or act on an existing Meshy task by id: status (poll progress), download (re-fetch fresh signed URLs and save the GLB + PBR maps locally), remesh (retopologize an existing task's model to targetPolycount — 5 credits, textures preserved; use to bring a >20k-tri result under Roblox's limit without regenerating), balance (remaining account credits — no taskId needed). Needs TUFAN_MESHY_KEY.

generate_assetA

FULL PIPELINE: turn a text prompt (or an image) into a game-ready asset in the open place — Meshy AI generates the textured mesh, headless Blender lints it against Roblox limits and auto-fixes (decimates >20k tris, downscales >1024px textures; autoFix:false to skip), then the GLB uploads to the user's Roblox account via Open Cloud and inserts as a Model. SPENDS MESHY CREDITS (~30 ≈ $0.60 per asset) — first call returns a cost estimate and asks for confirm:true unless TUFAN_MESHY_AUTOCONFIRM=1. Generation takes minutes; on budget exhaustion you get a meshyTaskId to resume with (no re-spend). Position the inserted model afterwards with place_on. Needs TUFAN_MESHY_KEY + TUFAN_OPENCLOUD_KEY (Blender optional but recommended). For an EXISTING marketplace asset by id use insert_asset instead; for a local file you already have use import_file instead; to generate WITHOUT auto-inserting into the place (just the raw model), use meshy_generate instead.

format_scriptsA

Format Luau on disk with StyLua (the standard Roblox formatter) over a place's synced script mirror. Default formats in place; check:true reports what's NOT formatted WITHOUT writing (a --check diff) — use it as a pre-commit gate so git diffs and snapshots stay clean. Respects a .stylua.toml in the project. Scope with paths (relative to the mirror root) or format the whole mirror. Needs StyLua installed (auto-detected or TUFAN_STYLUA_PATH).

lint_scriptsA

Lint Luau with Selene (the standard Roblox linter) over a place's synced script mirror — catches footguns, unused variables, shadowing, undefined globals, and deprecated APIs (file:line). Read-only: reports findings, changes nothing. Scope with paths or lint the whole mirror. Needs Selene installed (auto-detected or TUFAN_SELENE_PATH) and a selene.toml with std="roblox" in the project (else Roblox globals report as undefined).

export_sourcemapA

Generate a Rojo-style sourcemap.json from a place's synced script mirror — the file luau-lsp needs to resolve require paths and give IntelliSense/type info in VS Code (and the foundation the typecheck tool will build on). Pure filesystem walk of the on-disk mirror: no Studio round-trip, no mutation. Writes to /sourcemap.json by default. Point luau-lsp at it via the luau-lsp.sourcemap.sourcemapFile setting. (Reflects scripts + folders in the mirror; non-script instances aren't on disk so aren't represented — that's all luau-lsp needs for requires.)

typecheckA

Type-check Luau with luau-lsp (the Luau analyzer) over a place's synced script mirror — catches type errors, undefined globals, and bad require paths BEFORE the code runs. Read-only: reports findings, changes nothing. Resolves requires via a sourcemap (uses sourcemap.json if present, else synthesizes one) and Roblox globals via type defs (TUFAN_LUAU_DEFS, a project globalTypes.d.luau, or an auto-cached download). Scope with paths or check the whole mirror. Needs luau-lsp installed (auto-detected or TUFAN_LUAU_LSP_PATH).

datastoreA

Inspect/edit a PUBLISHED game's saved data via the Open Cloud DataStore API (server-side HTTP, no Studio runtime). READ actions: list_datastores, list_keys, get, list_ordered, get_ordered. WRITE actions (gated — need confirm:true and are blocked in read-only mode): set, delete, increment. ⚠ SESSION-LOCK WARNING: a live game server owns the keys of ONLINE players (ProfileStore session lock); the REST write path ignores that lock, so writing such a key either gets overwritten by the server's autosave or corrupts the live session. Only write keys for OFFLINE players. ⚠ SHARED BUDGET: since 2026-07-29 Open Cloud DataStore calls count against the SAME unified per-experience request budget as the live game's in-game DataStore calls (base 300 + CCU × multiplier per request type/minute) — heavy MCP-driven reads/writes can starve a running game; watch the quota: line when the API returns rate-limit headers. Needs an Open Cloud key with universe-datastores scopes (TUFAN_OPENCLOUD_KEY) and a published universe (auto-detected from game.GameId, or TUFAN_UNIVERSE_ID).

cloud_luauA

Run server-side Luau against your PUBLISHED game via the Open Cloud Luau Execution API — a fresh ephemeral server loads the latest published place version, runs your script in SERVER context (require/ModuleScripts work; existing scripts do NOT auto-run; no physics), and returns the script's return values + print logs. The closest thing to 'verify in production' without joining the game. ⚠ NOT a side-effect sandbox: DataStoreService and HttpService ARE available and PERSIST (a script could even AssetService:SavePlaceAsync) — runtime/in-memory state is throwaway, but cloud writes are real. Long scripts: if still running when the wait elapses, re-call with resume = the returned task path. Needs an Open Cloud key with the luau-execution scope (TUFAN_OPENCLOUD_KEY) + a published universe. For Studio EDIT-mode code use run_luau instead; for code inside a live Studio play session use Roblox's official Studio MCP (execute_luau).

get_server_logsA

Recent PRODUCTION game-server logs (errors/warnings with full stack traces) via the Open Cloud Server Management API (Game Server Logs, BETA) — per-server visibility into your LIVE game, the same data as Creator Hub → Server Management → Logs tab. Logs take ~3 min to appear after they're emitted. Pass serverId (a jobId, same as game.JobId) to read one server's logs; omit it to list the currently running servers so you can pick one (re-call with serverId). Server-emitted duplicates are aggregated into skippedCount. Needs TUFAN_OPENCLOUD_KEY with the universe read scope. Siblings: get_output_log = edit-mode Studio Output; get_recent_errors = live Studio session feed; this = PRODUCTION servers. Pair with get_server_history to find terminated/crashed servers (logs stay readable after shutdown).

get_server_historyA

Server History for your PUBLISHED game via the Open Cloud Server Management API (BETA) — a rolling 30-day list of active AND terminated servers (shut down / restarted / crashed / out_of_memory / moderated) with status, uptime, termination time, last-known memory/fps/occupancy. Default view is terminated servers only; pass status:active for live servers or status:all for everything. This is the same ListGameServers endpoint Creator Hub's Server Management page uses. Needs TUFAN_OPENCLOUD_KEY with the universe read scope. Siblings: get_output_log = edit-mode Studio Output; get_recent_errors = live Studio session feed; this = PRODUCTION servers. Follow up with get_server_logs serverId: to read a server's errors/stack traces (logs remain available after termination).

project_contextA

Persistent per-project AI context (markdown) stored on the MCP server at ~/.tufan-blox-bridge/context/.md — survives sessions and is shared by every AI session that touches this place. CALL get AT SESSION START, BEFORE exploring the place: it carries hard-won facts (architecture, conventions, gotchas, false-bug-report traps) that save tokens and prevent wrong conclusions. set overwrites the blob; append adds a dated entry — update it whenever you learn something durable about the place (a confirmed bug's root cause, a naming convention, a do-not-touch area). get works in read-only mode; set/append are write-gated. An explicit numeric PlaceId works even with no Studio connected (storage is local).

Prompts

Interactive templates invoked by user choice

NameDescription

No prompts

Resources

Contextual data attached and managed by the client

NameDescription

No resources

TDQS

A3.9/5.0

Scored across 87 tools

Disambiguation4/5

Descriptions do heavy lifting with explicit 'use X instead' cross-references, cleanly splitting near-neighbours like get_properties vs describe vs get_attributes, and search_objects vs search_by_property vs search_assets. The main risk is the four parallel undo/restore mechanisms (history, snapshot/restore, restore_from_mirror, git_restore) and the several script-writing tools (script_source, patch_script, edit_script_lines, find_and_replace_in_scripts), which an agent can still misselect despite the guidance.

Naming Consistency3/5

The bulk is snake_case verb_noun (get_tree, set_property, create_instance, git_commit, scan_perf), with pleasant domain prefixes (git_*, meshy_*, blender_*). But a sizeable minority are bare nouns or ambiguous names — snapshot, restore, describe, pick, place_on, tag, batch, history, typecheck, datastore, is_running — and `tag` uses an action parameter while sibling tools split actions into separate verbs, so conventions are mixed though still readable.

Tool Count2/5

87 tools vastly exceeds a workable selection surface; each domain (Studio edits, git, disk mirror, Blender, Meshy, Open Cloud) justifies its members, but the aggregate forces the agent to scan a huge catalogue before acting. Consolidation into families (e.g. one indexed action-based tool per domain like `datastore` and `tag` already do) would cut this dramatically.

Completeness4/5

Coverage is unusually deep: full CRUD plus batch, hierarchy mapping, script edit/lint/typecheck/format, three-tier recovery (undo stack, snapshots, disk mirror, git), asset search/generation/import, and production logs/datastores. Minor gaps remain — no place publishing/packaging, no plugin installation, and live play-session control is deliberately deferred to Roblox's official Studio MCP — but no workflow is truly blocked.

Maintenance

ActivityNo data
ResponsivenessOutdated data