# Tripwire

> Agentic MCP for Roblox. Run tests and find exploits in your game from Claude Code, Codex, or Gemini.

- **Type:** MCP server
- **Install:** `agentstack add mcp-aliboily-tripwire`
- **Verified:** Yes — security-reviewed for prompt injection and unsafe behavior
- **Seller:** [aliboIly](https://agentstack.voostack.com/s/aliboily)
- **Installs:** 0
- **Category:** [Integrations](https://agentstack.voostack.com/c/integrations)
- **Latest version:** 0.1.0
- **License:** MIT
- **Upstream author:** [aliboIly](https://github.com/aliboIly)
- **Source:** https://github.com/aliboIly/Tripwire
- **Website:** https://www.npmjs.com/package/tripwire-roblox

## Install

```sh
agentstack add mcp-aliboily-tripwire
```

Requires the [AgentStack CLI](https://agentstack.voostack.com/docs/cli). Works with Claude Code, Cursor, and any MCP-compatible agent.

## About

# Tripwire

**made by alibolly**

[](https://www.npmjs.com/package/tripwire-roblox)
[](https://github.com/aliboIly/Tripwire/actions/workflows/ci.yml)
[](https://registry.modelcontextprotocol.io)
[](LICENSE)

An MCP server that gives an AI coding agent real control of Roblox Studio and Roblox Open Cloud,
with a test-and-security layer no other Studio MCP has.

Tripwire lets an assistant read, write, and edit the data model, drive playtests with simulated
input, run tests-as-code headlessly in the real engine, flag client-trust exploits in game code,
and call the Open Cloud APIs (DataStores, MessagingService, Memory Stores, and more). The Studio
tools need no API key; the headless test, asset, and Open Cloud tools use an Open Cloud key.

---

## Requirements

- An MCP client: Claude Code, Codex, Gemini, or any client that speaks MCP over stdio.
- Roblox Studio, for the Studio tools. These need no API key.
- Node.js, only if you run the server with `npx`. The prebuilt binary needs no Node.
- For the headless test, asset, and Open Cloud tools: a published place and a Roblox Open Cloud API key. See [Open Cloud setup](#open-cloud-setup).

## Quickstart

Tripwire is for Roblox developers who drive Studio through an AI coding agent.

1. Wire the server into your MCP client (one command or a small config block, see [Install](#install) below).
2. Install the Studio plugin so the Studio tools can reach Studio (see the plugin step in Install).
3. Open your place in Studio, turn on Game Settings > Security > Allow HTTP Requests, then click the Tripwire toolbar button and press Connect in the panel. The panel shows Connected and the Output prints `[Tripwire v...] connected`.
4. Ask your agent to run `studio_status`. A connected Studio confirms the bridge works.
5. Optional: add an Open Cloud key for the headless test, asset, and Open Cloud tools (see Open Cloud setup).

---

## Install

Tripwire's server is a single binary. The easiest way to run it is with `npx`, which fetches the
prebuilt binary for your platform, so there is no Rust toolchain to install. Prefer a manual binary
or a source build? See the Alternatives at the end of this section.

Claude Code

One command:

```bash
claude mcp add --transport stdio tripwire -- npx -y tripwire-roblox
```

Or add it to a project `.mcp.json` (or `~/.claude.json`):

```json
{
  "mcpServers": {
    "tripwire": {
      "type": "stdio",
      "command": "npx",
      "args": ["-y", "tripwire-roblox"]
    }
  }
}
```

Codex

Add to `~/.codex/config.toml`:

```toml
[mcp_servers.tripwire]
command = "npx"
args = ["-y", "tripwire-roblox"]
```

Or: `codex mcp add tripwire -- npx -y tripwire-roblox`

Gemini

Add to `~/.gemini/settings.json` (or a project `.gemini/settings.json`):

```json
{
  "mcpServers": {
    "tripwire": {
      "command": "npx",
      "args": ["-y", "tripwire-roblox"]
    }
  }
}
```

Or: `gemini mcp add tripwire npx -y tripwire-roblox`

Other MCP clients

Any client that speaks MCP over stdio can run it:

```
command: npx
args:    ["-y", "tripwire-roblox"]
```

Alternatives: prebuilt binary, or build from source

**Prebuilt binary (no Node).** Download the archive for your platform from the
[Releases](https://github.com/aliboIly/Tripwire/releases) page (for example
`tripwire-server-vX.Y.Z-aarch64-apple-darwin.tar.gz`), extract it, and point your client's
`command` at the extracted `tripwire-server` with empty `args`.

**Build from source** (needs [Rust](https://rustup.rs)):

```bash
git clone https://github.com/aliboIly/Tripwire.git
cd Tripwire/server
cargo build --release   # produces server/target/release/tripwire-server
```

Then point your client's `command` at that binary path.

Studio plugin (required for the Studio tools)

The Studio tools reach Studio through a small plugin that long-polls the local server. Grab
`Tripwire.rbxmx` from the [Releases](https://github.com/aliboIly/Tripwire/releases) page, or build it:

```bash
cd Tripwire/plugin
npm install
npx rbxtsc
rojo build --output Tripwire.rbxmx
cp Tripwire.rbxmx ~/Documents/Roblox/Plugins/   # macOS; Windows: %LOCALAPPDATA%\Roblox\Plugins
```

Restart Studio, enable **Game Settings > Security > Allow HTTP Requests**, then click the
**Tripwire** toolbar button and press **Connect** in the panel. The panel shows Connected and
the Output prints `[Tripwire v...] connected`.

Open Cloud key (for headless tests, assets, and Open Cloud tools)

The Studio tools need no key. The Open Cloud tools do. See [Open Cloud setup](#open-cloud-setup)
below for the full walkthrough.

---

## Open Cloud setup

Most of Tripwire needs no credentials. These tools do, because they call Roblox Open Cloud:
`run_luau`, the headless tests (`run_tests`, `run_test_file`, `list_tests`), `upload_asset`,
`publish_place`, and the DataStore, Ordered DataStore, MessagingService, Memory Store, platform,
and engagement tools. They authenticate with a Roblox Open Cloud API key.

> **Use at your own risk.** An Open Cloud key is a real credential with real power over your
> experience. Depending on the scopes you grant it, it can read and overwrite your live DataStores,
> publish new versions of your place, upload assets to your account, and message your servers. Treat
> it like a password: grant only the scopes you actually use, restrict it to your own IP, never
> commit it, and revoke it if it leaks. You are responsible for what you do with it. Tripwire is not
> affiliated with or endorsed by Roblox.

### 1. Create the key

1. Go to [create.roblox.com/dashboard/credentials](https://create.roblox.com/dashboard/credentials) and sign in.
2. Click **Create API Key** and name it (for example `Tripwire`).
3. Under **Access Permissions**, add only the API systems for the tools you want, and grant each the operation it needs, scoped to your experience:
   - **Luau Execution** (write): `run_luau` and the headless tests.
   - **universe-places** (write): `publish_place`.
   - **Assets** (read + write): `upload_asset`.
   - **DataStores** and **Ordered DataStores**: the data-store tools.
   - **Messaging Service** (publish) and **Memory Stores**: those tools.
   - **User/Group/Inventory/Subscription/Notification**: the platform and engagement tools.
4. Under **Security**, set **Accepted IP Addresses** to your machine's IP, or `0.0.0.0/0` to allow any (simplest for local use). Set an expiration if you want.
5. Click **Save & Generate Key** and copy the key string. It is shown only once.

### 2. Find your universe and place IDs

In the Studio command bar (View, then Command Bar), run:

```lua
print("universe", game.GameId, "place", game.PlaceId)
```

`GameId` is your `ROBLOX_UNIVERSE_ID`; `PlaceId` is your `ROBLOX_PLACE_ID`. The place must be
**published** to Roblox for Open Cloud to act on it.

### 3. Give Tripwire the credentials

Create a `.env` at the repo root. It is gitignored and the server loads it automatically:

```bash
ROBLOX_OPEN_CLOUD_KEY=paste_the_key_here
ROBLOX_UNIVERSE_ID=000000
ROBLOX_PLACE_ID=000000
ROBLOX_CREATOR_USER_ID=000000   # only for upload_asset (your user id)
```

Or put the same variables in your MCP client's `env` block instead (those take precedence).
Reconnect the MCP server after changing either. Each tool works when the key grants its scope and
returns Roblox's own error if a scope is missing, so you can add scopes as you go.

---

## Tools

### Connection
studio_statusWhether a Studio is connected, the active place, and any other connected studios.
ping_studioRound-trip a ping through the plugin to confirm the live bridge works.
list_studiosList every connected (or recently seen) Studio: place, whether it is active, last-seen, and playtest state.
set_active_studioChoose which connected Studio the tools target (by id, id prefix, or place name). Automatic with one Studio.

### Read and inspect
get_file_treeList the instance tree from a path (default the whole game), bounded by depth.
get_instance_childrenList the direct children (name and class) of an instance.
get_instance_propertiesRead an instance's name, class, full path, attributes, and a curated set of common engine properties (Position, Size, Color, Material, Anchored, Text, and so on).
search_objectsFind instances whose name contains a query, optionally filtered by exact class or by class-and-subclasses (isA).
search_by_propertyFind instances whose property equals a value, optionally filtered by exact class or by class-and-subclasses (isA).
get_script_sourceRead the source of a Script, LocalScript, or ModuleScript.
grep_scriptsSearch script sources for a substring; returns path, line number, and line.
get_output_logRecent Studio Output entries (message, type, timestamp).
get_selectionThe instances currently selected in Studio.
get_class_infoLook up a Roblox class's members (properties, methods, events) with their types, inherited members folded in. Answered from a bundled API reflection dump, so it needs no Studio and no key.

### Spatial (read-only)
raycastCast a ray and report the first hit (instance, position, normal, material, distance) or no hit, with an optional excluded subtree.
get_bounding_boxThe world-space bounding box (center and size) of a Model or BasePart.
find_spawnsList the SpawnLocations under a path: position, whether each is enabled, and whether it is neutral.
capture_screenshotCapture the Studio viewport as a JPEG image so the agent can see the scene. Needs the plugin connected and Allow Mesh / Image APIs enabled (Game Settings, Security). Edit mode only.

### Edit (each is one undo step)
create_instanceCreate an instance of a class with an optional name and initial properties.
delete_instanceDestroy an instance and its descendants.
set_propertySet one typed property (primitive, Vector3, Color3, UDim2, CFrame, EnumItem, or an instance reference).
update_script_sourceReplace a script's source through the script editor (the supported write path).
insert_modelInsert an asset by id, with optional reposition or unpack.
mass_createCreate many instances in one undo step (atomic, or best-effort with per-item results).
mass_set_propertySet one property on many instances in one undo step (atomic or best-effort).

### Playtest and input
start_playtestStart an F5 playtest (server and client DataModels with a player); injects the in-play runner.
stop_playtestStop the F5 playtest (best-effort; F5 teardown can outlast the confirmation).
start_simulationStart an F8 run (server-only simulation, no client or player).
stop_simulationStop the F8 run (clean).
simulate_mouse_inputClick or move the mouse at screen coordinates during an F5 playtest.
simulate_keyboard_inputPress a key (tap/press/release) or type text during an F5 playtest.
character_navigationWalk the local character toward a world position; reports whether it reached the goal.
get_playtest_outputThe running playtest's output log, aggregated across the server and client peers. Pass the cursor from the previous call as since to get only new lines; the buffer is bounded so long sessions do not freeze it.
reset_playtest_outputClear the playtest's output buffers so the next read starts fresh, without restarting Studio.
run_luau_liveEvaluate Luau in the live F5 playtest server and return the result, so you can inspect the running game (a Humanoid's state, an NPC's position, a path's waypoints) without adding a print and replaying. Needs an active playtest and ServerScriptService.LoadStringEnabled on in the test place. Distinct from run_luau, which is headless against the published place.

### Tests and headless execution (Open Cloud)
run_luauRun a Luau script headlessly in the published place; returns the results and logs.
run_testsRun the headless test suite in the published place and report passed/failed with messages.
run_test_fileRun a single spec by name, headlessly.
list_testsList the spec files and their cases discovered in the published place.
write_testWrite a roblox-ts test spec to disk; rebuild and publish, then run_tests picks it up.

### Security review (static analysis, no key)
review_securityReview the game source for client-trust and unvalidated-remote issues, each with a suggested server-side fix.
scan_remotesList server remote handlers and the client-controlled parameters of each.
scan_client_trustFlag server handlers that use client-supplied values without validating them.

### Assets and publishing (Open Cloud)
upload_assetUpload a local file as a Roblox asset (Decal, Audio, Model, Animation, or Video); returns the assetId.
publish_placePublish a local place file (.rbxl/.rbxlx) as a new version of the experience.

### DataStores (Open Cloud)
list_datastoresList the standard data stores in the universe.
list_datastore_entriesList entry keys in a data store.
get_datastore_entryRead an entry's value and metadata.
set_datastore_entryCreate or overwrite an entry (value plus optional users/attributes).
delete_datastore_entrySoft-delete an entry (purged after 30 days).
increment_datastore_entryAtomically add an integer to a numeric entry.
list_ordered_entriesList ordered data store entries by value, ascending or descending.
get_ordered_entryRead one ordered data store entry.
set_ordered_entrySet (upsert) an ordered data store entry to a non-negative integer.
increment_ordered_entryAtomically add to an ordered data store entry.

### Messaging and memory (Open Cloud)
publish_messagePublish a message to a MessagingService topic (reaches running production servers).
memory_sorted_map_setSet (upsert) a Memory Store sorted-map item, with TTL and sort keys.
memory_sorted_map_getRead a Memory Store sorted-map item.
memory_sorted_map_listList sorted-map items in sort order.
memory_sorted_map_deleteDelete a sorted-map item.
memory_queue_addAdd an item to a Memory Store queue, with priority and TTL.
memory_queue_readRead items from a queue; returns a readId for the discard call.
memory_queue_discardPermanently remove a read batch by its readId.

### Platform and engagement (Open Cloud)
get_universeThe configured universe's metadata.
get_placeThe configured place's metadata.
get_userA user's public profile.
get_groupA group's metadata.
list_inventoryA user's inventory items, filterable by type or id.
send_notificationSend an experience notification to a user (from a Creator Dashboard template).
get_subscriptionRead a user's subscription to a subscription product.

---

## What you can do

- **Build scenes from a prompt.** Create and mass-create instances, set typed properties, insert
  models, and write scripts, each as a clean undo step.
- **Test gameplay in CI.** Write specs, run them headlessly in the real engine through Open Cloud,
  and gate pull requests on the results.
- **Catch exploits before they ship.** The security reviewer flags server handlers that trust client
  input and suggests the server-side fix; the same check runs automatically on every PR.
- **Drive a real playtest.** Enter Play mode, send keyboard and mouse input, walk the character to a
  spot, read the combined server/client output, then stop.
- **Inspect a live place.** Read the instance tree, search by name or property, read and grep
  scripts, and pull the Output log.
- **Automate Open Cloud.** Seed DataStores for test fixtures, publish a place, broadcast a
  MessagingService topic, or look up users, groups, and inventory.

---

## Known limits

These are platform limits, not bugs. They are written down here so you know going in.

- F5 playtest stop is best-effort. `stop_playtest` may not take, because the plugin and the running game are separate DataModels. `stop_simulation` (F8) stops cleanly. If an F5 playtest will not stop, press Stop in Studio.
- In-play actions go through an injected runner. Input, runtime state, and stop during a playtest are relayed over the bridge, not called directly on the plugin.
- Headless tests run a server context. Open Cloud runs your published place on a server, where `RunService:IsStudio()` is false and plugin APIs are absent. Use it for server and gameplay logic and the securi

…

## Source & license

This open-source MCP server is cataloged on AgentStack and links to its original source — we do not rehost the code.

- **Author:** [aliboIly](https://github.com/aliboIly)
- **Source:** [aliboIly/Tripwire](https://github.com/aliboIly/Tripwire)
- **License:** MIT
- **Homepage:** https://www.npmjs.com/package/tripwire-roblox

Install and usage instructions live in the source repository linked above.

## Pricing

- **Free** — Free

## Security capabilities

Automated source analysis of v0.1.0 — what this tool can access:

- **Network access:** no
- **Filesystem access:** no
- **Shell / process execution:** no
- **Environment & secrets:** yes
- **Dynamic code execution:** no

*"Yes" means the capability is present in the source — more access means more to trust, not that it is unsafe.*


## Versions

- **0.1.0** — security scan: passed — Imported from the upstream source.

## Links

- Listing page: https://agentstack.voostack.com/l/mcp-aliboily-tripwire
- Seller: https://agentstack.voostack.com/s/aliboily
- Browse the marketplace: https://agentstack.voostack.com/browse

---
Listed on AgentStack — the marketplace for AI agent skills and MCP servers. Every listing is security-reviewed. Creators keep 70%.
