@irtio/mcp 0.6.0

package/dist/chunk-VFNFDDNZ.js

@@ -0,0 +1,1122 @@
+// src/auth.ts
+import { createApiClientWithToken } from "@irtio/cli/api";
+import { readCredential, resolveControlUrlForUser } from "@irtio/cli/credentials";
+async function resolveAuth(env = process.env, controlUrlFlag) {
+  const controlUrl = await resolveControlUrlForUser(controlUrlFlag);
+  const credential = await readCredential(controlUrl);
+  if (credential) {
+    const expiresAt = new Date(credential.expiresAt).getTime();
+    if (Number.isFinite(expiresAt) && expiresAt <= Date.now()) {
+      return { ok: false, controlUrl, reason: "expired" };
+    }
+    return {
+      ok: true,
+      controlUrl,
+      token: credential.token,
+      source: "credential-file",
+      email: credential.email
+    };
+  }
+  const envToken = env.IRTIO_TOKEN;
+  if (envToken !== void 0 && envToken.length > 0) {
+    return { ok: true, controlUrl, token: envToken, source: "env", email: void 0 };
+  }
+  return { ok: false, controlUrl, reason: "no-credential" };
+}
+var NoCredentialError = class extends Error {
+  constructor(controlUrl, reason) {
+    super(
+      reason === "expired" ? `the stored login for ${controlUrl} has expired` : `no stored login for ${controlUrl}`
+    );
+    this.controlUrl = controlUrl;
+    this.reason = reason;
+  }
+  controlUrl;
+  reason;
+  name = "NoCredentialError";
+};
+async function requireClient(env = process.env, controlUrlFlag) {
+  const auth = await resolveAuth(env, controlUrlFlag);
+  if (!auth.ok) throw new NoCredentialError(auth.controlUrl, auth.reason);
+  return { client: createApiClientWithToken(auth.controlUrl, auth.token), auth };
+}
+
+// src/narrate.ts
+import { ApiClientError, NotLoggedInError } from "@irtio/cli/api";
+import { DeployRefusedError } from "@irtio/cli/deploy";
+import { RunNotPerformedError, ScenarioNotRunError } from "@irtio/cli/simulate";
+function narrate(n) {
+  const text = `${n.summary}
+
+${JSON.stringify(n.data, null, 2)}
+
+next: ${n.next}`;
+  return { content: [{ type: "text", text }], structuredContent: n.data };
+}
+var LOGIN_NARRATION = "You are not signed in to the irtio control plane, so this tool could not run. Run `irtio login` in a terminal. It opens a browser once and writes a credential that this server reads on the next call. No token belongs in this server's config file.";
+function narrateBreaking(changes, hint) {
+  const messages = changes.map(
+    (c) => typeof c === "object" && c !== null && "message" in c ? String(c.message) : void 0
+  ).filter((m) => m !== void 0);
+  const detail = messages.length > 0 ? ` ${messages.join("; ")}.` : "";
+  return narrate({
+    summary: `The deploy was refused: the schema change is breaking, so nothing was deployed.${detail} A breaking change needs a migration, because rooms holding live state cannot be read under the new schema without one.`,
+    data: {
+      error: "E_BREAKING_SCHEMA",
+      breaking: messages.length,
+      changes,
+      ...hint !== void 0 ? { hint } : {}
+    },
+    next: hint ?? "Write a migration, then deploy again with allowBreaking set."
+  });
+}
+function narrateError(err, toolName) {
+  const expired = err instanceof NoCredentialError && err.reason === "expired";
+  if (err instanceof NoCredentialError || err instanceof NotLoggedInError || err instanceof ApiClientError && err.status === 401) {
+    const summary = expired ? "Your irtio login has expired, so this tool could not run. Run `irtio login` in a terminal to sign in again. The server picks the new credential up on the next call." : LOGIN_NARRATION;
+    return {
+      ...narrate({
+        summary,
+        data: {
+          error: expired ? "login_expired" : "not_signed_in",
+          tool: toolName,
+          ...err instanceof NoCredentialError ? { controlUrl: err.controlUrl } : {}
+        },
+        next: "Run `irtio login`, then call this tool again."
+      }),
+      isError: true
+    };
+  }
+  if (err instanceof DeployRefusedError) {
+    return { ...narrateBreaking(err.changes, err.hint), isError: true };
+  }
+  if (err instanceof ScenarioNotRunError || err instanceof RunNotPerformedError) {
+    return {
+      ...narrate({
+        summary: `The scenario did not run, so nothing was measured and this says nothing about the room. ${err.message}`,
+        data: { error: "scenario_not_run", tool: toolName, message: err.message },
+        next: "Start the room with `irtio dev` if it is not running, fix the path or the scenario file the message names, then call this tool again."
+      }),
+      isError: true
+    };
+  }
+  if (err instanceof ApiClientError) {
+    if (err.status === 409 && err.code === "E_BREAKING_SCHEMA") {
+      return { ...narrateBreaking(err.changes ?? [], err.hint), isError: true };
+    }
+    if (err.status === 404) {
+      return {
+        ...narrate({
+          summary: `Not found in your organisation: ${err.message}. The control plane answers the same way for a project that does not exist and one that belongs to somebody else, so check the project id.`,
+          data: { error: err.code, status: err.status, message: err.message },
+          next: "Call `project_list` to see the projects this account can reach."
+        }),
+        isError: true
+      };
+    }
+    return {
+      ...narrate({
+        summary: `The control plane refused the request: ${err.message}.`,
+        data: {
+          error: err.code,
+          status: err.status,
+          message: err.message,
+          ...err.hint !== void 0 ? { hint: err.hint } : {}
+        },
+        next: err.hint ?? "Fix the request and call the tool again."
+      }),
+      isError: true
+    };
+  }
+  const message = err instanceof Error ? err.message : String(err);
+  return {
+    ...narrate({
+      summary: `\`${toolName}\` failed before it reached the control plane: ${message}.`,
+      data: { error: "local_failure", tool: toolName, message },
+      next: "Check the message above. If it names a file or a path, that is the thing to fix."
+    }),
+    isError: true
+  };
+}
+function plural(count, one, many = `${one}s`) {
+  return `${count} ${count === 1 ? one : many}`;
+}
+
+// src/tools.ts
+import { NotLoggedInError as NotLoggedInError2 } from "@irtio/cli/api";
+import { runDeploy } from "@irtio/cli/deploy";
+import { runSimulation } from "@irtio/cli/simulate";
+function api(ctx) {
+  if (ctx.client === void 0) throw new NotLoggedInError2(ctx.controlUrl);
+  return ctx.client;
+}
+function str(args, key) {
+  const value = args[key];
+  if (typeof value !== "string" || value.length === 0) {
+    throw new Error(`\`${key}\` is required and must be a non-empty string`);
+  }
+  return value;
+}
+function optStr(args, key) {
+  const value = args[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "string") throw new Error(`\`${key}\` must be a string`);
+  return value;
+}
+function optInt(args, key) {
+  const value = args[key];
+  if (value === void 0 || value === null) return void 0;
+  if (typeof value !== "number" || !Number.isInteger(value)) {
+    throw new Error(`\`${key}\` must be a whole number`);
+  }
+  return value;
+}
+var PROJECT_ARG = {
+  type: "string",
+  description: "The project id, like p_0123456789abcdef. Call project_list if you do not have it."
+};
+function projectSchema(extra = {}, required = []) {
+  return {
+    type: "object",
+    properties: { project: PROJECT_ARG, ...extra },
+    required: ["project", ...required],
+    additionalProperties: false
+  };
+}
+var whoami = {
+  name: "whoami",
+  description: "Read the signed-in account and the control plane it is signed in to. Read-only and cheap. Call this first when you are not sure whether a credential exists, because every other tool needs one.",
+  inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  async run(ctx) {
+    const me = await api(ctx).get("/v1/me");
+    return {
+      summary: `Signed in to ${ctx.controlUrl} as ${me.email}.`,
+      data: { id: me.id, orgId: me.orgId, email: me.email, controlUrl: me.controlUrl },
+      next: "Call `project_list` to see what this account can reach."
+    };
+  }
+};
+var projectList = {
+  name: "project_list",
+  description: "List every project in your organisation. Read-only and cheap. Returns ids, names and regions, which is where you get the project id every other tool needs.",
+  inputSchema: { type: "object", properties: {}, additionalProperties: false },
+  async run(ctx) {
+    const rows = await api(ctx).get("/v1/projects");
+    if (rows.length === 0) {
+      return {
+        summary: "This organisation has no projects yet.",
+        data: { projects: [], count: 0 },
+        next: "Call `project_create` with a name to make one."
+      };
+    }
+    const names = rows.map((r) => `${r.name} (${r.id}, ${r.region})`).join(", ");
+    return {
+      summary: `${plural(rows.length, "project")}: ${names}.`,
+      data: { count: rows.length, projects: rows },
+      next: "Call `project_get` with one of these ids for its settings and origins."
+    };
+  }
+};
+var projectGet = {
+  name: "project_get",
+  description: 'Read one project: its name, region, project key, per-IP connection limit, tenant VM size and allowed origins. Read-only and cheap. The project id IS the public project key a game client joins with, so this is the tool that answers "what key does my client use".',
+  inputSchema: projectSchema(),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const project = await api(ctx).get(`/v1/projects/${id}`);
+    const origins = await api(ctx).get(`/v1/projects/${id}/origins`);
+    const limit = project.connectionsPerIpPerMin === null ? "the tenant default" : `${project.connectionsPerIpPerMin} per minute`;
+    const vmMem = project.vmMemMib === null ? "sized automatically" : `${project.vmMemMib} MiB`;
+    const shards = typeof project.shards === "number" ? project.shards : 1;
+    const machines = shards === 1 ? "one machine" : `${shards} machines (sharded)`;
+    const originList2 = origins.length === 0 ? "No browser origins are allowed yet, so a hosted page cannot connect." : `Allowed origins: ${origins.map((o) => o.origin).join(", ")}.`;
+    return {
+      summary: `${project.name} (${project.id}) in ${project.region}, running as ${machines}. Per-IP connection limit: ${limit}. Tenant VM: ${vmMem}. ${originList2} The project key your client joins with is ${project.id}.`,
+      data: {
+        project: {
+          id: project.id,
+          name: project.name,
+          region: project.region,
+          createdAt: project.createdAt,
+          connectionsPerIpPerMin: project.connectionsPerIpPerMin,
+          vmMemMib: project.vmMemMib,
+          shards
+        },
+        projectKey: project.id,
+        origins: origins.map((o) => o.origin)
+      },
+      next: origins.length === 0 ? "Call `origin_add` with the site that will host your client, or `deploy` to ship a room." : "Call `rooms` to see what is running, or `deploy` to ship a new version."
+    };
+  }
+};
+var originList = {
+  name: "origin_list",
+  description: "List the browser origins allowed to open a socket to this project. Read-only and cheap. An empty list means no hosted page can connect, which is the usual cause of a client that works locally and fails once deployed.",
+  inputSchema: projectSchema(),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const rows = await api(ctx).get(`/v1/projects/${id}/origins`);
+    return {
+      summary: rows.length === 0 ? `${id} allows no browser origins, so a hosted page cannot connect to it.` : `${id} allows ${plural(rows.length, "origin")}: ${rows.map((o) => o.origin).join(", ")}.`,
+      data: { project: id, count: rows.length, origins: rows.map((o) => o.origin) },
+      next: rows.length === 0 ? "Call `origin_add` with the origin that serves your client, like https://example.com." : "Call `origin_add` to allow another, or `origin_remove` to withdraw one."
+    };
+  }
+};
+var rooms = {
+  name: "rooms",
+  description: "List the rooms the control plane knows about for a project, with their status and when each was last seen. Read-only and cheap. A room appears here once it has been joined at least once, so an empty list on a fresh deploy is normal.",
+  inputSchema: projectSchema(),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const rows = await api(ctx).get(`/v1/projects/${id}/rooms`);
+    if (rows.length === 0) {
+      return {
+        summary: `${id} has no rooms on record. Nothing has joined one yet.`,
+        data: { project: id, count: 0, rooms: [] },
+        next: "Join a room from your client, or run `irtio simulate` to drive one, then call `rooms` again."
+      };
+    }
+    const byStatus = /* @__PURE__ */ new Map();
+    for (const r of rows) byStatus.set(r.status, (byStatus.get(r.status) ?? 0) + 1);
+    const breakdown = [...byStatus].map(([s, n]) => `${n} ${s}`).join(", ");
+    return {
+      summary: `${plural(rows.length, "room")} in ${id}: ${breakdown}.`,
+      data: { project: id, count: rows.length, rooms: rows },
+      next: "Call `logs` with a `room` filter for one room, or `save_list` to see its save generations."
+    };
+  }
+};
+var logs = {
+  name: "logs",
+  description: "Read a project's log lines, oldest first. Read-only and cheap. Pass `since` with the `at` of the last line you read to page forward, and `room` to filter to one room. The room id `__tenant` is the tenant process itself rather than any single room, which is where startup and placement failures show up.",
+  inputSchema: projectSchema({
+    since: {
+      type: "string",
+      description: "Cursor: the `at` timestamp of the last line you already read."
+    },
+    room: {
+      type: "string",
+      description: "Filter to one room id, or `__tenant` for the tenant process itself."
+    },
+    limit: { type: "number", description: "How many lines, 1 to 1000. Defaults to 100." }
+  }),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const since = optStr(args, "since");
+    const room = optStr(args, "room");
+    const limit = optInt(args, "limit");
+    const rows = await api(ctx).get(`/v1/projects/${id}/logs`, {
+      ...since !== void 0 ? { since } : {},
+      ...room !== void 0 ? { room } : {},
+      ...limit !== void 0 ? { limit: String(limit) } : {}
+    });
+    const scope = room !== void 0 ? ` for room ${room}` : "";
+    if (rows.length === 0) {
+      return {
+        summary: `No log lines${scope}${since !== void 0 ? " after that cursor" : ""}.`,
+        data: { project: id, count: 0, entries: [], ...since !== void 0 ? { since } : {} },
+        next: "Nothing new. Call `logs` again with the same `since` after the room has done something."
+      };
+    }
+    const errors = rows.filter((r) => r.level === "error").length;
+    const warnings = rows.filter((r) => r.level === "warn").length;
+    const cursor = rows[rows.length - 1]?.at;
+    const health = errors > 0 ? ` ${plural(errors, "line")} at error level.` : warnings > 0 ? ` ${plural(warnings, "line")} at warn level, none at error.` : " Nothing at warn or error level.";
+    return {
+      summary: `${plural(rows.length, "log line")}${scope}, oldest first.${health}`,
+      data: {
+        project: id,
+        count: rows.length,
+        errors,
+        warnings,
+        entries: rows,
+        ...cursor !== void 0 ? { nextSince: cursor } : {}
+      },
+      next: cursor !== void 0 ? `Call \`logs\` again with since="${cursor}" to read what comes after this.` : "Call `logs` again to poll for more."
+    };
+  }
+};
+function tickHealth(snapshots) {
+  const perRoom = {};
+  for (const snapshot of snapshots) {
+    const entry = {};
+    for (const counter of ["overruns", "maxTickMs", "ticks"]) {
+      const value = snapshot.metrics[counter];
+      if (typeof value === "number") entry[counter] = value;
+    }
+    perRoom[snapshot.roomId] = entry;
+  }
+  const ids = Object.keys(perRoom);
+  if (ids.length === 0) {
+    return {
+      sentence: "No tick-health counters have arrived yet. They appear once a room has run and the host has shipped a metrics poll.",
+      perRoom
+    };
+  }
+  const troubled = ids.filter((r) => (perRoom[r]?.overruns ?? 0) > 0);
+  if (troubled.length === 0) {
+    const worst = Math.max(...ids.map((r) => perRoom[r]?.maxTickMs ?? 0));
+    return {
+      sentence: `Tick health is clean across ${plural(ids.length, "room")}: zero overruns, worst single tick ${worst} ms.`,
+      perRoom
+    };
+  }
+  const detail = troubled.map((r) => `room ${r}: ${plural(perRoom[r]?.overruns ?? 0, "overrun")}`).join("; ");
+  return {
+    sentence: `Tick overruns recorded. ${detail}. An overrun is a tick the loop fell behind on and dropped.`,
+    perRoom
+  };
+}
+var metrics = {
+  name: "metrics",
+  description: "Read a project's metric rollups, including per-room tick health (overruns and worst tick). Read-only and cheap. This is how you tell whether a deployed room is keeping up with its own tick rate, which no other tool reports for a deployed tenant.",
+  inputSchema: projectSchema(),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const [rows, roomSnapshots] = await Promise.all([
+      api(ctx).get(`/v1/projects/${id}/metrics`),
+      api(ctx).get(`/v1/projects/${id}/metrics/rooms`)
+    ]);
+    if (rows.length === 0 && roomSnapshots.length === 0) {
+      return {
+        summary: `No metrics for ${id} yet. The host ships a rollup only once a tenant is running.`,
+        data: { project: id, count: 0, metrics: [] },
+        next: "Deploy a room and join it, then call `metrics` again."
+      };
+    }
+    const health = tickHealth(roomSnapshots);
+    const latest = /* @__PURE__ */ new Map();
+    const seenAt = /* @__PURE__ */ new Map();
+    for (const row of rows) {
+      const at = seenAt.get(row.name);
+      if (at === void 0 || row.at >= at) {
+        latest.set(row.name, row.value);
+        seenAt.set(row.name, row.at);
+      }
+    }
+    return {
+      summary: `${plural(latest.size, "metric")} for ${id}, latest reading of each. ${health.sentence}`,
+      data: {
+        project: id,
+        count: rows.length,
+        latest: Object.fromEntries(latest),
+        tickHealth: health.perRoom
+      },
+      next: Object.keys(health.perRoom).length > 0 && Object.values(health.perRoom).some((r) => (r.overruns ?? 0) > 0) ? "Call `logs` to see what the room was doing, then reduce per-tick work or lower the tick rate." : "Call `logs` for the same project if you are chasing a specific event."
+    };
+  }
+};
+function formatBytes(bytes) {
+  const units = ["B", "KB", "MB", "GB", "TB"];
+  let value = bytes;
+  let unit = 0;
+  while (value >= 1e3 && unit < units.length - 1) {
+    value /= 1e3;
+    unit++;
+  }
+  return `${unit === 0 ? String(Math.round(value)) : value.toFixed(2)} ${units[unit]}`;
+}
+var usage = {
+  name: "usage",
+  description: "Read a project's measured usage for the current billing period: room hours (with the physics engine each was run under), data out, voice minutes, and storage. Read-only and cheap. Each meter carries its signed rate and card-plan allowance, but these are measurements, not an invoice: only card plans bill overage (free plans stop at their caps), and meters nothing has reported come back as absent rather than as zero.",
+  inputSchema: projectSchema(),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const body = await api(ctx).get(`/v1/projects/${id}/usage`);
+    const reported = body.meters.filter((m) => m.present);
+    if (reported.length === 0) {
+      return {
+        summary: `No usage reported for ${id} in ${body.period.label}. Usage arrives once a host ships a window for a running tenant, so a project that has not been played is blank rather than zero.`,
+        data: { project: id, period: body.period, meters: body.meters },
+        next: "Deploy a room and join it, then call `usage` again."
+      };
+    }
+    const parts = reported.map((m) => {
+      if (m.unit === "bytes") return `${m.label.toLowerCase()} ${formatBytes(m.used)}`;
+      if (m.unit === "hours") return `${m.used.toFixed(3)} room hours`;
+      return `${m.used.toFixed(2)} ${m.unit}`;
+    });
+    const absent = body.meters.filter((m) => !m.present).map((m) => m.label.toLowerCase());
+    return {
+      summary: `${id} in ${body.period.label}: ${parts.join(", ")}.` + (absent.length > 0 ? ` Not reported: ${absent.join(", ")}.` : "") + (body.plan === "card" ? " These are measurements; overage past the included bundle is billed at the rates in each meter's pricing block." : " These are measurements, not charges: the free plan stops at its caps instead of billing."),
+      data: {
+        project: id,
+        period: body.period,
+        meters: body.meters,
+        windowCount: body.windows.length
+      },
+      next: "Call `metrics` for tick health on the same project, or `usage` again after more play to watch a meter move."
+    };
+  }
+};
+var leaderboard = {
+  name: "leaderboard",
+  description: "Read a project's leaderboards: every board with its row count, the top N of one board, or the rows around one player with their rank. Read-only and cheap. Scores can only be posted by room code (room.leaderboard.submit), and deleting a board or a row is deliberately not available here: it is a destructive act that belongs to a human running `irtio leaderboard delete --yes` after reading what would go.",
+  inputSchema: projectSchema(
+    {
+      board: {
+        type: "string",
+        description: 'Board name, e.g. "scores". Omit it to list every board on the project with its row count and direction.'
+      },
+      limit: {
+        type: "integer",
+        description: "How many rows for a top-N read. Default 10, max 100."
+      },
+      cursor: {
+        type: "string",
+        description: "Continue a top-N read from a previous call\u2019s `nextCursor`. Opaque: pass it back exactly as it was given, and do not construct one."
+      },
+      around: {
+        type: "string",
+        description: "A player id. Given, the read returns that player\u2019s neighbours and absolute rank instead of the top of the board."
+      }
+    },
+    []
+  ),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const around = typeof args.around === "string" ? args.around : void 0;
+    const limit = typeof args.limit === "number" ? args.limit : void 0;
+    const cursor = typeof args.cursor === "string" && args.cursor !== "" ? args.cursor : void 0;
+    if (typeof args.board !== "string" || args.board === "") {
+      const listed = await api(ctx).get(
+        `/v1/projects/${id}/leaderboards`
+      );
+      if (listed.boards.length === 0) {
+        return {
+          summary: `${id} has no leaderboards yet.`,
+          data: { project: id, boards: [] },
+          next: "A board appears when room code calls room.leaderboard.submit; nothing else can write to one."
+        };
+      }
+      return {
+        summary: `${id} has ${listed.boards.length} board(s): ` + listed.boards.map((b) => `${b.board} (${b.rows} row(s), ${b.direction})`).join(", "),
+        data: { project: id, boards: listed.boards },
+        next: "Call `leaderboard` again with `board` set to read one of them."
+      };
+    }
+    const board = args.board;
+    const query = new URLSearchParams();
+    if (limit !== void 0) query.set("limit", String(limit));
+    if (cursor !== void 0) query.set("cursor", cursor);
+    const q = query.toString();
+    const path = around !== void 0 ? `/v1/leaderboard/${id}/${encodeURIComponent(board)}/around/${encodeURIComponent(around)}` : `/v1/leaderboard/${id}/${encodeURIComponent(board)}/top${q === "" ? "" : `?${q}`}`;
+    const body = await api(ctx).get(path);
+    if (body.entries.length === 0) {
+      return {
+        summary: around !== void 0 ? `${around} has no score on ${board} in ${id}.` : `${board} in ${id} has no scores yet. A board fills up when room code calls room.leaderboard.submit; nothing else can write to it.`,
+        data: { project: id, board, direction: body.direction, entries: [] },
+        next: "Play a round that posts a score, then call `leaderboard` again."
+      };
+    }
+    const leader = body.entries[0];
+    return {
+      summary: `${board} in ${id} (${body.direction} is better): ${body.entries.length} row(s), leading with ${leader?.playerId} on ${leader?.score}.` + (around !== void 0 ? ` ${around} is ranked ${String(body.rank)}.` : ""),
+      data: {
+        project: id,
+        board,
+        direction: body.direction,
+        rank: body.rank ?? null,
+        entries: body.entries,
+        // Opaque, and passed straight back through `cursor` to read the next page. Absent means
+        // this is the last page.
+        nextCursor: body.nextCursor ?? null
+      },
+      next: body.nextCursor !== void 0 ? "Call `leaderboard` again with `cursor` set to `nextCursor` for the next page." : "Call `leaderboard` with `around` set to a player id to see where they sit, or `usage` for what the project is costing."
+    };
+  }
+};
+var ratings = {
+  name: "ratings",
+  description: "Read a project's skill ratings: every queue with its row count, or one queue's ranking best first. Read-only and cheap. Ratings move only from room code (room.ratings.report), which is what makes them worth anything, and removing one is deliberately not available here: it is a destructive act that belongs to a human running `irtio ratings delete --yes`.",
+  inputSchema: projectSchema({
+    queue: {
+      type: "string",
+      description: 'Queue name, e.g. "ranked". Omit it to list every queue with ratings on the project.'
+    },
+    limit: { type: "integer", description: "How many rows. Default 20, max 100." },
+    cursor: {
+      type: "string",
+      description: "Continue from a previous call\u2019s `nextCursor`. Opaque: pass it back exactly as it was given, and do not construct one."
+    }
+  }),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    if (typeof args.queue !== "string" || args.queue === "") {
+      const listed = await api(ctx).get(
+        `/v1/projects/${id}/ratings`
+      );
+      if (listed.queues.length === 0) {
+        return {
+          summary: `${id} has no rating queues yet.`,
+          data: { project: id, queues: [] },
+          next: "A rating appears when room code calls room.ratings.report; nothing else can write one."
+        };
+      }
+      return {
+        summary: `${id} has ${listed.queues.length} queue(s): ` + listed.queues.map((q2) => `${q2.queue} (${q2.rows} rated, ${q2.skill ? "skill" : "fifo"})`).join(", "),
+        data: { project: id, queues: listed.queues },
+        next: "Call `ratings` again with `queue` set to read one of them."
+      };
+    }
+    const queue = args.queue;
+    const query = new URLSearchParams();
+    if (typeof args.limit === "number") query.set("limit", String(args.limit));
+    if (typeof args.cursor === "string" && args.cursor !== "") query.set("cursor", args.cursor);
+    const q = query.toString();
+    const body = await api(ctx).get(
+      `/v1/projects/${id}/ratings/${encodeURIComponent(queue)}${q === "" ? "" : `?${q}`}`
+    );
+    if (body.entries.length === 0) {
+      return {
+        summary: `${queue} in ${id} has no ratings yet.`,
+        data: { project: id, queue, entries: [] },
+        next: "Play a rated match that calls room.ratings.report, then call `ratings` again."
+      };
+    }
+    const top = body.entries[0];
+    return {
+      summary: `${queue} in ${id}: ${body.entries.length} row(s), led by ${top?.playerId} on ${top?.rating.toFixed(0)} (deviation ${top?.deviation.toFixed(0)}, ${top?.games} game(s)).`,
+      data: { project: id, queue, entries: body.entries, nextCursor: body.nextCursor },
+      next: 'A deviation near 350 is a player nobody has measured yet, which is usually the answer to "why did the matchmaker pair those two". `match_status` shows who is queueing now.'
+    };
+  }
+};
+var matchStatus = {
+  name: "match_status",
+  description: "How many players are waiting in a project's quick-match queue right now, and how many it takes to fill. Read-only and cheap. This does NOT join the queue: queueing is a long poll that ends in a room code, which is the player's call to make.",
+  inputSchema: projectSchema({
+    queue: {
+      type: "string",
+      description: "Queue name. Omitted reads the project's default queue."
+    }
+  }),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const queue = typeof args.queue === "string" ? args.queue : void 0;
+    const body = await api(ctx).get(
+      `/match/status?project=${encodeURIComponent(id)}${queue !== void 0 ? `&queue=${encodeURIComponent(queue)}` : ""}`
+    );
+    return {
+      summary: `${body.waiting} of ${body.size} waiting in the ${body.queue} queue on ${id}` + (body.waiting === 0 ? " (nobody is queueing)." : "."),
+      data: { project: id, ...body },
+      next: "A queue that never fills is usually a game with no players rather than a broken matcher; `usage` says whether anyone has been playing at all."
+    };
+  }
+};
+var deploymentList = {
+  name: "deployment_list",
+  description: "List a project's deployments, newest first, with the schema hash and whether each was rolled back. Read-only and cheap. This is where you find the version number `rollback` takes.",
+  inputSchema: projectSchema(),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const rows = await api(ctx).get(`/v1/projects/${id}/deployments`);
+    if (rows.length === 0) {
+      return {
+        summary: `${id} has never been deployed.`,
+        data: { project: id, count: 0, deployments: [] },
+        next: "Call `deploy` from a directory holding an irtio.json and a room file."
+      };
+    }
+    const serving = rows.find((d) => d.rolledBackAt == null);
+    const rolledBack = rows.filter((d) => d.rolledBackAt != null).length;
+    return {
+      summary: `${plural(rows.length, "deployment")} for ${id}, newest first. Serving v${serving?.version ?? rows[0]?.version}.` + (rolledBack > 0 ? ` ${plural(rolledBack, "version")} rolled back.` : ""),
+      data: {
+        project: id,
+        count: rows.length,
+        serving: serving?.version ?? null,
+        deployments: rows
+      },
+      next: "Call `rollback` with a version to re-promote it, or `deploy` to ship a new one."
+    };
+  }
+};
+var saveList = {
+  name: "save_list",
+  description: "List the save generations of one room, newest first, with their sizes. Read-only and cheap. Saves are listed from object storage rather than from the room, so this works even when the tenant is stopped, which is the case it is most useful in.",
+  inputSchema: projectSchema(
+    { room: { type: "string", description: "The room id, as it appears in `rooms`." } },
+    ["room"]
+  ),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const room = str(args, "room");
+    const rows = await api(ctx).get(
+      `/v1/projects/${id}/rooms/${encodeURIComponent(room)}/saves`
+    );
+    if (rows.length === 0) {
+      return {
+        summary: `Room ${room} has no save generations.`,
+        data: { project: id, room, count: 0, saves: [] },
+        next: "Nothing to restore. Check the room id with `rooms`."
+      };
+    }
+    const newest = rows[0];
+    return {
+      summary: `${plural(rows.length, "save generation")} for room ${room}, newest first. The newest is ${newest?.saveId} from ${newest?.createdAt} at v${newest?.version}, ${newest?.bytes} bytes.`,
+      data: { project: id, room, count: rows.length, saves: rows },
+      next: "Call `save_restore` with one of these saveId values to put the room back to it."
+    };
+  }
+};
+var projectCreate = {
+  name: "project_create",
+  description: "Create a project. This writes: it registers a new project in your organisation and returns its id, which is also the public project key a client joins with. Cheap, and the first step before any deploy.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      name: { type: "string", description: "A human-readable name. Not the id." },
+      region: {
+        type: "string",
+        description: "Placement region. Defaults to the control plane's own region."
+      }
+    },
+    required: ["name"],
+    additionalProperties: false
+  },
+  async run(ctx, args) {
+    const name = str(args, "name");
+    const region = optStr(args, "region");
+    const project = await api(ctx).post("/v1/projects", {
+      name,
+      ...region !== void 0 ? { region } : {}
+    });
+    return {
+      summary: `Created ${project.name} in ${project.region}. Its id is ${project.id}, which is also the project key your client joins with. No origins are allowed yet, so a hosted page cannot connect until you add one.`,
+      data: {
+        project: project.id,
+        projectKey: project.id,
+        name: project.name,
+        region: project.region
+      },
+      next: `Call \`origin_add\` with the site that will serve your client, then \`deploy\` with project="${project.id}".`
+    };
+  }
+};
+var projectUpdate = {
+  name: "project_update",
+  description: "Change a project's name, its per-IP connection limit, or its tenant VM memory size. This writes. The limit caps how many connections one IP may open per minute; pass null to go back to the tenant default. Raising it is what a load test needs. The VM size is how much memory the tenant gets, in MiB; pass null for automatic sizing. Neither takes effect immediately: both apply at the tenant's next start.",
+  inputSchema: projectSchema({
+    name: { type: "string", description: "New name. Omit to leave it alone." },
+    connectionsPerIpPerMin: {
+      type: ["number", "null"],
+      description: "Connections per IP per minute, at least 1. null resets to the tenant default."
+    },
+    vmMemMib: {
+      type: ["number", "null"],
+      description: "Tenant VM memory in MiB, between 128 and 4096. null returns the project to automatic sizing (128 MiB, or 256 MiB when the schema declares physics). Raise it for a project whose tenant is being killed for running out of memory."
+    }
+  }),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const current = await api(ctx).get(`/v1/projects/${id}`);
+    const name = optStr(args, "name") ?? current.name;
+    const limitGiven = "connectionsPerIpPerMin" in args;
+    const limit = limitGiven ? args.connectionsPerIpPerMin : void 0;
+    const memGiven = "vmMemMib" in args;
+    const mem = memGiven ? args.vmMemMib : void 0;
+    const updated = await api(ctx).patch(`/v1/projects/${id}`, {
+      name,
+      ...limitGiven ? { connectionsPerIpPerMin: limit } : {},
+      ...memGiven ? { vmMemMib: mem } : {}
+    });
+    const changed = [];
+    if (updated.name !== current.name) changed.push(`name is now ${updated.name}`);
+    if (limitGiven) {
+      changed.push(
+        updated.connectionsPerIpPerMin === null ? "the per-IP connection limit is back to the tenant default" : `the per-IP connection limit is ${updated.connectionsPerIpPerMin} per minute`
+      );
+    }
+    if (memGiven) {
+      changed.push(
+        updated.vmMemMib === null ? "the tenant VM is sized automatically again from its next cold boot" : `the tenant VM gets ${updated.vmMemMib} MiB from its next cold boot`
+      );
+    }
+    const timing = limitGiven && memGiven ? " Both apply at the next tenant start; a running tenant keeps its current limit and size until it is placed again." : limitGiven ? " The limit is carried in the tenant environment, so it applies from the next tenant start." : memGiven ? " A running tenant keeps its current size until it is placed again, because a VM cannot be resized underneath a live guest." : "";
+    return {
+      summary: changed.length === 0 ? `Nothing changed on ${id}.` : `Updated ${id}: ${changed.join(", ")}.` + timing,
+      data: {
+        project: updated.id,
+        name: updated.name,
+        connectionsPerIpPerMin: updated.connectionsPerIpPerMin,
+        vmMemMib: updated.vmMemMib,
+        changed
+      },
+      next: limitGiven || memGiven ? "Call `deploy` to restart the tenant so the new settings are in force." : "Call `project_get` to confirm the settings."
+    };
+  }
+};
+var originAdd = {
+  name: "origin_add",
+  description: "Allow one browser origin to connect to this project. This writes. An origin is a scheme and host, like https://example.com, with no path. Until at least one is allowed, a hosted page cannot open a socket.",
+  inputSchema: projectSchema(
+    { origin: { type: "string", description: "Scheme and host, like https://example.com." } },
+    ["origin"]
+  ),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const origin = str(args, "origin");
+    const rows = await api(ctx).post(`/v1/projects/${id}/origins`, {
+      origin
+    });
+    return {
+      summary: `${origin} may now connect to ${id}. ${plural(rows.length, "origin")} allowed in total.`,
+      data: { project: id, added: origin, origins: rows.map((o) => o.origin) },
+      next: "Call `deploy` to ship your room, or `origin_add` again for another site."
+    };
+  }
+};
+var originRemove = {
+  name: "origin_remove",
+  description: "Withdraw one browser origin. This writes, and it takes effect for new connections. Removing the last origin leaves the project unreachable from any hosted page.",
+  inputSchema: projectSchema(
+    { origin: { type: "string", description: "The exact origin string to remove." } },
+    ["origin"]
+  ),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const origin = str(args, "origin");
+    const rows = await api(ctx).del(`/v1/projects/${id}/origins`, {
+      origin
+    });
+    return {
+      summary: `${origin} may no longer connect to ${id}. ` + (rows.length === 0 ? "No origins remain, so no hosted page can connect to this project." : `${plural(rows.length, "origin")} still allowed.`),
+      data: { project: id, removed: origin, origins: rows.map((o) => o.origin) },
+      next: rows.length === 0 ? "Call `origin_add` if that was not intended." : "Call `origin_list` to confirm what remains."
+    };
+  }
+};
+var jwtSecretMint = {
+  name: "jwt_secret_mint",
+  description: "Mint a JWT signing secret for a project. This writes, and it returns the plaintext secret exactly once: there is no route that reads one back, so store it now or mint another. At most two are active per issuer at a time, which is what makes a rotation safe.",
+  inputSchema: projectSchema({
+    issuer: {
+      type: "string",
+      description: "Issuer name, defaults to `main`. It becomes the namespace half of player ids."
+    }
+  }),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const issuer = optStr(args, "issuer");
+    const result = await api(ctx).post(
+      `/v1/projects/${id}/jwt-secret`,
+      { ...issuer !== void 0 ? { issuer } : {} }
+    );
+    return {
+      summary: `Minted a signing secret for issuer ${result.issuer} on ${id}. ${result.active} of a possible 2 are now active. This plaintext is shown once and cannot be read back. Put it in your token server's environment, not in a config file you commit.`,
+      data: { project: id, issuer: result.issuer, active: result.active, secret: result.secret },
+      next: result.active === 2 ? "Sign new tokens with this secret, then call `jwt_secret_retire` to end the overlap." : "Sign your player tokens with this secret."
+    };
+  }
+};
+var jwtSecretRetire = {
+  name: "jwt_secret_retire",
+  description: "Retire the oldest active JWT signing secret for an issuer. This writes, and it is not reversible: tokens signed with the retired secret stop verifying. Run it only after every token issuer has moved to the newer secret.",
+  inputSchema: projectSchema({
+    issuer: { type: "string", description: "Issuer name, defaults to `main`." }
+  }),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const issuer = optStr(args, "issuer");
+    const result = await api(ctx).post(
+      `/v1/projects/${id}/jwt-secret/retire`,
+      { ...issuer !== void 0 ? { issuer } : {} }
+    );
+    return {
+      summary: `Retired the oldest signing secret for issuer ${issuer ?? "main"} on ${id}. ${result.active} still active. Tokens signed with the retired secret no longer verify.`,
+      data: { project: id, issuer: issuer ?? "main", active: result.active },
+      next: "The rotation is finished. Call `jwt_secret_mint` when you next need to rotate."
+    };
+  }
+};
+var saveRestore = {
+  name: "save_restore",
+  description: "Put one room back to a named save generation. This writes and it is disruptive: the project's tenant is stopped without snapshotting, so EVERY room in the project drops its connections, not just this one. The others come back from their own saves unchanged. The room's current state is discarded, which is the point.",
+  inputSchema: projectSchema(
+    {
+      room: { type: "string", description: "The room id to restore." },
+      saveId: { type: "string", description: "A saveId from `save_list`." }
+    },
+    ["room", "saveId"]
+  ),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const room = str(args, "room");
+    const saveId = str(args, "saveId");
+    const result = await api(ctx).post(
+      `/v1/projects/${id}/rooms/${encodeURIComponent(room)}/restore`,
+      { saveId }
+    );
+    const applied = result.applied === "stopped" ? "The tenant was running and has been stopped, so every room in this project dropped its connections. The restore lands on the next join." : "No tenant was running, so nothing was disconnected. The restore lands on the next placement.";
+    return {
+      summary: `Room ${room} in ${id} will come back from save ${saveId}. ${applied}`,
+      data: { project: id, room, saveId, applied: result.applied },
+      next: "Join the room, or run `irtio simulate`, to bring it up on the restored state, then call `logs` to confirm."
+    };
+  }
+};
+var rollback = {
+  name: "rollback",
+  description: "Re-promote an older deployment and bring every room that migrated past it back to its pre-migration state. This writes and it is disruptive: the tenant is stopped, so every room in the project drops its connections. Rooms with no pre-migration save are reported skipped by name rather than silently left alone.",
+  inputSchema: projectSchema(
+    { version: { type: "number", description: "The deployment version to go back to." } },
+    ["version"]
+  ),
+  async run(ctx, args) {
+    const id = str(args, "project");
+    const version = optInt(args, "version");
+    if (version === void 0) throw new Error("`version` is required and must be a whole number");
+    const result = await api(ctx).post(`/v1/projects/${id}/rollback`, { version });
+    const restored = result.rooms.filter((r) => r.action === "restored");
+    const skipped = result.rooms.filter((r) => r.action === "skipped");
+    const skipNote = skipped.length > 0 ? ` ${plural(skipped.length, "room")} skipped (${skipped.map((r) => r.roomId).join(", ")}): no pre-migration state at that version.` : "";
+    return {
+      summary: `${id} is back on v${result.version}. ${plural(result.rolledBack, "newer deployment")} marked rolled back. ${plural(restored.length, "room")} restored to pre-migration state.${skipNote} ` + (result.applied === "stopped" ? "The tenant was stopped, so every room dropped its connections." : "No tenant was running, so nothing was disconnected."),
+      data: {
+        project: id,
+        version: result.version,
+        rolledBack: result.rolledBack,
+        applied: result.applied,
+        restored: restored.map((r) => r.roomId),
+        skipped: skipped.map((r) => ({ roomId: r.roomId, reason: r.reason }))
+      },
+      next: "Call `deployment_list` to confirm what is serving, then `logs` once a room has come back up."
+    };
+  }
+};
+var deploy = {
+  name: "deploy",
+  description: "Bundle the room in the working directory and ship it. This writes, it is the most expensive tool here, and it is disruptive: it builds a bundle locally, uploads it, and drains or migrates live rooms. The control plane decides authoritatively whether the schema change is additive or breaking; a breaking one is refused unless you supply a migration. Needs an irtio.json and a room file in `cwd`.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      project: {
+        type: "string",
+        description: "Project id. Defaults to the one in irtio.json."
+      },
+      cwd: {
+        type: "string",
+        description: "Directory holding irtio.json and the room file. Defaults to the server's."
+      },
+      room: { type: "string", description: "Path to the room file, if it is not the default." },
+      strategy: {
+        type: "string",
+        enum: ["drain", "migrate"],
+        description: "drain closes rooms and lets them come back; migrate carries state forward."
+      },
+      allowBreaking: {
+        type: "boolean",
+        description: "Permit a breaking schema change. Only meaningful with a migration present."
+      }
+    },
+    additionalProperties: false
+  },
+  async run(ctx, args) {
+    const project = optStr(args, "project");
+    const cwd = optStr(args, "cwd") ?? ctx.cwd;
+    const room = optStr(args, "room");
+    const strategy = optStr(args, "strategy");
+    if (strategy !== void 0 && strategy !== "drain" && strategy !== "migrate") {
+      throw new Error('`strategy` must be "drain" or "migrate"');
+    }
+    const allowBreaking = args.allowBreaking === true;
+    const lines = [];
+    const result = await runDeploy({
+      cwd,
+      client: api(ctx),
+      log: (line) => lines.push(stripAnsi(line)),
+      // A deploy must never block on a prompt here: there is no human at this end of the pipe.
+      ask: async () => "",
+      ...project !== void 0 ? { project } : {},
+      ...room !== void 0 ? { room } : {},
+      ...strategy !== void 0 ? { strategy } : {},
+      ...allowBreaking ? { allowBreaking: true } : {}
+    });
+    const drained = result.rooms ?? [];
+    const applied = result.applied ?? "pending";
+    const appliedNote = applied === "live" ? drained.length === 0 ? "The running tenant took the new version, and no rooms were live to move." : `The running tenant took the new version. ${plural(drained.length, "room")} moved.` : "No tenant was running, so the new version is picked up on the next placement.";
+    return {
+      summary: `Deployed v${result.version} of ${result.project}. ${appliedNote} Playable at ${result.url}.`,
+      data: {
+        project: result.project,
+        version: result.version,
+        url: result.url,
+        applied,
+        draining: result.draining,
+        rooms: drained,
+        ...result.site !== void 0 ? { site: result.site } : {},
+        output: lines
+      },
+      // D41: the verification step is now a scenario, which asserts against the server's own
+      // recorded timeline rather than reporting what the bots happened to see.
+      next: "Verify it: write a scenario and call `scenario_run` against `irtio dev`, then call `logs` and `metrics` for this project."
+    };
+  }
+};
+var DEFAULT_DEV_URL = "ws://localhost:7070";
+var scenarioRun = {
+  name: "scenario_run",
+  local: true,
+  description: "Run a scenario file against a local `irtio dev` room and report every assertion against the recorded authoritative timeline. This is the verification step after a deploy or a room change. It runs against a dev server on this machine (ws://localhost:7070 by default), not against a deployed tenant, because only `irtio dev` exposes the authoritative timeline. It opens real sockets and plays the room for a few seconds, so it is not a cheap read. The built-in invariants run underneath and still gate the verdict.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      scenario: {
+        type: "string",
+        description: "Path to the scenario module, relative to `cwd`. Its default export is defineScenario({ bots, script, assert }) from @irtio/bots."
+      },
+      cwd: {
+        type: "string",
+        description: "Project directory holding irtio/schema.ts. Defaults to the server cwd."
+      },
+      url: {
+        type: "string",
+        description: `The dev server socket URL. Default ${DEFAULT_DEV_URL}.`
+      }
+    },
+    required: ["scenario"],
+    additionalProperties: false
+  },
+  async run(ctx, args) {
+    const scenario = str(args, "scenario");
+    const cwd = optStr(args, "cwd") ?? ctx.cwd;
+    const url = optStr(args, "url") ?? DEFAULT_DEV_URL;
+    const lines = [];
+    const run = await runSimulation({
+      cwd,
+      scenario,
+      url,
+      log: (line) => lines.push(stripAnsi(line))
+    });
+    const section = run.scenario;
+    const assertions = section?.assertions ?? [];
+    const failed = assertions.filter((a) => !a.ok);
+    const brokenInvariants = run.report.invariants.filter((i) => !i.ok);
+    const verdict = failed.length === 0 && brokenInvariants.length === 0 ? `The scenario held. ${plural(assertions.length, "assertion")} passed against ${plural(section?.ticks ?? 0, "recorded tick")}, and every built-in invariant held.` : "The scenario failed. " + (failed.length > 0 ? `${plural(failed.length, "assertion")} did not hold: ${failed.map(
+      (a) => `${a.name}${a.tick !== void 0 ? ` at tick ${a.tick}` : ""}: ${a.detail}`
+    ).join("; ")}. ` : "") + (brokenInvariants.length > 0 ? `Built-in invariants failed too: ${brokenInvariants.map((i) => i.name).join(", ")}.` : "");
+    return {
+      summary: verdict.trim(),
+      data: {
+        scenario: section?.file ?? scenario,
+        room: run.report.roomId,
+        url,
+        exitCode: run.exitCode,
+        ok: run.exitCode === 0,
+        recordedTicks: section?.ticks ?? 0,
+        droppedTicks: section?.dropped ?? 0,
+        assertions: assertions.map((a) => ({
+          name: a.name,
+          ok: a.ok,
+          ...a.tick !== void 0 ? { tick: a.tick } : {},
+          detail: a.detail
+        })),
+        invariants: run.report.invariants.map((i) => ({
+          name: i.name,
+          state: i.state,
+          detail: i.detail
+        })),
+        ...section !== void 0 ? { timeline: section.timelinePath } : {},
+        trace: run.tracePath,
+        output: lines
+      },
+      next: failed.length === 0 && brokenInvariants.length === 0 ? "Deploy it with `deploy`, or widen the scenario: add a bot, or assert on another tick." : `Read the recorded timeline at ${section?.timelinePath ?? run.tracePath} and the frame trace at ${run.tracePath}, then fix the room handler the failing assertion names.`
+    };
+  }
+};
+var ANSI = /\u001b\[[0-9;]*m/g;
+function stripAnsi(line) {
+  return line.replace(ANSI, "");
+}
+var TOOLS = [
+  whoami,
+  projectList,
+  projectGet,
+  originList,
+  rooms,
+  logs,
+  metrics,
+  usage,
+  leaderboard,
+  matchStatus,
+  ratings,
+  deploymentList,
+  saveList,
+  projectCreate,
+  projectUpdate,
+  originAdd,
+  originRemove,
+  jwtSecretMint,
+  jwtSecretRetire,
+  saveRestore,
+  rollback,
+  deploy,
+  scenarioRun
+];
+function toolByName(name) {
+  return TOOLS.find((t) => t.name === name);
+}
+
+// src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+var SERVER_NAME = "irtio";
+var SERVER_VERSION = "0.5.2";
+var INSTRUCTIONS = "irtio hosts multiplayer rooms for web games. These tools reach the irtio control plane: create projects, allow browser origins, deploy rooms, and read rooms, logs, metrics and saves. Every tool needs a signed-in account. If a tool answers that you are not signed in, run `irtio login` in a terminal and call it again. Start with `whoami` or `project_list`.";
+function createMcpServer(options = {}) {
+  const server = new Server(
+    { name: SERVER_NAME, version: SERVER_VERSION },
+    { capabilities: { tools: {} }, instructions: INSTRUCTIONS }
+  );
+  server.setRequestHandler(ListToolsRequestSchema, async () => ({
+    tools: TOOLS.map((t) => ({
+      name: t.name,
+      description: t.description,
+      inputSchema: t.inputSchema
+    }))
+  }));
+  const asResult = (r) => ({ ...r });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const name = request.params.name;
+    const tool = toolByName(name);
+    if (!tool) {
+      return asResult({
+        ...narrate({
+          summary: `There is no tool called \`${name}\` on this server.`,
+          data: { error: "unknown_tool", tool: name, available: TOOLS.map((t) => t.name) },
+          next: "Pick one of the tool names listed above."
+        }),
+        isError: true
+      });
+    }
+    try {
+      const resolved = tool.local ? void 0 : await requireClient(options.env, options.controlUrl);
+      const ctx = {
+        client: resolved?.client,
+        controlUrl: resolved?.auth.controlUrl ?? options.controlUrl ?? "",
+        cwd: options.cwd ?? process.cwd()
+      };
+      const args = request.params.arguments ?? {};
+      return asResult(narrate(await tool.run(ctx, args)));
+    } catch (err) {
+      return asResult(narrateError(err, name));
+    }
+  });
+  return server;
+}
+
+export {
+  resolveAuth,
+  NoCredentialError,
+  requireClient,
+  narrate,
+  LOGIN_NARRATION,
+  narrateError,
+  TOOLS,
+  toolByName,
+  SERVER_NAME,
+  SERVER_VERSION,
+  createMcpServer
+};