@mgcrea/mcp-ios-simulator 0.4.0 → 0.4.2

package/README.md

@@ -95,8 +95,8 @@ failure.
 | `IOS_SIMULATOR_ID`                | the only booted simulator          | UDID, name, or `booted`. Two booted and no value is an error that names them. |
 | `IOS_SIMULATOR_ALLOW_WRITES`      | **on**                             | `0` drops the seventeen driving tools from `tools/list`.                      |
 | `IOS_SIMULATOR_LAUNCH_ARGS`       | none                               | Launch arguments applied when `launch` passes none of its own.                |
-| `IOS_SIMULATOR_WDA_PORT`          | `8100`                             | Must match the runner's `USE_PORT`. One port per simulator.                   |
-| `IOS_SIMULATOR_WDA_URL`           | `http://127.0.0.1:<port>`          | Explicit override; rarely needed.                                             |
+| `IOS_SIMULATOR_WDA_PORT`          | `8100`                             | Where `restart_wda` starts looking for a free port; the fallback runner port. |
+| `IOS_SIMULATOR_WDA_URL`           | none                               | Pins every simulator to one runner URL; rarely needed.                        |
 | `IOS_SIMULATOR_MAX_TREE_BYTES`    | `24000`                            | Byte cap on a `ui_tree` payload.                                              |
 | `IOS_SIMULATOR_TIMEOUT_MS`        | `120000`                           | Budget for one `simctl` call; a boot is slow.                                 |
 | `IOS_SIMULATOR_WDA_TIMEOUT_MS`    | `30000`                            | Budget for one WebDriverAgent call.                                           |
@@ -137,6 +137,13 @@ scripts/wda.sh run     # leave this running
 scripts/wda.sh status  # is it answering?
 ```
 
+Several simulators can be driven at once, each with its own runner. The server
+finds a simulator's runner by its port's owner, so no port needs configuring:
+`ios_simulator_restart_wda {"device":"…"}` starts one on the first free port, and
+from a shell `IOS_SIMULATOR_ID=<udid> USE_PORT=8101 scripts/wda.sh run` does the
+same by hand. A call for a simulator whose runner is not up is refused rather
+than sent to another simulator's.
+
 Installed from npm, the same script is the `ios-simulator-wda` binary:
 
 ```bash
@@ -223,8 +230,9 @@ Xcode 27.0 (27A266a) with an iOS 27.0 runtime.
 - **WebDriverAgent scans ports 8100-8199 when `USE_PORT` is unset.** With two
   booted simulators, the second runner comes up healthy on 8101 and a server
   pointed at 8100 drives the _first_ one while every call reports success.
-  `scripts/wda.sh` always pins `USE_PORT`, and `diagnostics` reports the port's
-  real owner via `SIMULATOR_UDID` from `ps -Eww`.
+  `scripts/wda.sh` always pins `USE_PORT`, and every UI call looks up the runner
+  it needs by its owner — `SIMULATOR_UDID` from `ps -Eww` on each listener
+  `lsof` finds in 8100-8199 — rather than trusting a fixed port.
 - **`listapps` returns an old-style NeXTSTEP plist, not JSON.** `--json` is a flag
   on `list` and nothing else.
 - **A status bar override survives a reboot.** Clear it or it quietly pollutes

package/dist/cli.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { N as BUILD_INFO, a as createServer, n as loadConfig, t as defaultConfigPath } from "./config-HmqayUrt.js";
+import { P as BUILD_INFO, a as createServer, n as loadConfig, t as defaultConfigPath } from "./config-BA3aCrX9.js";
 import { ZodError } from "zod";
 import { StdioServerTransport } from "@modelcontextprotocol/server/stdio";
 // src/cli.ts

package/dist/{config-HmqayUrt.js → config-BA3aCrX9.js}

@@ -1,7 +1,7 @@
 import { McpServer } from "@modelcontextprotocol/server";
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
-import { CommandError, CommandTimeoutError, DEFAULT_CRASH_KINDS, IosError, IosError as IosError$1, ToolchainError, WdaClient, WdaError, WdaUnavailableError, assertNoShellMetachars, crashKind, crashProcessName, createArgs, createExec, readLogFile, registerInputTools, registerScreenTools, summarizeCrashReport, wrap } from "@mgcrea/mcp-ios-core";
+import { CommandError, CommandError as CommandError$1, CommandTimeoutError, DEFAULT_CRASH_KINDS, IosError, IosError as IosError$1, ToolchainError, WdaClient, WdaError, WdaUnavailableError, assertNoShellMetachars, crashKind, crashProcessName, createArgs, createExec, readLogFile, registerInputTools, registerScreenTools, summarizeCrashReport, wrap } from "@mgcrea/mcp-ios-core";
 import { mkdir, mkdtemp, open, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { homedir, tmpdir } from "node:os";
 import { z } from "zod";
@@ -23,8 +23,8 @@ const pkg = readPackageJson();
 const BUILD_INFO = {
 	name: pkg.name,
 	version: pkg.version,
-	gitCommit: "5584c7c",
-	gitCommitDate: "2026-10-29T22:11:35+01:00"
+	gitCommit: "07a8b77",
+	gitCommitDate: "2026-11-05T00:19:14+01:00"
 };
 // src/client/errors.ts
 /** Raising the budget, or noticing the simulator died mid-call. */
@@ -55,6 +55,22 @@ const START_RUNNER_TOOL_REMEDY = "Start it with ios_simulator_restart_wda, which
 const startRunnerRemedy = (allowWrites) => allowWrites ? START_RUNNER_TOOL_REMEDY : START_RUNNER_SCRIPT_REMEDY;
 /** What to do when WebDriverAgent does not answer at all. */
 const wdaUnavailableRemedy = (allowWrites) => `${startRunnerRemedy(allowWrites)} Everything except ios_simulator_ui_tree and the input tools works without it — screenshots go through simctl. If something else already forwards the port, set IOS_SIMULATOR_WDA_URL.`;
+/**
+* The target has no runner of its own, and the port this server would fall
+* back to is another simulator's.
+*
+* Refused rather than forwarded, because the failure it prevents does not look
+* like one: the other runner answers healthily, a tap lands on someone else's
+* screen, and the UI tree that comes back describes an app the caller never
+* launched.
+*/
+var RunnerBelongsElsewhereError = class extends IosError {
+	name = "RunnerBelongsElsewhereError";
+	constructor(opts) {
+		const { target, owner, port, freePort, allowWrites } = opts;
+		super(`No WebDriverAgent runner belongs to ${target.name}. Port ${port} is ${owner}'s runner, so a tap or UI tree read sent there would go to that simulator's screen instead.`, { remedy: allowWrites ? `Start one for this simulator with ios_simulator_restart_wda {"device":"${target.id}"} — it picks a free port (${freePort} right now) and this server finds it by itself. Give it about fifteen seconds.` : `Start one for this simulator on a free port: IOS_SIMULATOR_ID=${target.id} USE_PORT=${freePort} scripts/wda.sh run. This server finds it by itself once it answers.` });
+	}
+};
 /** No simulator matched, or several did and none was named. */
 var SimulatorNotFoundError = class extends IosError {
 	name = "SimulatorNotFoundError";
@@ -249,6 +265,105 @@ var LaunchCaptures = class {
 };
 /** True when `path` exists on this Mac. */
 const exists = async (path) => stat(path).then(() => true, () => false);
+// src/client/runners.ts
+/** WebDriverAgent's own scan range when `USE_PORT` is unset (FBConfiguration.m). */
+const WDA_DEFAULT_PORT = 8100;
+/**
+* The ranges worth scanning: WebDriverAgent's default one, and the one this
+* server allocates from when IOS_SIMULATOR_WDA_PORT moves it elsewhere.
+*/
+const runnerRanges = (basePort) => {
+	const ranges = [[WDA_DEFAULT_PORT, 8199]];
+	if (basePort < 8100 || basePort >= 8200) ranges.push([basePort, Math.min(65535, basePort + 100 - 1)]);
+	return ranges;
+};
+/**
+* `lsof -F pn` output: a `p<pid>` line opens each process, then one `n<addr>`
+* line per socket. A runner listening on both stacks shows up twice.
+*/
+const parseLsof = (stdout) => {
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	let pid;
+	for (const line of stdout.split("\n")) if (line.startsWith("p")) {
+		const value = Number(line.slice(1));
+		pid = Number.isInteger(value) ? value : void 0;
+	} else if (line.startsWith("n") && pid !== void 0) {
+		const port = Number(/:(\d+)$/.exec(line)?.[1]);
+		if (!Number.isInteger(port)) continue;
+		const key = `${pid}:${port}`;
+		if (seen.has(key)) continue;
+		seen.add(key);
+		out.push({
+			pid,
+			port
+		});
+	}
+	return out;
+};
+/**
+* `ps -Eww -o pid=,command=` output, one process per line with its environment
+* appended. Every process inside a simulator carries `SIMULATOR_UDID`.
+*/
+const parsePsUdids = (stdout) => {
+	const out = /* @__PURE__ */ new Map();
+	for (const line of stdout.split("\n")) {
+		const pid = Number(/^\s*(\d+)\s/.exec(line)?.[1]);
+		const udid = /SIMULATOR_UDID=([0-9A-Fa-f-]{36})/.exec(line)?.[1];
+		if (Number.isInteger(pid) && udid) out.set(pid, udid);
+	}
+	return out;
+};
+/**
+* Every listener in the runner ranges, each attributed to its simulator.
+*
+* A simulator shares the host's network stack, so a runner's port is a host
+* port and nothing in WebDriverAgent's `/status` names the simulator behind it
+* — the process environment is the only reliable owner. Failure is an empty
+* list rather than an error: lsof exits 1 when nothing matches, and not knowing
+* who owns a port must degrade to the old fixed-port behaviour, not break
+* every UI call.
+*/
+const scanRunners = async (exec, basePort, timeoutMs = 5e3) => {
+	let sockets;
+	try {
+		const args = [
+			"-nP",
+			"-sTCP:LISTEN",
+			"-F",
+			"pn"
+		];
+		for (const [from, to] of runnerRanges(basePort)) args.push(`-iTCP:${from}-${to}`);
+		sockets = parseLsof((await exec("/usr/sbin/lsof", args, timeoutMs)).stdout);
+	} catch {
+		return [];
+	}
+	if (sockets.length === 0) return [];
+	let udids = /* @__PURE__ */ new Map();
+	try {
+		const pids = [...new Set(sockets.map((s) => s.pid))].join(",");
+		udids = parsePsUdids((await exec("/bin/ps", [
+			"-Eww",
+			"-o",
+			"pid=,command=",
+			"-p",
+			pids
+		], timeoutMs)).stdout);
+	} catch {}
+	return sockets.map((s) => {
+		const udid = udids.get(s.pid);
+		return udid ? {
+			...s,
+			udid
+		} : s;
+	}).toSorted((a, b) => a.port - b.port);
+};
+/** The first port from `basePort` up that nothing listens on. */
+const freePort = (listeners, basePort) => {
+	const taken = new Set(listeners.map((l) => l.port));
+	for (let port = basePort; port < basePort + 100 && port <= 65535; port++) if (!taken.has(port)) return port;
+	return basePort;
+};
 // src/client/shape.ts
 /**
 * Flatten the runtime-keyed map `list devices` returns.
@@ -349,6 +464,12 @@ const remedyFor = (stderr) => {
 const assertNotBulkTarget = (udid) => {
 	if (udid === "all" || udid === "unavailable" || udid === "booted") throw new IosError$1(`Refusing to pass "${udid}" to simctl as a device.`, { remedy: "simctl reads these as *every* matching simulator, so `erase all` would wipe the machine. Resolve to one concrete UDID with ios_simulator_list first." });
 };
+/**
+* `io … screenshot` refusing to pick between a multi-display device's screens.
+* Matched on simctl's own words rather than exit 22 alone, which is just
+* EINVAL and covers any malformed argument.
+*/
+const isAmbiguousDisplay = (err) => err instanceof CommandError && /Cannot choose between \d+ displays/.test(`${String(err.details ?? "")}\n${err.message}`);
 var Simctl = class {
 	opts;
 	exec;
@@ -593,19 +714,42 @@ var Simctl = class {
 	*
 	* A successful capture also writes a `Note: No display specified…` line to
 	* stderr, so non-empty stderr is not a failure here.
+	*
+	* A device with two displays — the iPhone Duo, iOS 27.1 runtime — makes the
+	* bare call fail outright: exit 22, "Cannot choose between 2 displays.
+	* Specify one with --display". Only then is it retried on `--display=primary`,
+	* so a single-display simulator and Xcode 26 never see the flag. Primary
+	* rather than whichever is lit, because it is the display WebDriverAgent
+	* addresses when no `currentDisplayId` is set: a capture of the other one
+	* would put every tap read off it in the wrong coordinate space. On an open
+	* Duo that display is black (appium/appium-xcuitest-driver#3012); driving
+	* the inner one means selecting it in WDA too, which nothing here does yet.
+	* The `internal` alias the help text offers fails on the Duo with exit 22.
 	*/
 	async screenshotPng(udid) {
 		assertNotBulkTarget(udid);
 		const dir = await mkdtemp(join(tmpdir(), "simshot-"));
 		const path = join(dir, "shot.png");
 		try {
-			await this.run([
-				"io",
-				udid,
-				"screenshot",
-				"--type=png",
-				path
-			]);
+			try {
+				await this.run([
+					"io",
+					udid,
+					"screenshot",
+					"--type=png",
+					path
+				]);
+			} catch (err) {
+				if (!isAmbiguousDisplay(err)) throw err;
+				await this.run([
+					"io",
+					udid,
+					"screenshot",
+					"--type=png",
+					"--display=primary",
+					path
+				]);
+			}
 			return (await readFile(path)).toString("base64");
 		} finally {
 			await rm(dir, {
@@ -742,6 +886,7 @@ var SimulatorClient = class {
 	wdaClients = /* @__PURE__ */ new Map();
 	/** `simctl list` is ~80ms and most tools want it twice; 2s collapses that. */
 	cache;
+	runnerCache;
 	profiles = /* @__PURE__ */ new Map();
 	constructor(opts) {
 		this.opts = opts;
@@ -900,15 +1045,10 @@ var SimulatorClient = class {
 		return this.simctl.screenshotPng(target.id);
 	}
 	/**
-	* Where WebDriverAgent is.
-	*
-	* Unlike the device lane there is no tunnel address to derive: a simulator
-	* shares the host's network stack, so the runner's port *is* a host loopback
-	* port. That is also the trap — several booted simulators contend for the
-	* same one, and WebDriverAgent scans 8100-8199 when `USE_PORT` is unset, so a
-	* second runner comes up healthy on 8101 and a server pointed at 8100 drives
-	* the first simulator while reporting success. `ios_simulator_diagnostics`
-	* reports which simulator actually owns the port.
+	* Where WebDriverAgent is *configured* to be: IOS_SIMULATOR_WDA_URL, or the
+	* base port on loopback. Which runner a call actually reaches is decided per
+	* simulator by `runnerUrl`; this is only the fallback when nothing better is
+	* known.
 	*/
 	wdaUrl() {
 		return this.opts.wdaUrl ?? `http://127.0.0.1:${this.opts.wdaPort}`;
@@ -917,24 +1057,110 @@ var SimulatorClient = class {
 	get defaultSimulatorId() {
 		return this.opts.defaultSimulatorId;
 	}
+	/** Where runner ports are allocated from, and the fallback when no owner is known. */
 	get wdaPort() {
 		return this.opts.wdaPort;
 	}
-	wda(_target) {
-		const url = this.wdaUrl();
-		const existing = this.wdaClients.get(url);
+	/**
+	* Every listener in the runner ranges, attributed to its simulator. Cached
+	* for 2s: every UI call asks, and lsof plus ps costs tens of milliseconds.
+	*/
+	async listRunners(opts = {}) {
+		const cached = this.runnerCache;
+		if (!opts.fresh && cached && Date.now() - cached.at < 2e3) return cached.listeners;
+		const listeners = await scanRunners(this.exec, this.opts.wdaPort);
+		this.runnerCache = {
+			at: Date.now(),
+			listeners
+		};
+		return listeners;
+	}
+	/** Called once a runner is started, so the next call looks again. */
+	forgetRunners() {
+		this.runnerCache = void 0;
+	}
+	/** The first port nothing listens on, from the base port up. */
+	async freeRunnerPort() {
+		return freePort(await this.listRunners({ fresh: true }), this.opts.wdaPort);
+	}
+	/** The port of this simulator's own runner, when it has one. */
+	async ownRunnerPort(target) {
+		const id = target.id.toLowerCase();
+		return (await this.listRunners({ fresh: true })).find((l) => l.udid?.toLowerCase() === id)?.port;
+	}
+	/**
+	* Which runner a call for this simulator goes to.
+	*
+	* A simulator shares the host's network stack, so every runner is a host
+	* loopback port, and one server process — Bastion runs one for every session
+	* on the Mac — sees all of them. A fixed port therefore meant one simulator
+	* per process, and worse, a second simulator's calls went to the first one's
+	* runner while every tool reported success.
+	*
+	* So the owner is looked up rather than assumed: the simulator's own runner
+	* wherever it listens; failing that the configured URL, *unless* that is
+	* known to be another simulator's, which is refused. Not knowing the owner
+	* (lsof saw nothing) keeps the configured URL, which is the behaviour from
+	* before ownership was checked.
+	*/
+	async runnerUrl(target) {
+		const listeners = await this.listRunners();
+		const id = target.id.toLowerCase();
+		const own = listeners.find((l) => l.udid?.toLowerCase() === id);
+		if (!this.opts.wdaUrl && own) return `http://127.0.0.1:${own.port}`;
+		const configured = this.wdaUrl();
+		const port = loopbackPort(configured);
+		const owner = port === void 0 ? void 0 : listeners.find((l) => l.port === port && l.udid)?.udid;
+		if (owner && owner.toLowerCase() !== id) throw new RunnerBelongsElsewhereError({
+			target,
+			owner: (await this.listSimulators()).find((sim) => sim.id.toLowerCase() === owner.toLowerCase())?.name ?? owner,
+			port,
+			freePort: freePort(listeners, this.opts.wdaPort),
+			allowWrites: this.opts.allowWrites !== false
+		});
+		return configured;
+	}
+	/**
+	* The WebDriverAgent client for one simulator, one per UDID so each keeps its
+	* own session. The URL is resolved on every request, so a runner restarted on
+	* another port is followed without a server restart.
+	*/
+	wda(target) {
+		return this.wdaClient(target.id, () => this.runnerUrl(target));
+	}
+	/** The configured URL, unchecked — for diagnostics with no single target. */
+	wdaConfigured() {
+		return this.wdaClient("", async () => this.wdaUrl());
+	}
+	wdaClient(key, baseUrl) {
+		const existing = this.wdaClients.get(key);
 		if (existing) return existing;
 		const client = new WdaClient({
-			baseUrl: async () => url,
+			baseUrl,
 			timeoutMs: this.opts.wdaTimeoutMs,
 			remedies: simulatorWdaRemedies(this.opts.allowWrites !== false),
 			...this.opts.fetch ? { fetch: this.opts.fetch } : {},
 			...this.opts.logger ? { logger: this.opts.logger } : {}
 		});
-		this.wdaClients.set(url, client);
+		this.wdaClients.set(key, client);
 		return client;
 	}
 };
+/** The port of a loopback URL, or undefined for anything else. */
+const loopbackPort = (url) => {
+	try {
+		const parsed = new URL(url);
+		if (![
+			"127.0.0.1",
+			"localhost",
+			"[::1]"
+		].includes(parsed.hostname)) return void 0;
+		const port = Number(parsed.port || (parsed.protocol === "https:" ? 443 : 80));
+		return Number.isInteger(port) ? port : void 0;
+	} catch {
+		return;
+	}
+};
 // src/tools/util.ts
 /**
 * How the shared tools name themselves and each other in this server.
@@ -1153,40 +1379,6 @@ const registerAppTools = (server, client, launchArgs, outputDir) => {
 };
 // src/tools/diagnostics.ts
 /**
-* Which simulator owns the WebDriverAgent port.
-*
-* This check has no device-server equivalent and it is the most valuable one
-* here. A simulator shares the host's network stack, so a runner's port is a
-* *host* port, and WebDriverAgent scans 8100-8199 when `USE_PORT` is unset. Two
-* booted simulators therefore give you a second runner answering healthily on
-* 8101 while a server pointed at 8100 drives the first one and reports success
-* on every call.
-*
-* Every process inside a simulator carries `SIMULATOR_UDID` in its environment,
-* and `ps -Eww` prints it, so the port's real owner is knowable rather than
-* assumed.
-*/
-const portOwner = async (client, port) => {
-	try {
-		const { stdout: pids } = await client.exec("/usr/sbin/lsof", [
-			"-nP",
-			`-iTCP:${port}`,
-			"-sTCP:LISTEN",
-			"-t"
-		], 5e3);
-		const pid = pids.trim().split("\n")[0];
-		if (!pid) return void 0;
-		const { stdout: env } = await client.exec("/bin/ps", [
-			"-Eww",
-			"-p",
-			pid
-		], 5e3);
-		return /SIMULATOR_UDID=([0-9A-Fa-f-]{36})/.exec(env)?.[1];
-	} catch {
-		return;
-	}
-};
-/**
 * The whole point of this tool is that **it never throws**. Every other tool
 * fails when nothing is booted, the runtime is missing or the runner is not up,
 * and each of those looks much like the others from the outside. This one
@@ -1249,31 +1441,41 @@ const diagnose = async (client, ctx, deviceHint) => {
 	if (target) try {
 		display = await client.display(target);
 	} catch {}
+	const listeners = await client.listRunners({ fresh: true });
+	const names = new Map(simulators.map((sim) => [sim.id.toLowerCase(), sim.name]));
+	const runners = listeners.flatMap((l) => l.udid ? [{
+		udid: l.udid,
+		name: names.get(l.udid.toLowerCase()) ?? l.udid,
+		port: l.port
+	}] : []);
+	let url = client.wdaUrl();
+	let refused = false;
+	if (target) try {
+		url = await client.runnerUrl(target);
+	} catch (err) {
+		refused = true;
+		problems.push(err instanceof Error ? err.message : String(err));
+		const remedy = err.remedy;
+		if (remedy) nextSteps.push(remedy);
+	}
+	const port = portOf(url) ?? client.wdaPort;
 	const wda = {
-		url: client.wdaUrl(),
-		port: client.wdaPort,
-		reachable: false
+		url,
+		port,
+		reachable: false,
+		runners
 	};
-	try {
-		wda.state = await client.wda(target ?? {
-			id: "",
-			name: ""
-		}).status();
+	const owner = listeners.find((l) => l.port === port && l.udid)?.udid;
+	if (owner) wda.boundTo = owner;
+	if (refused) wda.error = "Not probed: the runner on this port belongs to another simulator.";
+	else try {
+		wda.state = await (target ? client.wda(target) : client.wdaConfigured()).status();
 		wda.reachable = true;
 	} catch (err) {
 		wda.error = err instanceof Error ? err.message : String(err);
 		problems.push("WebDriverAgent is not answering, so the UI tree and the input tools will fail.");
 		nextSteps.push((nothingBooted ? "Then, once it is booted: " : "") + startRunnerRemedy(ctx.allowWrites) + " Everything else — including screenshots — works without it.");
 	}
-	if (wda.reachable) {
-		const owner = await portOwner(client, client.wdaPort);
-		if (owner) wda.boundTo = owner;
-		if (owner && target && owner.toLowerCase() !== target.id.toLowerCase()) {
-			const other = simulators.find((sim) => sim.id.toLowerCase() === owner.toLowerCase());
-			problems.push(`Port ${client.wdaPort} is owned by ${other?.name ?? owner}, not ${target.name}. Every tap and every UI tree read would go to the wrong screen.`);
-			nextSteps.push("WebDriverAgent scans 8100-8199 when USE_PORT is unset, so a second simulator's runner takes the next free port and nothing looks wrong. Give this one its own port with IOS_SIMULATOR_WDA_PORT and start its runner with a matching USE_PORT.");
-		}
-	}
 	if (unavailable.length > 0) nextSteps.push(`${unavailable.length} simulators have no installed runtime and cannot be used at all. \`xcrun simctl delete unavailable\` clears them.`);
 	return {
 		ok: problems.length === 0,
@@ -1292,10 +1494,18 @@ const diagnose = async (client, ctx, deviceHint) => {
 		nextSteps
 	};
 };
+const portOf = (url) => {
+	try {
+		const port = Number(new URL(url).port);
+		return port > 0 ? port : void 0;
+	} catch {
+		return;
+	}
+};
 const registerDiagnosticsTools = (server, client, ctx) => {
 	server.registerTool("ios_simulator_diagnostics", {
 		title: "iOS Simulator: Diagnostics",
-		description: "Report both lanes separately and never fail: which simulators exist and which are usable, which one this server would drive, its screen geometry, and whether WebDriverAgent is answering — including *which* simulator owns its port, which is the one way to catch a second runner quietly taking your taps. Start here when anything else misbehaves.",
+		description: "Report both lanes separately and never fail: which simulators exist and which are usable, which one this server would drive, its screen geometry, and whether WebDriverAgent is answering — including every simulator's runner and its port, and which one the target's taps would reach. Start here when anything else misbehaves.",
 		inputSchema: z.object({ device: deviceArg }),
 		annotations: { readOnlyHint: true }
 	}, async ({ device }) => wrap(async () => diagnose(client, ctx, device)));
@@ -1910,10 +2120,10 @@ const runnerBuilt = async () => {
 const registerRunnerTools = (server, client, outputDir, spawnRunner = defaultSpawnRunner) => {
 	server.registerTool("ios_simulator_restart_wda", {
 		title: "iOS Simulator: Restart WebDriverAgent",
-		description: "Start the WebDriverAgent runner, or restart it after it has died. Only the UI tree and the input tools need it — screenshots and everything simctl does keep working without it. The runner is started detached so it outlives this conversation, and its output goes to a log file rather than to you. It does not wait: give it fifteen seconds or so, then check ios_simulator_diagnostics.",
+		description: "Start the WebDriverAgent runner, or restart it after it has died. Only the UI tree and the input tools need it — screenshots and everything simctl does keep working without it. Each simulator gets its own runner on its own port, so several can be driven at once. The runner is started detached so it outlives this conversation, and its output goes to a log file rather than to you. It does not wait: give it fifteen seconds or so, then check ios_simulator_diagnostics.",
 		inputSchema: z.object({
 			device: deviceArg,
-			port: z.number().int().min(1).max(65535).optional().describe("Port to bind, passed to the runner as USE_PORT. Defaults to IOS_SIMULATOR_WDA_PORT. Two simulators need two ports: they share this Mac's loopback, and a runner with no USE_PORT scans 8100-8199 and silently takes the next free one.")
+			port: z.number().int().min(1).max(65535).optional().describe("Port to bind, passed to the runner as USE_PORT. Leave it out: the simulator's current runner port is reused, or else the first free one from IOS_SIMULATOR_WDA_PORT up, and the other tools find the runner wherever it listens.")
 		}),
 		annotations: {
 			readOnlyHint: false,
@@ -1922,7 +2132,7 @@ const registerRunnerTools = (server, client, outputDir, spawnRunner = defaultSpa
 		}
 	}, async ({ device, port }) => wrap(async () => {
 		const target = client.requireBooted(await client.resolveTarget(device));
-		const usePort = port ?? client.wdaPort;
+		const usePort = port ?? await client.ownRunnerPort(target) ?? await client.freeRunnerPort();
 		const { built, products } = await runnerBuilt();
 		if (!built) throw new IosError$1(`No WebDriverAgent build in ${products}, so there is nothing to start.`, { remedy: "Build it once with `scripts/wda.sh setup` (or `npx -p @mgcrea/mcp-ios-simulator ios-simulator-wda setup` from an npm install), then call ios_simulator_restart_wda again." });
 		const logPath = join(outputDir, "wda.log");
@@ -1936,6 +2146,7 @@ const registerRunnerTools = (server, client, outputDir, spawnRunner = defaultSpa
 			},
 			logPath
 		});
+		client.forgetRunners();
 		if (pid === void 0) throw new IosError$1("Could not start the runner — the process had no pid.", { remedy: START_RUNNER_SCRIPT_REMEDY });
 		return {
 			started: true,
@@ -2165,6 +2376,6 @@ const loadConfig = (env = process.env, configPath = defaultConfigPath(env)) => {
 		openPath: pick(trimmed(env.IOS_SIMULATOR_OPEN_PATH), "openPath")
 	});
 };
-export { WritesDisabledError as A, SimulatorNotBootedError as C, ToolchainError as D, TOOLCHAIN_REMEDY as E, wdaUnavailableRemedy as M, BUILD_INFO as N, WdaError as O, START_RUNNER_TOOL_REMEDY as S, TIMEOUT_REMEDY as T, CommandTimeoutError as _, createServer as a, RuntimeUnavailableError as b, assertNotBulkTarget as c, summarizeDevices as d, toListRow as f, CommandError as g, toDisplayInfo as h, SERVER_VERSION as i, startRunnerRemedy as j, WdaUnavailableError as k, parseSimctlError as l, readScreenProfile as m, loadConfig as n, SimulatorClient as o, pngDimensions as p, SERVER_NAME as r, Simctl as s, defaultConfigPath as t, summarizeApps as u, EMPTY_SCREENSHOT_REMEDY as v, SimulatorNotFoundError as w, START_RUNNER_SCRIPT_REMEDY as x, IosError$1 as y };
+export { WdaUnavailableError as A, START_RUNNER_TOOL_REMEDY as C, TOOLCHAIN_REMEDY as D, TIMEOUT_REMEDY as E, startRunnerRemedy as M, wdaUnavailableRemedy as N, ToolchainError as O, BUILD_INFO as P, START_RUNNER_SCRIPT_REMEDY as S, SimulatorNotFoundError as T, CommandTimeoutError as _, createServer as a, RunnerBelongsElsewhereError as b, assertNotBulkTarget as c, summarizeDevices as d, toListRow as f, CommandError$1 as g, toDisplayInfo as h, SERVER_VERSION as i, WritesDisabledError as j, WdaError as k, parseSimctlError as l, readScreenProfile as m, loadConfig as n, SimulatorClient as o, pngDimensions as p, SERVER_NAME as r, Simctl as s, defaultConfigPath as t, summarizeApps as u, EMPTY_SCREENSHOT_REMEDY as v, SimulatorNotBootedError as w, RuntimeUnavailableError as x, IosError$1 as y };
 
-//# sourceMappingURL=config-HmqayUrt.js.map
+//# sourceMappingURL=config-BA3aCrX9.js.map