@el4cteo/rbx-studio-mcp 0.7.5 → 0.7.7

package/scripts/test-bridge.mjs

@@ -297,7 +297,7 @@ function twoStudios() {
       probe.close(() => resolve(free));
     });
   });
-  const server = await startBridgeServer({ port });
+  const server = await startBridgeServer({ port, bridge: new Bridge({ reconnectGraceMs: 100 }) });
   const open = () =>
     new Promise((resolve) => {
       const req = request(
@@ -312,7 +312,7 @@ function twoStudios() {
   const count = async () =>
     (await (await fetch(`http://127.0.0.1:${port}/sessions`, { headers: { "x-roblox-studio-mcp": "test" } })).json())
       .list.length;
-  const settle = () => new Promise((resolve) => setTimeout(resolve, 150));
+  const settle = () => new Promise((resolve) => setTimeout(resolve, 250));
 
   const first = await open();
   const second = await open();
@@ -321,7 +321,48 @@ function twoStudios() {
   assert.equal(await count(), 1, "the old stream closing leaves the new session alone");
   second.destroy();
   await settle();
-  assert.equal(await count(), 0, "a stream that dies without a goodbye is dropped");
+  assert.equal(await count(), 0, "a stream that dies without a goodbye is dropped after the grace");
+
+  // A stream that closes and redials inside the grace keeps its session, its
+  // agent's chosen target, and a call issued during the gap.
+  {
+    const before = await open();
+    await server.bridge.setActive("crashy");
+    before.destroy();
+    await new Promise((resolve) => setTimeout(resolve, 20));
+    const during = server.bridge.call("studio.ping", {}, { timeoutMs: 2_000 });
+    const events = [];
+    const after = await new Promise((resolve) => {
+      const req = request(
+        { host: "127.0.0.1", port, path: "/events", method: "POST", headers: { "x-roblox-studio-mcp": "test" } },
+        (res) => {
+          res.setEncoding("utf8");
+          res.on("data", (chunk) => {
+            for (const block of chunk.split("\n\n")) {
+              if (!block.startsWith("data: ")) continue;
+              const frame = JSON.parse(block.slice(6));
+              if (typeof frame.id !== "string") continue;
+              events.push(frame);
+              void fetch(`http://127.0.0.1:${port}/result?studioId=crashy`, {
+                method: "POST",
+                headers: { "x-roblox-studio-mcp": "test" },
+                body: JSON.stringify({ id: frame.id, ok: true, data: "pong" }),
+              });
+            }
+          });
+          resolve(req);
+        },
+      );
+      req.end(JSON.stringify({ studioId: "crashy", placeName: "p", placeId: 1 }));
+    });
+    assert.equal(await during, "pong", "a call made while redialling is delivered on the new stream");
+    assert.equal(events.length, 1);
+    await settle();
+    const view = await server.bridge.sessions();
+    assert.equal(view.list.length, 1, "the redialled session is still listed after the grace");
+    assert.equal(view.activeIsChosen, true, "and the agent's chosen target survived");
+    after.destroy();
+  }
 
   // A command far bigger than one socket read goes down the stream as ONE
   // event, and its answer comes back. The plugin half of this -- joining the
@@ -365,4 +406,78 @@ function twoStudios() {
   await server.close();
 }
 
+// Normalize deadlines at the owner, even when the caller isn't input or a current peer.
+{
+ const { normalizeTimeoutMs } = await import("../dist/lib/timeout.js");
+ assert.equal(normalizeTimeoutMs(78394.99999999999), 78395);
+ assert.equal(normalizeTimeoutMs(91613.1, 10000), 101614);
+ assert.equal(normalizeTimeoutMs(0.05), 1);
+ assert.equal(normalizeTimeoutMs(2 ** 31 - 1), 2 ** 31 - 1);
+ assert.throws(() => normalizeTimeoutMs(2 ** 31 - 1, 10000), {code:"BAD_TIMEOUT"});
+ const bridge = new Bridge();
+ bridge.attach(identity("timeout-test", 1), null);
+ const originalTimer = globalThis.setTimeout;
+ const delays = [];
+ try {
+  globalThis.setTimeout = (callback, delay, ...args) => {
+   delays.push(delay);
+   return originalTimer(callback, delay, ...args);
+  };
+  for (const timeoutMs of [78394.99999999999, 91613.1, 95762.99999999994, 15000, undefined]) {
+   const result = bridge.call("studio.ping", {}, {clientId:"test",studioId:"timeout-test",timeoutMs});
+   assert.equal(delays.at(-1), Math.ceil(timeoutMs ?? 15000));
+   const command = await bridge.waitForCommand("timeout-test");
+   bridge.settle("timeout-test", {id:command.id,ok:true,data:"ok"});
+   assert.equal(await result, "ok");
+  }
+  const before = delays.length;
+  for (const timeoutMs of [NaN, Infinity, -Infinity, -1, 0, null, "1000", {}, 2 ** 31, Number.MAX_SAFE_INTEGER]) {
+   assert.throws(() => bridge.call("studio.ping", {}, {clientId:"test",timeoutMs}), {code:"BAD_TIMEOUT"});
+  }
+  assert.equal(delays.length, before, "invalid deadlines never create timers");
+  assert.equal(bridge.sessions.get("timeout-test").pending.size, 0);
+  assert.equal(bridge.sessions.get("timeout-test").queue.length, 0);
+ } finally {
+  globalThis.setTimeout = originalTimer;
+  bridge.detach("timeout-test");
+ }
+}
+
+// A poll whose socket closed while parked must not swallow the next command.
+{
+  const bridge = new Bridge();
+  bridge.attach(identity("poll-drop", 1), null);
+  const released = new AbortController();
+  const parked = bridge.waitForCommand("poll-drop", released.signal);
+  released.abort();
+  assert.equal(await parked, null, "an abandoned poll resolves empty");
+  assert.equal(bridge.sessions.get("poll-drop").waiter, null, "and leaves no waiter behind");
+
+  const result = bridge.call("studio.ping", {}, { clientId: "test", studioId: "poll-drop" });
+  assert.equal(bridge.sessions.get("poll-drop").queue.length, 1, "the command waits in the queue");
+
+  // One handed to a poll that died anyway goes back to the front.
+  const command = await bridge.waitForCommand("poll-drop");
+  bridge.requeue("poll-drop", command);
+  const again = await bridge.waitForCommand("poll-drop");
+  assert.equal(again.id, command.id, "the requeued command is picked up next");
+  bridge.settle("poll-drop", { id: again.id, ok: true, data: "pong" });
+  assert.equal(await result, "pong");
+
+  // Nothing is requeued for a call that already settled.
+  bridge.requeue("poll-drop", command);
+  assert.equal(bridge.sessions.get("poll-drop").queue.length, 0, "settled calls are not resent");
+  bridge.detach("poll-drop");
+}
+
+// A resolved published name survives the plugin reconnecting.
+{
+  const bridge = new Bridge();
+  bridge.attach(identity("named", 1), null);
+  bridge.notePlaceName("named", "My Game");
+  bridge.attach({ ...identity("named", 1), placeName: "Place3" }, null);
+  assert.equal(bridge.list()[0].placeName, "My Game", "reconnect keeps the published name");
+  bridge.detach("named");
+}
+
 process.stdout.write("bridge: ok\n");

package/scripts/test-failover.mjs

@@ -239,4 +239,73 @@ function handshake(port, studioId) {
   await new Promise((resolve) => halfDead.close(resolve));
 }
 
+// Issue #4: the real input tool crosses peer -> owner -> fake Studio over HTTP.
+{
+ const { z } = await import("zod");
+ const { registerInputTools } = await import("../dist/tools/input.js");
+ const owner = await startBridgeServer({port:PORT});
+ const peer = await startBridgeServer({port:PORT});
+ const headers = {[CLIENT_HEADER]:"test", "Content-Type":"application/json"};
+ const originalSignal = AbortSignal.timeout;
+ const signalDelays = [];
+ const base = `http://127.0.0.1:${PORT}`;
+ const reply = async () => {
+  const response = await fetch(`${base}/poll?studioId=decimal`, {headers,signal:originalSignal(5000)});
+  const {command} = await response.json();
+  assert.ok(command, "the command reaches Studio");
+  await fetch(`${base}/result?studioId=decimal`, {method:"POST",headers,
+   body:JSON.stringify({id:command.id,ok:true,data:{delivered:true,steps:command.params.steps?.length ?? 0,player:"Test"}})});
+  return command;
+ };
+ try {
+  await handshake(PORT,"decimal");
+  assert.equal(peer.owner,false);
+  AbortSignal.timeout = delay => { signalDelays.push(delay); return originalSignal(delay); };
+  let tool;
+  registerInputTools({bridge:peer.bridge,server:{registerTool(name,spec,handler) {tool={spec,handler};}}});
+  const steps = [{kind:"key",key:"E",hold:0.1,after:4.1}, ...Array.from({length:24}, () => ({kind:"key",key:"Left",hold:0.05,after:1.065}))];
+  const [result, command] = await Promise.all([
+   tool.handler(z.object(tool.spec.inputSchema).parse({steps,studioId:"decimal"})), reply(),
+  ]);
+  assert.ok(!result.isError, JSON.stringify(result));
+  assert.deepEqual(command.params.steps,steps);
+  assert.ok(signalDelays.includes(88460), "input budget plus existing 10s peer padding");
+
+  const [other] = await Promise.all([
+   peer.bridge.call("another.tool", {}, {studioId:"decimal",timeoutMs:91613.1}), reply(),
+  ]);
+  assert.ok(other.delivered);
+  assert.ok(signalDelays.includes(101614), "other tools are normalized at the peer boundary");
+
+  // Older/non-normalizing peers may send decimals directly to the owner.
+  const [raw] = await Promise.all([
+   fetch(`${base}/call`, {method:"POST",headers,body:JSON.stringify({op:"another.tool",studioId:"decimal",timeoutMs:95762.99999999994})}).then(res => res.json()), reply(),
+  ]);
+  assert.equal(raw.ok,true);
+  for (const timeoutMs of [null, "1000", 0, -1, 2 ** 31]) {
+   const response = await fetch(`${base}/call`, {method:"POST",headers,body:JSON.stringify({op:"studio.ping",studioId:"decimal",timeoutMs})});
+   const error = await response.json();
+   assert.equal(error.error.code,"BAD_TIMEOUT", "owner rejects invalid wire values without crashing");
+  }
+  for (const timeoutMs of [NaN, Infinity, -1, 0, 2 ** 31 - 1]) {
+   await assert.rejects(() => peer.bridge.call("studio.ping", {}, {studioId:"decimal",timeoutMs}), {code:"BAD_TIMEOUT"});
+  }
+  // A locally thrown AbortSignal error must not trigger failover or blame the owner.
+  const localError = new RangeError("local AbortSignal setup failure");
+  AbortSignal.timeout = delay => { if (delay === 10001) throw localError; return originalSignal(delay); };
+  await assert.rejects(() => peer.bridge.call("studio.ping", {}, {studioId:"decimal",timeoutMs:1}), cause => cause === localError);
+  AbortSignal.timeout = originalSignal;
+  const [healthy] = await Promise.all([
+   peer.bridge.call("studio.ping", {}, {studioId:"decimal",timeoutMs:1000}), reply(),
+  ]);
+  assert.ok(healthy.delivered, "owner still answers after every rejected call");
+  assert.equal(owner.owner,true);
+  assert.equal(peer.owner,false);
+ } finally {
+  AbortSignal.timeout = originalSignal;
+  await peer.close();
+  await owner.close();
+ }
+}
+
 process.stdout.write("failover: ok\n");

package/scripts/test-tools.mjs

@@ -67,6 +67,17 @@ for (const step of [{kind:"click",target:"PlayerGui.HUD.BuyButton"},{kind:"text"
  await input.handler(z.object(input.spec.inputSchema).parse({steps:[step]}));
  assert.deepEqual(calls.at(-1).params.steps[0], step);
 }
+// Issue #4: ordinary decimal holds/waits retain padding and yield whole milliseconds.
+for (const steps of [
+ [{kind:"key",key:"E",hold:0.1,after:4.1}, ...Array.from({length:24}, () => ({kind:"key",key:"Left",hold:0.05,after:1.065}))],
+ [{kind:"key",key:"E",hold:0.05,after:1.0651}],
+]) {
+ await input.handler(z.object(input.spec.inputSchema).parse({steps}));
+ const raw = (35 + steps.reduce((sum, step) => sum + step.hold + step.after + 0.5, 0)) * 1000;
+ assert.equal(calls.at(-1).options.timeoutMs, Math.ceil(raw));
+ assert.ok(Number.isInteger(calls.at(-1).options.timeoutMs));
+ assert.deepEqual(calls.at(-1).params.steps, steps, "step timing itself is unchanged");
+}
 assert.deepEqual([...registered.keys()].sort(), ["execute_luau", "input", "viewport"]);
 process.stdout.write("client tool schemas: ok\n");