conduit-mcp 2.0.0 → 2.0.3

package/dist/{chunk-JDWBW44K.js → chunk-HI6KFLGA.js}

@@ -10,7 +10,7 @@ import { WebSocketServer, WebSocket } from "ws";
 // src/protocol.ts
 import { randomUUID } from "crypto";
 function generateId() {
-  return randomUUID().slice(0, 8);
+  return randomUUID().slice(0, 16);
 }
 function isHeartbeat(msg) {
   return typeof msg === "object" && msg !== null && "type" in msg && msg.type === "heartbeat";
@@ -41,8 +41,10 @@ var log = {
 var REQUEST_TIMEOUT_MS = 3e4;
 var HEARTBEAT_CHECK_INTERVAL_MS = 5e3;
 var HEARTBEAT_TIMEOUT_MS = 15e3;
+var PING_INTERVAL_MS = 1e4;
 var LONG_POLL_TIMEOUT_MS = 25e3;
 var MAX_PORT_RETRIES = 10;
+var REGISTRATION_TIMEOUT_MS = 1e4;
 var Bridge = class extends EventEmitter {
   constructor(port = 3200) {
     super();
@@ -56,6 +58,7 @@ var Bridge = class extends EventEmitter {
   pendingRequests = /* @__PURE__ */ new Map();
   lastHeartbeats = /* @__PURE__ */ new Map();
   heartbeatTimer = null;
+  pingTimer = null;
   actualPort = 0;
   // HTTP-only studios (no WebSocket connection)
   httpStudios = /* @__PURE__ */ new Map();
@@ -65,8 +68,10 @@ var Bridge = class extends EventEmitter {
   httpPendingCommands = /* @__PURE__ */ new Map();
   httpPollWaiters = /* @__PURE__ */ new Map();
   get isConnected() {
-    const studio = this.getActiveStudio();
-    return studio !== void 0 && studio.ws.readyState === WebSocket.OPEN;
+    for (const [, studio] of this.studios) {
+      if (studio.ws.readyState === WebSocket.OPEN) return true;
+    }
+    return this.httpStudios.size > 0;
   }
   get listeningPort() {
     return this.actualPort;
@@ -92,7 +97,35 @@ var Bridge = class extends EventEmitter {
     log.info(`Active studio set to: ${studioId}`);
   }
   // ── Server lifecycle ───────────────────────────────────────────
+  /**
+   * Try to shut down a stale Conduit instance on the target port.
+   * Returns true if the port was freed (or was already free).
+   */
+  async evictStaleInstance(port) {
+    return new Promise((resolve) => {
+      const req = http.request(
+        {
+          hostname: "127.0.0.1",
+          port,
+          path: "/shutdown",
+          method: "POST",
+          timeout: 2e3
+        },
+        (res) => {
+          res.resume();
+          setTimeout(() => resolve(true), 500);
+        }
+      );
+      req.on("error", () => resolve(false));
+      req.on("timeout", () => {
+        req.destroy();
+        resolve(false);
+      });
+      req.end();
+    });
+  }
   async start() {
+    await this.evictStaleInstance(this.port);
     return new Promise((resolve, reject) => {
       let attempts = 0;
       const tryPort = (port) => {
@@ -102,6 +135,9 @@ var Bridge = class extends EventEmitter {
         server.once("error", (err) => {
           if (err.code === "EADDRINUSE" && attempts < MAX_PORT_RETRIES) {
             attempts++;
+            log.warn(
+              `Port ${port} still in use after eviction \u2014 trying ${port + 1}`
+            );
             tryPort(port + 1);
           } else {
             reject(err);
@@ -139,6 +175,7 @@ var Bridge = class extends EventEmitter {
       clearInterval(this.heartbeatTimer);
       this.heartbeatTimer = null;
     }
+    this.stopPingInterval();
     for (const [, waiters] of this.httpPollWaiters) {
       for (const waiter of waiters) {
         clearTimeout(waiter.timer);
@@ -209,30 +246,33 @@ var Bridge = class extends EventEmitter {
     if (active && active.ws.readyState === WebSocket.OPEN) {
       return active;
     }
-    if (this.studios.size === 1) {
-      const [studioId, studio] = this.studios.entries().next().value;
+    for (const [studioId, studio] of this.studios) {
       if (studio.ws.readyState === WebSocket.OPEN) {
         this.activeStudioId = studioId;
+        log.info(`Auto-selected active studio: ${studioId}`);
         return studio;
       }
     }
-    if (this.studios.size === 0) {
-      return void 0;
-    }
-    throw new Error(
-      `Multiple Studio instances connected but none is active. Use set_active_studio to choose one. Connected: ${Array.from(
-        this.studios.values()
-      ).map((s) => `${s.info.studioId} (${s.info.placeName ?? "unknown"})`).join(", ")}`
-    );
+    return void 0;
   }
   // ── WebSocket handling ─────────────────────────────────────────
   handleWsConnection(ws) {
     log.info("New WebSocket connection \u2014 waiting for registration");
     this.pendingWs.add(ws);
+    const registrationTimer = setTimeout(() => {
+      if (this.pendingWs.has(ws)) {
+        log.warn(
+          "WebSocket failed to register within timeout \u2014 closing"
+        );
+        this.pendingWs.delete(ws);
+        ws.close(1008, "Registration timeout");
+      }
+    }, REGISTRATION_TIMEOUT_MS);
     const onFirstMessage = (data) => {
       try {
         const msg = JSON.parse(data.toString());
         if (isStudioRegistration(msg)) {
+          clearTimeout(registrationTimer);
           ws.removeListener("message", onFirstMessage);
           this.pendingWs.delete(ws);
           this.registerStudio(ws, {
@@ -243,9 +283,10 @@ var Bridge = class extends EventEmitter {
           });
           return;
         }
+        clearTimeout(registrationTimer);
         ws.removeListener("message", onFirstMessage);
         this.pendingWs.delete(ws);
-        const syntheticId = "studio-1";
+        const syntheticId = `studio-legacy-${Date.now()}`;
         log.info(
           "Legacy plugin detected (no registration), assigning ID: " + syntheticId
         );
@@ -259,12 +300,17 @@ var Bridge = class extends EventEmitter {
       }
     };
     ws.on("message", onFirstMessage);
-    ws.on("close", () => {
+    const onEarlyClose = () => {
+      clearTimeout(registrationTimer);
       this.pendingWs.delete(ws);
-    });
-    ws.on("error", (err) => {
+    };
+    const onEarlyError = (err) => {
       log.warn("WebSocket error:", err.message);
-    });
+    };
+    ws.on("close", onEarlyClose);
+    ws.on("error", onEarlyError);
+    ws.__earlyClose = onEarlyClose;
+    ws.__earlyError = onEarlyError;
   }
   registerStudio(ws, info) {
     const { studioId } = info;
@@ -275,6 +321,10 @@ var Bridge = class extends EventEmitter {
     }
     this.studios.set(studioId, { ws, info });
     this.lastHeartbeats.set(studioId, Date.now());
+    ws.isAlive = true;
+    ws.on("pong", () => {
+      ws.isAlive = true;
+    });
     if (this.activeStudioId === null) {
       this.activeStudioId = studioId;
     }
@@ -283,11 +333,23 @@ var Bridge = class extends EventEmitter {
       `Studio registered: ${studioId}` + (info.placeName ? ` (${info.placeName})` : "")
     );
     this.startHeartbeatMonitor();
+    this.startPingInterval();
+    if (ws.__earlyClose) {
+      ws.removeListener("close", ws.__earlyClose);
+      delete ws.__earlyClose;
+    }
+    if (ws.__earlyError) {
+      ws.removeListener("error", ws.__earlyError);
+      delete ws.__earlyError;
+    }
     ws.on("message", (data) => {
       try {
         const msg = JSON.parse(data.toString());
         if (isHeartbeat(msg)) {
           this.lastHeartbeats.set(studioId, Date.now());
+          if (ws.readyState === WebSocket.OPEN) {
+            ws.send(JSON.stringify({ type: "heartbeat_ack" }));
+          }
           return;
         }
         this.handlePluginMessage(msg);
@@ -303,7 +365,7 @@ var Bridge = class extends EventEmitter {
         this.emit("studio-disconnected", info);
         log.info(`Studio disconnected: ${studioId}`);
         if (this.activeStudioId === studioId) {
-          if (this.studios.size === 1) {
+          if (this.studios.size > 0) {
             this.activeStudioId = this.studios.keys().next().value;
             log.info(
               `Auto-switched active studio to: ${this.activeStudioId}`
@@ -314,26 +376,27 @@ var Bridge = class extends EventEmitter {
         }
         if (this.studios.size === 0) {
           this.stopHeartbeatMonitor();
+          this.stopPingInterval();
         }
       }
     });
   }
   handlePluginMessage(msg) {
-    if (isBridgeResponse(msg)) {
+    if (isBridgeError(msg)) {
       const pending = this.pendingRequests.get(msg.id);
       if (pending) {
         clearTimeout(pending.timer);
         this.pendingRequests.delete(msg.id);
-        pending.resolve(msg.result);
+        pending.reject(new Error(`${msg.error.code}: ${msg.error.message}`));
       }
       return;
     }
-    if (isBridgeError(msg)) {
+    if (isBridgeResponse(msg)) {
       const pending = this.pendingRequests.get(msg.id);
       if (pending) {
         clearTimeout(pending.timer);
         this.pendingRequests.delete(msg.id);
-        pending.reject(new Error(`${msg.error.code}: ${msg.error.message}`));
+        pending.resolve(msg.result);
       }
       return;
     }
@@ -350,7 +413,8 @@ var Bridge = class extends EventEmitter {
             log.warn(
               `Heartbeat timeout for studio "${studioId}" \u2014 disconnecting`
             );
-            studio.ws.terminate();
+            studio.ws.close(1001, "Heartbeat timeout");
+            this.lastHeartbeats.delete(studioId);
           } else if (this.httpStudios.has(studioId)) {
             log.warn(
               `Heartbeat timeout for HTTP studio "${studioId}" \u2014 evicting`
@@ -374,9 +438,35 @@ var Bridge = class extends EventEmitter {
       this.heartbeatTimer = null;
     }
   }
+  startPingInterval() {
+    if (this.pingTimer) return;
+    this.pingTimer = setInterval(() => {
+      for (const [studioId, studio] of this.studios) {
+        const ws = studio.ws;
+        if (ws.isAlive === false) {
+          log.warn(
+            `Ping timeout for studio "${studioId}" \u2014 terminating connection`
+          );
+          ws.terminate();
+          return;
+        }
+        ws.isAlive = false;
+        ws.ping();
+      }
+    }, PING_INTERVAL_MS);
+  }
+  stopPingInterval() {
+    if (this.pingTimer) {
+      clearInterval(this.pingTimer);
+      this.pingTimer = null;
+    }
+  }
   // ── HTTP fallback handling ─────────────────────────────────────
   handleHttp(req, res) {
-    res.setHeader("Access-Control-Allow-Origin", "*");
+    const origin = req.headers.origin;
+    if (origin && (origin.startsWith("http://localhost") || origin.startsWith("http://127.0.0.1"))) {
+      res.setHeader("Access-Control-Allow-Origin", origin);
+    }
     res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
     res.setHeader("Access-Control-Allow-Headers", "Content-Type");
     if (req.method === "OPTIONS") {
@@ -386,6 +476,20 @@ var Bridge = class extends EventEmitter {
     }
     const parsedUrl = new URL(req.url ?? "/", `http://127.0.0.1`);
     const pathname = parsedUrl.pathname;
+    if (req.method === "POST" && pathname === "/shutdown") {
+      if (req.headers.origin) {
+        res.writeHead(403);
+        res.end("Forbidden");
+        return;
+      }
+      log.info("Received shutdown request from new Conduit instance");
+      res.writeHead(200);
+      res.end("ok");
+      setImmediate(() => {
+        this.emit("shutdown");
+      });
+      return;
+    }
     if (req.method === "GET" && pathname === "/health") {
       res.writeHead(200, { "Content-Type": "application/json" });
       res.end(
@@ -393,7 +497,8 @@ var Bridge = class extends EventEmitter {
           status: "ok",
           connected: this.isConnected,
           port: this.actualPort,
-          studios: this.getStudios()
+          studios: this.getStudios(),
+          activeStudioId: this.activeStudioId
         })
       );
       return;
@@ -404,6 +509,11 @@ var Bridge = class extends EventEmitter {
       return;
     }
     if (req.method === "POST" && pathname === "/result") {
+      if (req.headers.origin) {
+        res.writeHead(403);
+        res.end("Forbidden");
+        return;
+      }
       this.handleResult(req, res);
       return;
     }
@@ -418,8 +528,10 @@ var Bridge = class extends EventEmitter {
           connectedAt: Date.now()
         };
         this.httpStudios.set(studioId, info);
+        this.lastHeartbeats.set(studioId, Date.now());
         this.emit("studio-connected", info);
         log.info(`HTTP-only studio registered: ${studioId}`);
+        this.startHeartbeatMonitor();
       }
       this.lastHeartbeats.set(studioId, Date.now());
       if (this.activeStudioId === null) {
@@ -464,9 +576,22 @@ var Bridge = class extends EventEmitter {
     this.httpPollWaiters.set(studioId, waiters);
   }
   handleResult(req, res) {
-    let body = "";
-    req.on("data", (chunk) => body += chunk);
+    const MAX_BODY_SIZE = 10 * 1024 * 1024;
+    const chunks = [];
+    let totalSize = 0;
+    req.on("data", (chunk) => {
+      totalSize += chunk.length;
+      if (totalSize > MAX_BODY_SIZE) {
+        req.destroy();
+        res.writeHead(413);
+        res.end("Request body too large");
+        return;
+      }
+      chunks.push(chunk);
+    });
     req.on("end", () => {
+      if (totalSize > MAX_BODY_SIZE) return;
+      const body = Buffer.concat(chunks).toString("utf-8");
       try {
         const msg = JSON.parse(body);
         this.handlePluginMessage(msg);
@@ -520,7 +645,6 @@ function truncateToTokenBudget(text, budget) {
 }
 
 // src/utils/formatting.ts
-var DEFAULT_TOKEN_BUDGET = 4e3;
 function formatTree(data, depth = 0, indent = "") {
   let line = `${indent}- **${data.name}** \`${data.className}\``;
   if (data.properties && Object.keys(data.properties).length > 0) {
@@ -528,7 +652,7 @@ function formatTree(data, depth = 0, indent = "") {
     line += ` (${props})`;
   }
   let result = line + "\n";
-  if (data.children && depth > 0) {
+  if (data.children && depth >= 0) {
     for (const child of data.children) {
       result += formatTree(child, depth - 1, indent + "  ");
     }
@@ -552,8 +676,8 @@ ${source}
 \`\`\``;
 }
 function applyTokenBudget(text, maxTokens) {
-  const budget = maxTokens ?? DEFAULT_TOKEN_BUDGET;
-  const { text: result } = truncateToTokenBudget(text, budget);
+  if (maxTokens === void 0) return text;
+  const { text: result } = truncateToTokenBudget(text, maxTokens);
   return result;
 }
 function formatValue(v) {
@@ -883,6 +1007,9 @@ function registerWrite(server, bridge) {
           sources: params.sources,
           targetParent: params.targetParent
         });
+        if (result2.cloned.length === 0) {
+          return { content: [{ type: "text", text: "No instances were cloned." }] };
+        }
         const text2 = result2.cloned.map((r) => `- \`${r.path}\` (${r.className})`).join("\n");
         return { content: [{ type: "text", text: text2 }] };
       }
@@ -892,6 +1019,9 @@ function registerWrite(server, bridge) {
       const result = await bridge.send("create_instances", {
         operations: params.operations
       });
+      if (result.created.length === 0) {
+        return { content: [{ type: "text", text: "No instances were created." }] };
+      }
       const text = result.created.map((r) => `- \`${r.path}\` (${r.className})`).join("\n");
       return { content: [{ type: "text", text }] };
     }
@@ -956,6 +1086,9 @@ function registerWrite(server, bridge) {
       const result = await bridge.send("modify_instances", {
         operations: params.operations
       });
+      if (result.modified.length === 0) {
+        return { content: [{ type: "text", text: "No instances were modified." }] };
+      }
       const text = result.modified.map((r) => `- \`${r.path}\` \u2014 modified: ${r.modified.join(", ")}`).join("\n");
       return { content: [{ type: "text", text }] };
     }
@@ -979,6 +1112,9 @@ function registerWrite(server, bridge) {
       const result = await bridge.send("delete_instances", {
         paths: params.paths
       });
+      if (result.deleted.length === 0) {
+        return { content: [{ type: "text", text: "No instances were deleted." }] };
+      }
       const text = result.deleted.map((p) => `- \`${p}\` \u2014 deleted`).join("\n");
       return { content: [{ type: "text", text }] };
     }
@@ -1016,6 +1152,12 @@ function registerReadScript(server, bridge) {
       }
     },
     async (params) => {
+      if (params.lineRange && params.lineRange.end < params.lineRange.start) {
+        return {
+          content: [{ type: "text", text: "lineRange.end must be >= lineRange.start." }],
+          isError: true
+        };
+      }
       const result = await bridge.send("read_script", {
         path: params.path,
         lineRange: params.lineRange
@@ -1061,6 +1203,30 @@ function registerWriteTools(server, bridge) {
       }
     },
     async (params) => {
+      if (params.mode === "range" && params.edits && params.edits.some((e) => e.endLine < e.startLine)) {
+        return {
+          content: [{ type: "text", text: "Range edit has endLine < startLine." }],
+          isError: true
+        };
+      }
+      if (params.mode === "full" && params.source === void 0) {
+        return {
+          content: [{ type: "text", text: "full mode requires a `source` parameter." }],
+          isError: true
+        };
+      }
+      if (params.mode === "range" && (!params.edits || params.edits.length === 0)) {
+        return {
+          content: [{ type: "text", text: "range mode requires a non-empty `edits` array." }],
+          isError: true
+        };
+      }
+      if (params.mode === "find_replace" && !params.find) {
+        return {
+          content: [{ type: "text", text: "find_replace mode requires a `find` parameter." }],
+          isError: true
+        };
+      }
       if (params.mode === "multi_replace") {
         if (!params.scripts || params.scripts.length === 0) {
           return { content: [{ type: "text", text: "multi_replace mode requires a non-empty `scripts` array." }] };
@@ -1155,14 +1321,16 @@ ${outputText}
 
 // src/tools/playtest.ts
 import { z as z4 } from "zod";
+var playtestStartedAt = null;
 function register4(server, bridge) {
   server.registerTool(
     "playtest",
     {
       title: "Playtest Control & Virtual Input",
-      description: "Control Roblox Studio playtesting and simulate user input.\n\nActions:\n- `start`: Begin a playtest session.\n- `stop`: End the current playtest.\n- `execute`: Run Lua code in the running game context.\n- `get_output`: Get console/log output from Studio (works in edit mode and during playtest).\n- `inspect`: Evaluate a Luau expression and return the typed result (requires active playtest).\n- `navigate`: Walk the player character to a position using PathfindingService (requires client playtest).\n- `mouse_click`: Simulate a mouse click at screen coordinates.\n- `mouse_move`: Move the virtual mouse to screen coordinates.\n- `key_press`: Press and release a key.\n- `key_down`: Hold a key down.\n- `key_up`: Release a held key.",
+      description: "Control Roblox Studio playtesting and simulate user input.\n\nActions:\n- `start`: Begin a playtest session. Defaults to Play mode (F5, full client with player character). Set mode='run' for Run mode (F8, server-only, no player).\n- `stop`: End the current playtest.\n- `execute`: Run Lua code in the running game context.\n- `get_output`: Get console/log output from Studio (works in edit mode and during playtest).\n- `inspect`: Evaluate a Luau expression and return the typed result (requires active playtest).\n- `navigate`: Walk the player character to a position using PathfindingService (requires client playtest).\n- `mouse_click`: Simulate a mouse click at screen coordinates.\n- `mouse_move`: Move the virtual mouse to screen coordinates.\n- `key_press`: Press and release a key.\n- `key_down`: Hold a key down.\n- `key_up`: Release a held key.",
       inputSchema: z4.object({
         action: z4.enum(["start", "stop", "execute", "get_output", "inspect", "navigate", "mouse_click", "mouse_move", "key_press", "key_down", "key_up"]).describe("Playtest action"),
+        mode: z4.enum(["play", "run"]).default("play").describe("Playtest mode: 'play' (F5, full client with player) or 'run' (F8, server-only). Default: play"),
         code: z4.string().optional().describe("Lua code to execute (for 'execute' action)"),
         // get_output params
         messageTypes: z4.array(z4.string()).optional().describe("Filter by message types: 'MessageOutput', 'MessageWarning', 'MessageError', 'MessageInfo' (for 'get_output')"),
@@ -1193,9 +1361,10 @@ function register4(server, bridge) {
     },
     async (params) => {
       if (params.action === "get_output") {
+        const since = params.since ?? playtestStartedAt ?? void 0;
         const result2 = await bridge.send("get_log_output", {
           messageTypes: params.messageTypes,
-          since: params.since,
+          since,
           limit: params.limit
         });
         if (result2.logs.length === 0) {
@@ -1245,6 +1414,18 @@ ${result2.message}` : ""}`;
         return { content: [{ type: "text", text: text2 }] };
       }
       if (params.action === "mouse_click" || params.action === "mouse_move" || params.action === "key_press" || params.action === "key_down" || params.action === "key_up") {
+        if ((params.action === "mouse_click" || params.action === "mouse_move") && (params.x === void 0 || params.y === void 0)) {
+          return {
+            content: [{ type: "text", text: `${params.action} requires \`x\` and \`y\` parameters.` }],
+            isError: true
+          };
+        }
+        if ((params.action === "key_press" || params.action === "key_down" || params.action === "key_up") && !params.key) {
+          return {
+            content: [{ type: "text", text: `${params.action} requires a \`key\` parameter.` }],
+            isError: true
+          };
+        }
         const result2 = await bridge.send("virtual_input", {
           action: params.action,
           x: params.x,
@@ -1258,10 +1439,22 @@ ${result2.message}` : ""}`;
           ]
         };
       }
+      if (params.action === "execute" && !params.code) {
+        return {
+          content: [{ type: "text", text: "execute action requires a `code` parameter." }],
+          isError: true
+        };
+      }
       const result = await bridge.send("playtest", {
         action: params.action,
-        code: params.code
+        code: params.code,
+        mode: params.mode
       });
+      if (params.action === "start" && result.status === "started") {
+        playtestStartedAt = Date.now() / 1e3;
+      } else if (params.action === "stop" && result.status === "stopped") {
+        playtestStartedAt = null;
+      }
       let text;
       if (params.action === "execute") {
         const lines = [];
@@ -1281,7 +1474,10 @@ ${outputText}
         text = lines.length > 0 ? lines.join("\n\n") : `Execution completed (${result.status})`;
         text = applyTokenBudget(text, void 0);
       } else {
-        text = `Playtest ${params.action}: ${result.status}`;
+        const modeInfo = result.mode ? ` (${result.mode} mode)` : "";
+        const extra = result.message ? `
+${result.message}` : "";
+        text = `Playtest ${params.action}${modeInfo}: ${result.status}${extra}`;
       }
       return { content: [{ type: "text", text }] };
     }
@@ -1343,6 +1539,14 @@ function register5(server, bridge) {
         const text2 = `Updated ${result2.modified?.length ?? 0} setting(s): ${result2.modified?.join(", ") ?? "none"}`;
         return { content: [{ type: "text", text: text2 }] };
       }
+      if (params.action === "terrain_fill") {
+        if (!params.region) {
+          return { content: [{ type: "text", text: "terrain_fill requires a `region` parameter." }], isError: true };
+        }
+        if (!params.material) {
+          return { content: [{ type: "text", text: "terrain_fill requires a `material` parameter." }], isError: true };
+        }
+      }
       const terrainAction = params.action.replace("terrain_", "");
       const result = await bridge.send("terrain", {
         action: terrainAction,
@@ -1666,6 +1870,10 @@ function formatSearchResults(results) {
 
 // src/tools/utility.ts
 function register7(server, bridge) {
+  const transactionState = /* @__PURE__ */ new Map();
+  bridge.on("studio-disconnected", (info) => {
+    transactionState.delete(info.studioId);
+  });
   server.registerTool(
     "undo_redo",
     {
@@ -1754,7 +1962,7 @@ function register7(server, bridge) {
     "transaction",
     {
       title: "Transaction Control",
-      description: "Group multiple mutating tool calls into a single Ctrl+Z undo point.\n\nActions:\n- `begin`: Start a transaction. All subsequent writes share one undo recording.\n- `commit`: Finish the transaction and commit all changes as one undo point.\n- `rollback`: Cancel the transaction and undo all changes made since begin.\n\nTransactions auto-rollback after 60 seconds if not committed.",
+      description: "Group multiple mutating tool calls into a single Ctrl+Z undo point.\n\nUsage: ALWAYS call `begin` first, then make your changes, then call `commit` or `rollback`. Calling `commit` or `rollback` without a prior `begin` will error.\n\nActions:\n- `begin`: Start a transaction. All subsequent writes share one undo recording.\n- `commit`: Finish an open transaction and commit all changes as one undo point. Requires a prior `begin`.\n- `rollback`: Cancel an open transaction and undo all changes made since begin. Requires a prior `begin`.\n\nTransactions auto-rollback after 60 seconds if not committed.",
       inputSchema: z7.object({
         action: z7.enum(["begin", "commit", "rollback"]).describe("Transaction action"),
         name: z7.string().optional().describe("Transaction name for the undo history (for 'begin' action)")
@@ -1767,31 +1975,53 @@ function register7(server, bridge) {
       }
     },
     async (params) => {
+      const studioId = bridge.getActiveStudioId() ?? "_default";
       if (params.action === "begin") {
-        const result2 = await bridge.send("begin_transaction", {
-          name: params.name
-        });
+        try {
+          const result = await bridge.send("begin_transaction", {
+            name: params.name
+          });
+          transactionState.set(studioId, true);
+          return {
+            content: [
+              { type: "text", text: `Transaction started: **${result.transactionId}**
+All subsequent writes will be grouped into one undo point. Call commit or rollback to finish.` }
+            ]
+          };
+        } catch (err) {
+          transactionState.set(studioId, false);
+          throw err;
+        }
+      }
+      if (!transactionState.get(studioId)) {
         return {
           content: [
-            { type: "text", text: `Transaction started: **${result2.transactionId}**
-All subsequent writes will be grouped into one undo point. Call commit or rollback to finish.` }
+            { type: "text", text: `No active transaction. Call \`begin\` first before calling \`${params.action}\`.` }
           ]
         };
       }
       if (params.action === "commit") {
-        const result2 = await bridge.send("commit_transaction", {});
+        try {
+          const result = await bridge.send("commit_transaction", {});
+          return {
+            content: [
+              { type: "text", text: `Transaction ${result.status}. All changes are now a single undo point.` }
+            ]
+          };
+        } finally {
+          transactionState.set(studioId, false);
+        }
+      }
+      try {
+        const result = await bridge.send("rollback_transaction", {});
         return {
           content: [
-            { type: "text", text: `Transaction ${result2.status}. All changes are now a single undo point.` }
+            { type: "text", text: `Transaction ${result.status}. All changes since begin have been reverted.` }
           ]
         };
+      } finally {
+        transactionState.set(studioId, false);
       }
-      const result = await bridge.send("rollback_transaction", {});
-      return {
-        content: [
-          { type: "text", text: `Transaction ${result.status}. All changes since begin have been reverted.` }
-        ]
-      };
     }
   );
 }
@@ -1853,7 +2083,15 @@ ${lines.join("\n")}`;
       }
     },
     async (params) => {
-      bridge.setActiveStudio(params.studioId);
+      try {
+        bridge.setActiveStudio(params.studioId);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        return {
+          content: [{ type: "text", text: message }],
+          isError: true
+        };
+      }
       const studios = bridge.getStudios();
       const studio = studios.find((s) => s.studioId === params.studioId);
       const name = studio?.placeName ?? "unknown";
@@ -1883,7 +2121,13 @@ function ensureDir() {
     mkdirSync(BUILDS_DIR, { recursive: true });
   }
 }
+function validateBuildName(name) {
+  if (!/^[\w-]+$/.test(name)) {
+    throw new Error(`Invalid build name "${name}". Names must match /^[\\w-]+$/.`);
+  }
+}
 function saveBuild(name, root, description) {
+  validateBuildName(name);
   ensureDir();
   const rootObj = root;
   const data = {
@@ -1903,6 +2147,7 @@ function saveBuild(name, root, description) {
   };
 }
 function loadBuild(name) {
+  validateBuildName(name);
   const filePath = join(BUILDS_DIR, `${name}.json`);
   if (!existsSync(filePath)) {
     throw new Error(`Build "${name}" not found. Use builds --action list to see available builds.`);
@@ -2027,7 +2272,7 @@ function register9(server, bridge) {
 }
 
 // src/tools/index.ts
-function registerAllTools(server, bridge, options = {}) {
+async function registerAllTools(server, bridge, options = {}) {
   const mode = options.mode ?? "full";
   register8(server, bridge);
   register(server, bridge);
@@ -2044,10 +2289,20 @@ function registerAllTools(server, bridge, options = {}) {
     registerReadOnly2(server, bridge);
   }
   if (options.withCloud) {
-    import("./cloud-HQIBAMRL.js").then((mod) => mod.register(server));
+    try {
+      const mod = await import("./cloud-4AYJVND6.js");
+      mod.register(server);
+    } catch (err) {
+      log.error("Failed to load cloud module:", err);
+    }
   }
   if (options.withRojo) {
-    import("./rojo-TXV4K4PB.js").then((mod) => mod.register(server));
+    try {
+      const mod = await import("./rojo-2CMKPTPS.js");
+      mod.register(server);
+    } catch (err) {
+      log.error("Failed to load rojo module:", err);
+    }
   }
 }
 
@@ -2088,7 +2343,7 @@ async function startServer(port = 3200, options = {}) {
     withCloud: options.withCloud,
     withRojo: options.withRojo
   };
-  registerAllTools(server, bridge, toolOptions);
+  await registerAllTools(server, bridge, toolOptions);
   bridge.on("studio-connected", (info) => {
     log.info(
       `Roblox Studio connected: ${info.studioId}` + (info.placeName ? ` (${info.placeName})` : "")
@@ -2104,12 +2359,16 @@ async function startServer(port = 3200, options = {}) {
   const transport = new StdioServerTransport();
   await server.connect(transport);
   log.info("MCP server connected via stdio");
+  let shuttingDown = false;
   const shutdown = async () => {
+    if (shuttingDown) return;
+    shuttingDown = true;
     log.info("Shutting down...");
     await bridge.stop();
     await server.close();
     process.exit(0);
   };
+  bridge.on("shutdown", shutdown);
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);
 }
@@ -2117,4 +2376,4 @@ async function startServer(port = 3200, options = {}) {
 export {
   startServer
 };
-//# sourceMappingURL=chunk-JDWBW44K.js.map
+//# sourceMappingURL=chunk-HI6KFLGA.js.map