@frontmcp/testing 1.8.5 → 1.8.7

package/esm/fixtures/index.mjs

@@ -5,16 +5,6 @@ var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require
   throw Error('Dynamic require of "' + x + '" is not supported');
 });
 
-// libs/testing/src/fixtures/test-fixture.ts
-import {
-  afterAll as _afterAll,
-  afterEach as _afterEach,
-  beforeAll as _beforeAll,
-  beforeEach as _beforeEach,
-  describe as _describe,
-  it as _it
-} from "@jest/globals";
-
 // libs/testing/src/auth/token-factory.ts
 import { exportJWK, generateKeyPair, SignJWT } from "jose";
 var TestTokenFactory = class {
@@ -73,14 +63,15 @@ var TestTokenFactory = class {
    */
   async createTestToken(options) {
     await this.ensureKeys();
-    const now = Math.floor(Date.now() / 1e3);
+    const nowMs = Date.now();
+    const iat = Math.floor(nowMs / 1e3);
     const exp = options.exp ?? 3600;
     const payload = {
       iss: options.iss ?? this.issuer,
       sub: options.sub,
       aud: options.aud ?? this.audience,
-      iat: now,
-      exp: now + exp,
+      iat,
+      exp: Math.ceil(nowMs / 1e3) + exp,
       scope: options.scopes?.join(" "),
       ...options.claims
     };
@@ -105,10 +96,10 @@ var TestTokenFactory = class {
   /**
    * Create a regular user token
    */
-  async createUserToken(sub = "user-001", scopes = ["read", "write"]) {
+  async createUserToken(sub = "user-001", scopes2 = ["read", "write"]) {
     return this.createTestToken({
       sub,
-      scopes,
+      scopes: scopes2,
       claims: {
         email: "user@test.local",
         name: "Test User",
@@ -119,10 +110,11 @@ var TestTokenFactory = class {
   /**
    * Create an anonymous user token
    */
-  async createAnonymousToken() {
+  async createAnonymousToken(expiresIn) {
     return this.createTestToken({
       sub: `anon:${Date.now()}`,
       scopes: ["anonymous"],
+      exp: expiresIn,
       claims: {
         name: "Anonymous",
         role: "anonymous"
@@ -471,6 +463,32 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// libs/testing/src/transport/error-utils.ts
+function errorName(err) {
+  if (typeof err !== "object" || err === null) return void 0;
+  const name = err.name;
+  return typeof name === "string" ? name : void 0;
+}
+function isAbortError(err) {
+  return errorName(err) === "AbortError";
+}
+function errorMessage(err, fallback = "Unknown error") {
+  if (typeof err === "string" && err) return err;
+  if (typeof err === "object" && err !== null) {
+    const message = err.message;
+    if (typeof message === "string" && message) return message;
+  }
+  return fallback;
+}
+var interceptedErrors = /* @__PURE__ */ new WeakSet();
+function markInterceptedError(err) {
+  interceptedErrors.add(err);
+  return err;
+}
+function isInterceptedError(err) {
+  return typeof err === "object" && err !== null && interceptedErrors.has(err);
+}
+
 // libs/testing/src/transport/streamable-http.transport.ts
 var DEFAULT_TIMEOUT = 3e4;
 var NOTIFICATION_STREAM_REOPEN_DELAY_MS = 250;
@@ -579,7 +597,7 @@ var StreamableHttpTransport = class {
           return mockResponse2;
         }
         case "error":
-          throw interceptResult.error;
+          throw markInterceptedError(interceptResult.error);
         case "continue":
           message = interceptResult.request;
           break;
@@ -640,7 +658,7 @@ var StreamableHttpTransport = class {
       return jsonResponse;
     } catch (error) {
       clearTimeout(timeoutId);
-      if (error instanceof Error && error.name === "AbortError") {
+      if (isAbortError(error)) {
         return {
           jsonrpc: "2.0",
           id: message.id ?? null,
@@ -679,7 +697,7 @@ var StreamableHttpTransport = class {
       }
     } catch (error) {
       clearTimeout(timeoutId);
-      if (error instanceof Error && error.name !== "AbortError") {
+      if (!isAbortError(error)) {
         throw error;
       }
     }
@@ -720,7 +738,7 @@ var StreamableHttpTransport = class {
         error: {
           code: -32700,
           message: "Parse error",
-          data: error instanceof Error ? error.message : "Unknown error"
+          data: errorMessage(error)
         }
       };
     }
@@ -1090,7 +1108,7 @@ var StreamableHttpTransport = class {
     if (this.config.clientInfo) {
       headers["User-Agent"] = `${this.config.clientInfo.name}/${this.config.clientInfo.version}`;
     }
-    if (this.authToken && !this.publicMode) {
+    if (this.authToken) {
       headers["Authorization"] = `Bearer ${this.authToken}`;
     }
     if (this.sessionId) {
@@ -1413,6 +1431,16 @@ var DEFAULT_CLIENT_INFO = {
   name: "@frontmcp/testing",
   version: "0.4.0"
 };
+var MAX_LIST_PAGES = 1e3;
+function isAuthFailure(error) {
+  return typeof error?.message === "string" && /^HTTP (401|403)\b/.test(error.message);
+}
+function describeInitializeError(error) {
+  const message = error?.message ?? "Unknown error";
+  const data = error?.data;
+  const detail = typeof data === "string" ? data.trim() : "";
+  return detail ? `${message} - ${detail.slice(0, 500)}` : message;
+}
 function extractEntryPaths(data) {
   let payload = data;
   if (typeof payload === "string") {
@@ -1499,19 +1527,22 @@ var McpTestClient = class {
   async connect() {
     this.log("debug", `Connecting to ${this.config.baseUrl}...`);
     this.triedDiscoveredEntryPath = false;
+    this.initResult = null;
     this.transport = this.createTransport();
     await this.transport.connect();
     const maxRetries = 3;
     const retryDelayMs = 500;
     let lastError;
     let reportedEntryPaths;
+    let attemptsMade = 0;
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
+      attemptsMade = attempt;
       const initResponse = await this.initialize();
       if (initResponse.success && initResponse.data) {
         this.initResult = initResponse.data;
         break;
       }
-      lastError = initResponse.error?.message ?? "Unknown error";
+      lastError = describeInitializeError(initResponse.error);
       reportedEntryPaths = extractEntryPaths(initResponse.error?.data) ?? reportedEntryPaths;
       if (reportedEntryPaths?.length === 1 && !this.triedDiscoveredEntryPath) {
         this.triedDiscoveredEntryPath = true;
@@ -1523,6 +1554,7 @@ var McpTestClient = class {
         await this.transport.connect();
         continue;
       }
+      if (isAuthFailure(initResponse.error)) break;
       if (attempt < maxRetries) {
         this.log("debug", `MCP init attempt ${attempt} failed (${lastError}), retrying in ${retryDelayMs}ms...`);
         await new Promise((resolve) => setTimeout(resolve, retryDelayMs));
@@ -1531,7 +1563,7 @@ var McpTestClient = class {
     if (!this.initResult) {
       const served = reportedEntryPaths?.length ? ` The server reports it serves MCP at ${reportedEntryPaths.join(", ")}; set \`entryPath\` in test.use() (or \`http.entryPath\` on the server) to match.` : "";
       throw new Error(
-        `Failed to initialize MCP connection to ${this.config.baseUrl}${this.mcpPathLabel()} after ${maxRetries} attempts: ${lastError}.${served}`
+        `Failed to initialize MCP connection to ${this.config.baseUrl}${this.mcpPathLabel()} after ${attemptsMade} attempt${attemptsMade === 1 ? "" : "s"}: ${lastError}.${served}`
       );
     }
     this._sessionId = this.transport.getSessionId();
@@ -1601,18 +1633,47 @@ var McpTestClient = class {
     return this._authState;
   }
   /**
-   * Authenticate with a token
+   * Authenticate with a token.
+   *
+   * When connected, this opens a NEW session with the token (the previous session was created
+   * for the previous identity) and rejects if the server refuses it — for example because the
+   * token is expired or badly signed. On rejection the client keeps its previous identity and
+   * session. The token is kept in the client config, so `reconnect()` keeps using it.
    */
   async authenticate(token) {
+    if (typeof token !== "string" || token.trim() === "") {
+      throw new Error("authenticate() requires a non-empty token");
+    }
+    const previousAuthState = this._authState;
+    const previousConfigAuth = this.config.auth;
+    this.config.auth = { ...previousConfigAuth, token };
     this._authState = {
       isAnonymous: false,
       token,
       scopes: this.parseScopesFromToken(token),
       user: this.parseUserFromToken(token)
     };
-    if (this.transport) {
-      this.transport.setAuthToken(token);
+    const previousTransport = this.transport;
+    if (!previousTransport) {
+      this.log("debug", "Authentication updated (not connected yet)");
+      return;
     }
+    const previousInit = this.initResult;
+    const previousSessionId = this._sessionId;
+    const previousSessionInfo = this._sessionInfo;
+    try {
+      await this.connect();
+    } catch (err) {
+      await this.transport?.close().catch(() => void 0);
+      this.transport = previousTransport;
+      this.initResult = previousInit;
+      this._sessionId = previousSessionId;
+      this._sessionInfo = previousSessionInfo;
+      this.config.auth = previousConfigAuth;
+      this._authState = previousAuthState;
+      throw err;
+    }
+    await previousTransport.close().catch(() => void 0);
     this.log("debug", "Authentication updated");
   }
   // ═══════════════════════════════════════════════════════════════════
@@ -1646,13 +1707,12 @@ var McpTestClient = class {
     /**
      * List all available tools
      */
-    list: async () => {
-      const response = await this.listTools();
-      if (!response.success || !response.data) {
-        throw new Error(`Failed to list tools: ${response.error?.message}`);
-      }
-      return response.data.tools;
-    },
+    list: async () => this.listAllPages(
+      "tools/list",
+      "tools",
+      (cursor) => this.listTools(cursor),
+      (page) => page.tools
+    ),
     /**
      * Call a tool by name with arguments
      */
@@ -1668,23 +1728,21 @@ var McpTestClient = class {
     /**
      * List all static resources
      */
-    list: async () => {
-      const response = await this.listResources();
-      if (!response.success || !response.data) {
-        throw new Error(`Failed to list resources: ${response.error?.message}`);
-      }
-      return response.data.resources;
-    },
+    list: async () => this.listAllPages(
+      "resources/list",
+      "resources",
+      (cursor) => this.listResources(cursor),
+      (page) => page.resources
+    ),
     /**
      * List all resource templates
      */
-    listTemplates: async () => {
-      const response = await this.listResourceTemplates();
-      if (!response.success || !response.data) {
-        throw new Error(`Failed to list resource templates: ${response.error?.message}`);
-      }
-      return response.data.resourceTemplates;
-    },
+    listTemplates: async () => this.listAllPages(
+      "resources/templates/list",
+      "resource templates",
+      (cursor) => this.listResourceTemplates(cursor),
+      (page) => page.resourceTemplates
+    ),
     /**
      * Read a resource by URI
      */
@@ -1712,13 +1770,12 @@ var McpTestClient = class {
     /**
      * List all available prompts
      */
-    list: async () => {
-      const response = await this.listPrompts();
-      if (!response.success || !response.data) {
-        throw new Error(`Failed to list prompts: ${response.error?.message}`);
-      }
-      return response.data.prompts;
-    },
+    list: async () => this.listAllPages(
+      "prompts/list",
+      "prompts",
+      (cursor) => this.listPrompts(cursor),
+      (page) => page.prompts
+    ),
     /**
      * Get a prompt with arguments
      */
@@ -2102,8 +2159,33 @@ var McpTestClient = class {
       clientInfo: this.config.clientInfo
     });
   }
-  async listTools() {
-    return this.request("tools/list", {});
+  async listTools(cursor) {
+    return this.request("tools/list", cursor ? { cursor } : {});
+  }
+  /**
+   * Follow `nextCursor` until the server stops returning one, concatenating the
+   * pages. A server that hands back a cursor it already returned, or never stops
+   * paging, fails the call rather than looping.
+   */
+  async listAllPages(method, label, fetchPage, itemsOf) {
+    const items = [];
+    const seenCursors = /* @__PURE__ */ new Set();
+    let cursor;
+    for (let page = 0; page < MAX_LIST_PAGES; page++) {
+      const response = await fetchPage(cursor);
+      if (!response.success || !response.data) {
+        throw new Error(`Failed to list ${label}: ${response.error?.message}`);
+      }
+      items.push(...itemsOf(response.data) ?? []);
+      const next = response.data.nextCursor;
+      if (!next) return items;
+      if (seenCursors.has(next)) {
+        throw new Error(`Failed to list ${label}: ${method} returned the cursor "${next}" twice`);
+      }
+      seenCursors.add(next);
+      cursor = next;
+    }
+    throw new Error(`Failed to list ${label}: ${method} did not finish within ${MAX_LIST_PAGES} pages`);
   }
   async callTool(name, args, progressToken) {
     return this.request("tools/call", {
@@ -2128,17 +2210,17 @@ var McpTestClient = class {
       timestamp
     });
   };
-  async listResources() {
-    return this.request("resources/list", {});
+  async listResources(cursor) {
+    return this.request("resources/list", cursor ? { cursor } : {});
   }
-  async listResourceTemplates() {
-    return this.request("resources/templates/list", {});
+  async listResourceTemplates(cursor) {
+    return this.request("resources/templates/list", cursor ? { cursor } : {});
   }
   async readResource(uri) {
     return this.request("resources/read", { uri });
   }
-  async listPrompts() {
-    return this.request("prompts/list", {});
+  async listPrompts(cursor) {
+    return this.request("prompts/list", cursor ? { cursor } : {});
   }
   async getPrompt(name, args) {
     return this.request("prompts/get", {
@@ -2215,10 +2297,11 @@ var McpTestClient = class {
         requestId: id
       };
     } catch (err) {
+      if (isInterceptedError(err)) throw err;
       const durationMs = Date.now() - start;
       const error = {
         code: -32603,
-        message: err instanceof Error ? err.message : "Unknown error"
+        message: errorMessage(err)
       };
       return {
         success: false,
@@ -2366,12 +2449,12 @@ var McpTestClient = class {
       const payload = this.decodeJwtPayload(token);
       if (!payload) return [];
       const scope = payload["scope"];
-      const scopes = payload["scopes"];
+      const scopes2 = payload["scopes"];
       if (typeof scope === "string") {
         return scope.split(" ");
       }
-      if (Array.isArray(scopes)) {
-        return scopes;
+      if (Array.isArray(scopes2)) {
+        return scopes2;
       }
       return [];
     } catch {
@@ -2446,7 +2529,7 @@ var ProgressCollector = class {
 };
 
 // libs/testing/src/server/test-server.ts
-import { spawn } from "child_process";
+import { execFile, spawn } from "child_process";
 import { sha256Hex } from "@frontmcp/utils";
 
 // libs/testing/src/errors/index.ts
@@ -2517,6 +2600,8 @@ var E2E_PORT_RANGES = {
   "demo-e2e-distributed": { start: 50440, size: 20 },
   // Protocol revision E2E tests (50460-50479)
   "demo-e2e-protocol-20260728": { start: 50460, size: 20 },
+  // Testing library E2E tests (50480-50499)
+  "demo-e2e-testing": { start: 50480, size: 20 },
   // Mock servers and utilities (50900-50999)
   "mock-oauth": { start: 50900, size: 10 },
   "mock-api": { start: 50910, size: 10 },
@@ -2525,6 +2610,66 @@ var E2E_PORT_RANGES = {
   default: { start: 51e3, size: 100 }
 };
 var reservedPorts = /* @__PURE__ */ new Map();
+var lockedPorts = /* @__PURE__ */ new Set();
+var LOCK_MAX_AGE_MS = 10 * 60 * 1e3;
+function lockDir() {
+  try {
+    const os = __require("node:os");
+    const path = __require("node:path");
+    return path.join(os.tmpdir(), "frontmcp-testing-ports");
+  } catch {
+    return void 0;
+  }
+}
+function pidIsAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+}
+function acquirePortLock(port) {
+  if (lockedPorts.has(port)) return false;
+  let fs;
+  let file;
+  try {
+    fs = __require("node:fs");
+    const dir = lockDir();
+    if (!dir) return true;
+    fs.mkdirSync(dir, { recursive: true });
+    file = __require("node:path").join(dir, `${port}.lock`);
+  } catch {
+    return true;
+  }
+  const payload = JSON.stringify({ pid: process.pid, at: Date.now() });
+  for (let attempt = 0; attempt < 2; attempt++) {
+    try {
+      fs.writeFileSync(file, payload, { flag: "wx" });
+      lockedPorts.add(port);
+      return true;
+    } catch (error) {
+      if (error.code !== "EEXIST") return true;
+      try {
+        const held = JSON.parse(fs.readFileSync(file, "utf8"));
+        const fresh = typeof held.at === "number" && Date.now() - held.at < LOCK_MAX_AGE_MS;
+        if (fresh && typeof held.pid === "number" && pidIsAlive(held.pid)) return false;
+        fs.unlinkSync(file);
+      } catch {
+      }
+    }
+  }
+  return false;
+}
+function releasePortLock(port) {
+  if (!lockedPorts.delete(port)) return;
+  try {
+    const fs = __require("node:fs");
+    const dir = lockDir();
+    if (dir) fs.unlinkSync(__require("node:path").join(dir, `${port}.lock`));
+  } catch {
+  }
+}
 var projectPortIndex = /* @__PURE__ */ new Map();
 function getPortRange(project) {
   const key = project;
@@ -2535,15 +2680,22 @@ function getPortRange(project) {
 }
 async function reservePort(project, preferredPort) {
   const range = getPortRange(project);
-  if (preferredPort !== void 0) {
+  const handle = (port) => ({
+    port,
+    // Frees the socket only, so the server about to be spawned can bind the port; the lock file stays
+    releaseSocket: async () => {
+      await releasePort(port);
+    },
+    release: async () => {
+      await releasePort(port);
+      releasePortLock(port);
+    }
+  });
+  const wantsSpecificPort = preferredPort !== void 0 && Number.isInteger(preferredPort) && preferredPort > 0;
+  if (wantsSpecificPort) {
     const reservation = await tryReservePort(preferredPort, project);
     if (reservation) {
-      return {
-        port: preferredPort,
-        release: async () => {
-          await releasePort(preferredPort);
-        }
-      };
+      return handle(preferredPort);
     }
     console.warn(`[PortRegistry] Preferred port ${preferredPort} not available for ${project}, allocating from range`);
   }
@@ -2552,30 +2704,19 @@ async function reservePort(project, preferredPort) {
   for (let attempt = 0; attempt < maxAttempts; attempt++) {
     const port = range.start + index % range.size;
     index = (index + 1) % range.size;
-    if (reservedPorts.has(port)) {
+    if (reservedPorts.has(port) || lockedPorts.has(port)) {
       continue;
     }
     const reservation = await tryReservePort(port, project);
     if (reservation) {
       projectPortIndex.set(project, index);
-      return {
-        port,
-        release: async () => {
-          await releasePort(port);
-        }
-      };
+      return handle(port);
     }
   }
-  const dynamicPort = await findAvailablePortInRange(51e3, 52e3);
-  if (dynamicPort) {
-    const reservation = await tryReservePort(dynamicPort, project);
-    if (reservation) {
-      return {
-        port: dynamicPort,
-        release: async () => {
-          await releasePort(dynamicPort);
-        }
-      };
+  for (let port = 51e3; port < 52e3; port++) {
+    if (reservedPorts.has(port) || lockedPorts.has(port)) continue;
+    if (await tryReservePort(port, project)) {
+      return handle(port);
     }
   }
   throw new Error(
@@ -2583,9 +2724,13 @@ async function reservePort(project, preferredPort) {
   );
 }
 async function tryReservePort(port, project) {
+  if (!acquirePortLock(port)) {
+    return false;
+  }
   return new Promise((resolve) => {
     const server = createServer();
     server.once("error", () => {
+      releasePortLock(port);
       resolve(false);
     });
     server.listen(port, () => {
@@ -2611,31 +2756,6 @@ async function releasePort(port) {
     });
   });
 }
-async function findAvailablePortInRange(start, end) {
-  for (let port = start; port < end; port++) {
-    if (reservedPorts.has(port)) {
-      continue;
-    }
-    const available = await isPortAvailable(port);
-    if (available) {
-      return port;
-    }
-  }
-  return null;
-}
-async function isPortAvailable(port) {
-  return new Promise((resolve) => {
-    const server = createServer();
-    server.once("error", () => {
-      resolve(false);
-    });
-    server.listen(port, () => {
-      server.close(() => {
-        resolve(true);
-      });
-    });
-  });
-}
 
 // libs/testing/src/server/test-server.ts
 var DEBUG_SERVER = process.env["DEBUG_SERVER"] === "1" || process.env["DEBUG"] === "1";
@@ -2644,8 +2764,11 @@ var TestServer = class _TestServer {
   options;
   _info;
   logs = [];
+  /** Frees the port reservation (socket and cross-process lock); held until stop() */
   portRelease = null;
-  constructor(options, port, portRelease) {
+  /** Frees only the reservation socket, just before the server is spawned */
+  portReleaseSocket = null;
+  constructor(options, port, portRelease, portReleaseSocket) {
     this.options = {
       port,
       project: options.project,
@@ -2657,6 +2780,7 @@ var TestServer = class _TestServer {
       debug: options.debug ?? DEBUG_SERVER
     };
     this.portRelease = portRelease ?? null;
+    this.portReleaseSocket = portReleaseSocket ?? portRelease ?? null;
     this._info = {
       baseUrl: `http://localhost:${port}`,
       port
@@ -2669,8 +2793,8 @@ var TestServer = class _TestServer {
     const project = options.project ?? "default";
     const maxAttempts = 3;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      const { port, release } = await reservePort(project, options.port);
-      const server = new _TestServer(options, port, release);
+      const { port, release, releaseSocket } = await reservePort(project, options.port);
+      const server = new _TestServer(options, port, release, releaseSocket);
       try {
         await server.startProcess();
         return server;
@@ -2710,7 +2834,7 @@ var TestServer = class _TestServer {
     }
     const maxAttempts = 3;
     for (let attempt = 1; attempt <= maxAttempts; attempt++) {
-      const { port, release } = await reservePort(project, options.port);
+      const { port, release, releaseSocket } = await reservePort(project, options.port);
       const serverOptions = {
         ...options,
         port,
@@ -2718,7 +2842,7 @@ var TestServer = class _TestServer {
         command: `npx nx serve ${project} --port ${port}`,
         cwd: options.cwd ?? process.cwd()
       };
-      const server = new _TestServer(serverOptions, port, release);
+      const server = new _TestServer(serverOptions, port, release, releaseSocket);
       try {
         await server.startProcess();
         return server;
@@ -2776,10 +2900,17 @@ var TestServer = class _TestServer {
    * Stop the test server
    */
   async stop() {
-    if (this.portRelease) {
-      await this.portRelease();
-      this.portRelease = null;
+    try {
+      await this.stopProcess();
+    } finally {
+      if (this.portRelease) {
+        await this.portRelease();
+        this.portRelease = null;
+      }
+      this.portReleaseSocket = null;
     }
+  }
+  async stopProcess() {
     if (this.process) {
       this.log("Stopping server...");
       if (this.process.exitCode !== null || this.process.signalCode !== null) {
@@ -2852,7 +2983,7 @@ var TestServer = class _TestServer {
    * Restart the server
    */
   async restart() {
-    await this.stop();
+    await this.stopProcess();
     await this.startProcess();
   }
   /**
@@ -2882,9 +3013,9 @@ var TestServer = class _TestServer {
       PORT: String(this.options.port)
     };
     const runtimeEnv = withWorkspaceProtocolFallback(env, this.options.cwd);
-    if (this.portRelease) {
-      await this.portRelease();
-      this.portRelease = null;
+    if (this.portReleaseSocket) {
+      await this.portReleaseSocket();
+      this.portReleaseSocket = null;
       await sleep2(300);
     }
     this.process = spawn(this.options.command, [], {
@@ -2894,9 +3025,8 @@ var TestServer = class _TestServer {
       detached: true,
       stdio: ["pipe", "pipe", "pipe"]
     });
-    if (this.process.pid !== void 0) {
-      this._info.pid = this.process.pid;
-    }
+    this._info.pid = this.process.pid;
+    this._info.shellPid = this.process.pid;
     let processExited = false;
     let exitCode = null;
     let exitError = null;
@@ -2999,6 +3129,8 @@ ${allLogs}`);
         });
         if (response.ok || response.status === 404) {
           this.log(`Server is ready after ${healthCheckAttempts} health check attempts`);
+          const listeningPid = await findListeningPid(this.options.port);
+          if (listeningPid !== void 0) this._info.pid = listeningPid;
           return;
         }
         lastHealthCheckError = `HTTP ${response.status}: ${response.statusText}`;
@@ -3043,6 +3175,19 @@ TIP: Set DEBUG_SERVER=1 or DEBUG=1 environment variable for verbose output`
 function sleep2(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
+function findListeningPid(port) {
+  if (process.platform === "win32") return Promise.resolve(void 0);
+  return new Promise((resolve) => {
+    execFile("lsof", ["-nP", `-iTCP:${port}`, "-sTCP:LISTEN", "-t"], { timeout: 2e3 }, (error, stdout) => {
+      if (error) {
+        resolve(void 0);
+        return;
+      }
+      const pid = parseInt(String(stdout).split("\n")[0] ?? "", 10);
+      resolve(Number.isInteger(pid) && pid > 0 ? pid : void 0);
+    });
+  });
+}
 function withWorkspaceProtocolFallback(env, cwd) {
   if (findInstalledProtocolPackageDir(cwd)) {
     return env;
@@ -3159,81 +3304,152 @@ function gatewayTokenBinding(serverUrl, entryPath) {
 }
 
 // libs/testing/src/fixtures/test-fixture.ts
-var describe = _describe;
-var beforeAll = _beforeAll;
-var beforeEach = _beforeEach;
-var afterEach = _afterEach;
-var afterAll = _afterAll;
-var it = _it;
-var currentConfig = {};
-var serverInstance = null;
-var tokenFactory = null;
-var serverStartedByUs = false;
-var skipScopes = [{ skipped: false }];
-function currentSkipScope() {
-  return skipScopes[skipScopes.length - 1];
+var jestApi;
+function jestGlobals() {
+  if (jestApi) return jestApi;
+  try {
+    const api = __require("@jest/globals");
+    jestApi = {
+      describe: api["describe"],
+      beforeAll: api["beforeAll"],
+      beforeEach: api["beforeEach"],
+      afterEach: api["afterEach"],
+      afterAll: api["afterAll"],
+      it: api["it"]
+    };
+    return jestApi;
+  } catch (error) {
+    throw new Error(
+      `@frontmcp/testing fixtures ("test", "test.use", ...) can only be used inside a Jest test file: ${error instanceof Error ? error.message : String(error)}`,
+      { cause: error }
+    );
+  }
 }
-async function initializeSharedResources() {
-  if (!serverInstance) {
-    if (currentConfig.baseUrl && !currentConfig.server) {
-      serverInstance = TestServer.connect(currentConfig.baseUrl);
-      serverStartedByUs = false;
-    } else if (currentConfig.server) {
-      const serverCommand = resolveServerCommand(currentConfig.server);
-      const isDebug = currentConfig.logLevel === "debug" || process.env["DEBUG"] === "1" || process.env["DEBUG_SERVER"] === "1";
+var scopes = [{ skipped: false, config: {}, configured: false, cleanupRegistered: false }];
+function currentScope() {
+  return scopes[scopes.length - 1];
+}
+var serverEntries = /* @__PURE__ */ new Map();
+function resolveConfig(chain) {
+  const merged = {};
+  for (const scope of chain) {
+    const { env, ...rest } = scope.config;
+    Object.assign(merged, rest);
+    if (env) merged.env = { ...merged.env, ...env };
+  }
+  return merged;
+}
+function ownerScopeOf(chain) {
+  for (let i = chain.length - 1; i > 0; i--) {
+    if (chain[i].configured) return chain[i];
+  }
+  return chain[0];
+}
+function serverKey(config) {
+  const env = Object.fromEntries(Object.entries(config.env ?? {}).sort(([a], [b]) => a.localeCompare(b)));
+  return JSON.stringify({
+    server: config.server,
+    baseUrl: config.baseUrl,
+    project: config.project,
+    port: config.port,
+    entryPath: config.entryPath,
+    startupTimeout: config.startupTimeout,
+    logLevel: config.logLevel,
+    auth: config.auth,
+    env
+  });
+}
+function serverEnv(config) {
+  const extra = {};
+  if (config.auth?.mode) extra["FRONTMCP_TEST_AUTH_MODE"] = config.auth.mode;
+  if (config.auth?.type) extra["FRONTMCP_TEST_AUTH_TYPE"] = config.auth.type;
+  if (Object.keys(extra).length === 0 && !config.env) return void 0;
+  return { ...extra, ...config.env };
+}
+async function startServerEntry(config, owner) {
+  let server;
+  let startedByUs = false;
+  if (config.baseUrl && !config.server) {
+    server = TestServer.connect(config.baseUrl);
+  } else if (config.server) {
+    const serverCommand = resolveServerCommand(config.server);
+    const isDebug = config.logLevel === "debug" || process.env["DEBUG"] === "1" || process.env["DEBUG_SERVER"] === "1";
+    if (isDebug) {
+      console.log(`[TestFixture] Starting server: ${serverCommand}`);
+    }
+    try {
+      server = await TestServer.start({
+        project: config.project,
+        port: config.port,
+        command: serverCommand,
+        env: serverEnv(config),
+        startupTimeout: config.startupTimeout ?? 3e4,
+        debug: isDebug
+      });
+      startedByUs = true;
       if (isDebug) {
-        console.log(`[TestFixture] Starting server: ${serverCommand}`);
+        console.log(`[TestFixture] Server started at ${server.info.baseUrl}`);
       }
-      try {
-        serverInstance = await TestServer.start({
-          project: currentConfig.project,
-          port: currentConfig.port,
-          command: serverCommand,
-          env: currentConfig.env,
-          startupTimeout: currentConfig.startupTimeout ?? 3e4,
-          debug: isDebug
-        });
-        serverStartedByUs = true;
-        if (isDebug) {
-          console.log(`[TestFixture] Server started at ${serverInstance.info.baseUrl}`);
-        }
-      } catch (error) {
-        const errMsg = error instanceof Error ? error.message : String(error);
-        throw new Error(
-          `Failed to start test server.
+    } catch (error) {
+      const errMsg = error instanceof Error ? error.message : String(error);
+      throw new Error(
+        `Failed to start test server.
 
-Server entry: ${currentConfig.server}
-Project: ${currentConfig.project ?? "default"}
+Server entry: ${config.server}
+Project: ${config.project ?? "default"}
 Command: ${serverCommand}
 
-Error: ${errMsg}`
-        );
-      }
-    } else {
-      throw new Error(
-        'test.use() requires either "server" (entry file path) or "baseUrl" (for external server) option'
+Error: ${errMsg}`,
+        { cause: error }
       );
     }
+  } else {
+    throw new Error('test.use() requires either "server" (entry file path) or "baseUrl" (for external server) option');
   }
-  if (!tokenFactory) {
-    const sharedSecret = currentConfig.env?.["JWT_SECRET"];
-    const binding = serverInstance ? gatewayTokenBinding(resolveClientBaseUrl(serverInstance), currentConfig.entryPath) : void 0;
-    tokenFactory = new TestTokenFactory(sharedSecret ? { hmacSecret: sharedSecret, ...binding } : {});
-  }
+  const sharedSecret = config.env?.["JWT_SECRET"];
+  const binding = sharedSecret ? gatewayTokenBinding(config.baseUrl ?? server.info.baseUrl, config.entryPath) : void 0;
+  const tokenFactory = new TestTokenFactory(sharedSecret ? { hmacSecret: sharedSecret, ...binding } : {});
+  return { server, startedByUs, tokenFactory, owner };
 }
-async function createTestFixtures() {
-  await initializeSharedResources();
-  if (!serverInstance) {
-    throw new Error("Server instance not initialized");
-  }
-  if (!tokenFactory) {
-    throw new Error("Token factory not initialized");
+function acquireServer(chain) {
+  const config = resolveConfig(chain);
+  const key = serverKey(config);
+  let entry = serverEntries.get(key);
+  if (!entry) {
+    entry = startServerEntry(config, ownerScopeOf(chain));
+    serverEntries.set(key, entry);
+    entry.catch(() => serverEntries.delete(key));
+  }
+  return entry;
+}
+async function stopServers(owner) {
+  for (const [key, pending] of Array.from(serverEntries)) {
+    let entry;
+    try {
+      entry = await pending;
+    } catch {
+      serverEntries.delete(key);
+      continue;
+    }
+    if (owner && entry.owner !== owner) continue;
+    serverEntries.delete(key);
+    if (entry.startedByUs) {
+      await entry.server.stop();
+    }
   }
+}
+var fixtureContexts = /* @__PURE__ */ new WeakMap();
+async function buildFixtures(chain) {
+  const config = resolveConfig(chain);
+  const entry = await acquireServer(chain);
+  const { server, tokenFactory } = entry;
+  const publicMode = config.publicMode ?? config.auth?.mode === "public";
+  const clientConfig = { ...config, publicMode };
   const clientInstance = McpTestClient.create({
-    baseUrl: resolveClientBaseUrl(serverInstance),
-    entryPath: currentConfig.entryPath,
-    transport: currentConfig.transport ?? "streamable-http",
-    publicMode: currentConfig.publicMode
+    baseUrl: resolveClientBaseUrl(server, clientConfig),
+    entryPath: clientConfig.entryPath,
+    transport: clientConfig.transport ?? "streamable-http",
+    publicMode
   }).build();
   try {
     await clientInstance.connect();
@@ -3247,17 +3463,24 @@ async function createTestFixtures() {
       throw err;
     }
   }
-  const auth = createAuthFixture(tokenFactory);
-  const server = createServerFixture(serverInstance);
-  return {
+  const context = { extraClients: [] };
+  const fixtures = {
     mcp: clientInstance,
-    auth,
-    server
+    auth: createAuthFixture(tokenFactory),
+    server: createServerFixture(server, clientConfig, clientInstance, context)
   };
+  fixtureContexts.set(fixtures, context);
+  return fixtures;
+}
+async function createTestFixtures() {
+  return buildFixtures(scopes.slice());
+}
+async function initializeSharedResources() {
+  await acquireServer(scopes.slice());
 }
 async function cleanupTestFixtures(fixtures, testFailed = false) {
-  if (testFailed && serverInstance) {
-    const logs = serverInstance.getLogs();
+  if (testFailed) {
+    const logs = fixtures.server.getLogs();
     if (logs.length > 0) {
       console.error("\n[TestFixture] === Server Logs (test failed) ===");
       const recentLogs = logs.slice(-50);
@@ -3268,20 +3491,21 @@ async function cleanupTestFixtures(fixtures, testFailed = false) {
       console.error("[TestFixture] === End Server Logs ===\n");
     }
   }
+  const extras = fixtureContexts.get(fixtures)?.extraClients ?? [];
+  for (const client of extras) {
+    if (client.isConnected()) {
+      await client.disconnect().catch(() => void 0);
+    }
+  }
   if (fixtures.mcp.isConnected()) {
     await fixtures.mcp.disconnect();
   }
 }
 async function cleanupSharedResources() {
-  if (serverInstance && serverStartedByUs) {
-    await serverInstance.stop();
-  }
-  serverInstance = null;
-  tokenFactory = null;
-  serverStartedByUs = false;
+  await stopServers();
 }
-function resolveClientBaseUrl(server) {
-  return currentConfig.baseUrl ?? server.info.baseUrl;
+function resolveClientBaseUrl(server, config) {
+  return config.baseUrl ?? server.info.baseUrl;
 }
 function createAuthFixture(factory) {
   const users = {
@@ -3327,28 +3551,39 @@ function createAuthFixture(factory) {
     getAudience: () => factory.getAudience()
   };
 }
-function createServerFixture(server) {
+function createServerFixture(server, config, mcp, context) {
   return {
-    info: server.info,
+    // Live view: `pid` is filled in once the server is listening and follows restarts
+    get info() {
+      return server.info;
+    },
     createClient: async (opts) => {
-      return McpTestClient.create({
-        baseUrl: resolveClientBaseUrl(server),
-        entryPath: opts?.entryPath ?? currentConfig.entryPath,
+      const client = await McpTestClient.create({
+        baseUrl: resolveClientBaseUrl(server, config),
+        entryPath: opts?.entryPath ?? config.entryPath,
         transport: opts?.transport ?? "streamable-http",
         auth: opts?.token ? { token: opts.token } : void 0,
         clientInfo: opts?.clientInfo,
-        publicMode: currentConfig.publicMode
+        publicMode: config.publicMode
       }).buildAndConnect();
+      context.extraClients.push(client);
+      return client;
     },
     createClientBuilder: () => {
       const builder = new McpTestClientBuilder({
-        baseUrl: resolveClientBaseUrl(server),
-        entryPath: currentConfig.entryPath,
-        publicMode: currentConfig.publicMode
+        baseUrl: resolveClientBaseUrl(server, config),
+        entryPath: config.entryPath,
+        publicMode: config.publicMode
       });
       return builder;
     },
-    restart: () => server.restart(),
+    restart: async () => {
+      const reconnect = [mcp, ...context.extraClients].filter((client) => client.isConnected());
+      await server.restart();
+      for (const client of reconnect) {
+        await client.reconnect();
+      }
+    },
     getLogs: () => server.getLogs(),
     clearLogs: () => server.clearLogs()
   };
@@ -3359,12 +3594,12 @@ function resolveServerCommand(server) {
   }
   return `npx tsx ${server}`;
 }
-function runWithFixtures(fn) {
-  return async () => {
-    const fixtures = await createTestFixtures();
+function runWithFixtures(fn, chain) {
+  return async (...extra) => {
+    const fixtures = await buildFixtures(chain);
     let testFailed = false;
     try {
-      await fn(fixtures);
+      await fn(fixtures, ...extra);
     } catch (error) {
       testFailed = true;
       throw error;
@@ -3373,24 +3608,37 @@ function runWithFixtures(fn) {
     }
   };
 }
+function skipTitle(name, scope) {
+  return scope.reason ? `${name} (skipped: ${scope.reason})` : name;
+}
 function testWithFixtures(name, fn) {
-  const scope = currentSkipScope();
+  const chain = scopes.slice();
+  const scope = currentScope();
   if (scope.skipped) {
-    it.skip(scope.reason ? `${name} (skipped: ${scope.reason})` : name, runWithFixtures(fn));
+    jestGlobals().it.skip(skipTitle(name, scope), runWithFixtures(fn, chain));
     return;
   }
-  it(name, runWithFixtures(fn));
+  jestGlobals().it(name, runWithFixtures(fn, chain));
 }
 function use(config) {
-  currentConfig = { ...currentConfig, ...config };
-  afterAll(async () => {
-    await cleanupSharedResources();
-  });
+  const scope = currentScope();
+  scope.config = {
+    ...scope.config,
+    ...config,
+    env: config.env ? { ...scope.config.env, ...config.env } : scope.config.env
+  };
+  scope.configured = true;
+  if (!scope.cleanupRegistered) {
+    scope.cleanupRegistered = true;
+    jestGlobals().afterAll(async () => {
+      await stopServers(scope === scopes[0] ? void 0 : scope);
+    });
+  }
 }
 function skip(nameOrCondition, fnOrReason) {
   if (typeof nameOrCondition === "boolean") {
     if (nameOrCondition) {
-      const scope = currentSkipScope();
+      const scope = currentScope();
       scope.skipped = true;
       scope.reason = typeof fnOrReason === "string" ? fnOrReason : void 0;
     }
@@ -3401,53 +3649,90 @@ function skip(nameOrCondition, fnOrReason) {
       `test.skip expects either (name: string, fn) or (condition: boolean, reason?: string); received (${typeof nameOrCondition}, ${typeof fnOrReason}).`
     );
   }
-  it.skip(nameOrCondition, runWithFixtures(fnOrReason));
+  jestGlobals().it.skip(nameOrCondition, runWithFixtures(fnOrReason, scopes.slice()));
 }
 function only(name, fn) {
-  const scope = currentSkipScope();
+  const scope = currentScope();
   if (scope.skipped) {
-    it.skip(scope.reason ? `${name} (skipped: ${scope.reason})` : name, runWithFixtures(fn));
+    jestGlobals().it.skip(skipTitle(name, scope), runWithFixtures(fn, scopes.slice()));
     return;
   }
-  it.only(name, runWithFixtures(fn));
+  jestGlobals().it.only(name, runWithFixtures(fn, scopes.slice()));
 }
 function todo(name) {
-  it.todo(name);
+  jestGlobals().it.todo(name);
 }
-function withSkipScope(register) {
+function each(table, ...tagged) {
+  const chain = scopes.slice();
+  const register = jestGlobals().it.each(table, ...tagged);
   return (name, fn) => {
-    register(name, () => {
-      const parent = currentSkipScope();
-      skipScopes.push({ skipped: parent.skipped, reason: parent.reason });
-      try {
-        fn();
-      } finally {
-        skipScopes.pop();
-      }
+    const scope = currentScope();
+    if (scope.skipped) {
+      const skipRegister = jestGlobals().it.skip.each(table, ...tagged);
+      skipRegister(skipTitle(name, scope), runWithFixtures(fn, chain));
+      return;
+    }
+    register(name, runWithFixtures(fn, chain));
+  };
+}
+function withScope(fn) {
+  return (...args) => {
+    const parent = currentScope();
+    scopes.push({
+      skipped: parent.skipped,
+      reason: parent.reason,
+      config: {},
+      configured: false,
+      cleanupRegistered: false
     });
+    try {
+      fn(...args);
+    } finally {
+      scopes.pop();
+    }
   };
 }
-function eachWithSkipScope(each) {
-  return ((...eachArgs) => {
-    const register = each(...eachArgs);
-    return withSkipScope(register);
-  });
+function scopedRegister(pick) {
+  return (name, fn, timeout) => {
+    pick()(name, withScope(fn), timeout);
+  };
 }
-var describeWithSkipScope = Object.assign(withSkipScope(describe), describe, {
-  only: Object.assign(withSkipScope(describe.only), { each: eachWithSkipScope(describe.only.each) }),
-  skip: Object.assign(withSkipScope(describe.skip), { each: eachWithSkipScope(describe.skip.each) }),
-  each: eachWithSkipScope(describe.each)
-});
+function scopedEach(pick) {
+  return (...eachArgs) => (name, fn, timeout) => {
+    const register = pick()(...eachArgs);
+    register(name, withScope(fn), timeout);
+  };
+}
+var describeWithScope = Object.assign(
+  scopedRegister(() => jestGlobals().describe),
+  {
+    // `describe.skip` still evaluates its callback during collection, so it needs a scope too
+    only: Object.assign(
+      scopedRegister(() => jestGlobals().describe.only),
+      {
+        each: scopedEach(() => jestGlobals().describe.only.each)
+      }
+    ),
+    skip: Object.assign(
+      scopedRegister(() => jestGlobals().describe.skip),
+      {
+        each: scopedEach(() => jestGlobals().describe.skip.each)
+      }
+    ),
+    each: scopedEach(() => jestGlobals().describe.each)
+  }
+);
 var test = testWithFixtures;
 test.use = use;
-test.describe = describeWithSkipScope;
-test.beforeAll = beforeAll;
-test.beforeEach = beforeEach;
-test.afterEach = afterEach;
-test.afterAll = afterAll;
+test.describe = describeWithScope;
+test.beforeAll = ((...args) => jestGlobals().beforeAll(...args));
+test.beforeEach = ((...args) => jestGlobals().beforeEach(...args));
+test.afterEach = ((...args) => jestGlobals().afterEach(...args));
+test.afterAll = ((...args) => jestGlobals().afterAll(...args));
 test.skip = skip;
 test.only = only;
 test.todo = todo;
+test.each = each;
 export {
   cleanupSharedResources,
   cleanupTestFixtures,