@mgcrea/mcp-ios-simulator 0.2.2 → 0.4.0

package/dist/index.d.ts

@@ -1,7 +1,53 @@
 import { McpServer } from "@modelcontextprotocol/server";
 import { CommandError, CommandTimeoutError, DisplayInfo, ExecImpl, IosError, IosError as IosError$1, Logger, ScreenHost, ToolchainError, WdaClient, WdaError, WdaUnavailableError } from "@mgcrea/mcp-ios-core";
 import { z } from "zod";
-//#region src/client/simctl.d.ts
+/**
+ * The log captures this server has started, newest per simulator and app.
+ *
+ * Much less machinery than the device server's `ConsoleCaptures`, because on a
+ * simulator nothing has to stay attached. `simctl launch --stdout/--stderr`
+ * hands the redirect to the simulator's launchd and returns as soon as the app
+ * is spawned; the app then writes its own file for as long as it runs. So there
+ * is no child process to watch, to keep out of this server's signal group, or
+ * to kill on exit — a capture is a path and a pid, and it outlives this server
+ * without leaking anything.
+ *
+ * Whether it is still running is a question about the app's process, which on a
+ * simulator is an ordinary process on this Mac: measured on an iOS 27.0
+ * runtime, the pid `simctl launch` prints is a host pid owned by the user, and
+ * `kill(pid, 0)` answers for it like for any other.
+ */
+type Capture = {
+  udid: string;
+  simulatorName: string;
+  bundleId: string;
+  /** Where the file actually is on this Mac, which is not always where it was asked for. */
+  path: string;
+  pid: number | undefined;
+  startedAt: string;
+};
+/** The liveness probe, as a seam: tests cannot rely on whichever pid is free on the machine. */
+type ProcessAlive = (pid: number) => boolean;
+declare class LaunchCaptures {
+  private readonly alive;
+  private readonly captures;
+  private latest;
+  constructor(alive?: ProcessAlive);
+  private key;
+  /**
+   * One capture per simulator and app. A relaunch replaces the record rather
+   * than adding a second, so a read never has to choose between two files of
+   * the same app — the older file stays on disk, it is just no longer "the" log.
+   */
+  record(capture: Capture): void;
+  find(udid: string | undefined, bundleId: string | undefined): Capture | undefined;
+  /**
+   * Whether the app is still writing. A pid can be reused once the app exits,
+   * and that is accepted: the cost of a false "running" is only that a final
+   * half-written line waits for the next read.
+   */
+  running(capture: Capture): boolean;
+}
 /**
  * `xcrun simctl` — Apple's own simulator tool, and the half of this server that
  * needs nothing installed and nothing signed.
@@ -23,6 +69,8 @@ import { z } from "zod";
 type SimctlOptions = {
   xcrunPath: string;
   plutilPath: string;
+  /** Only `launch` with environment variables goes through it; see there. */
+  envPath: string;
   timeoutMs: number;
   exec?: ExecImpl | undefined;
   logger?: Logger | undefined;
@@ -35,6 +83,8 @@ type RawSim = {
   availabilityError?: string;
   deviceTypeIdentifier?: string;
   lastBootedAt?: string;
+  /** The simulator's own filesystem root on this Mac; see `locateRedirect`. */
+  dataPath?: string;
 };
 type RawRuntime = {
   identifier: string;
@@ -69,7 +119,7 @@ type RawSimApp = {
  * Without this the message a caller sees is the first line, which names a
  * numeric code and says nothing about what to do.
  */
-declare const parseSimctlError: (stderr: string) => {
+export declare const parseSimctlError: (stderr: string) => {
   domain?: string;
   code?: number;
   message: string;
@@ -83,12 +133,18 @@ declare const parseSimctlError: (stderr: string) => {
  * forward, so it is refused here as well as in the resolver — the resolver is
  * where it should be caught, and this is where it cannot be missed.
  */
-declare const assertNotBulkTarget: (udid: string) => void;
-declare class Simctl {
+export declare const assertNotBulkTarget: (udid: string) => void;
+export declare class Simctl {
   private readonly opts;
   private readonly exec;
   /** Device types change only when Xcode is updated; re-reading is pure cost. */
   private deviceTypes;
+  /**
+   * Read once, like device types: both change only when Xcode or a runtime is
+   * installed, and every tool call resolves a simulator. The cost is that a
+   * runtime added or deleted while this server runs is seen after a restart.
+   */
+  private runtimes;
   constructor(opts: SimctlOptions);
   /** Raw stdout, for the subcommands that answer in prose. */
   private run;
@@ -112,6 +168,13 @@ declare class Simctl {
   listRuntimes(): Promise<RawRuntime[]>;
   listDeviceTypes(): Promise<RawDeviceType[]>;
   boot(udid: string): Promise<void>;
+  /**
+   * Wait until a booting simulator has finished, or `timeoutMs` passes (a
+   * `CommandTimeoutError`). Not the state in `list`: measured on an iOS 27.0
+   * runtime, that reads "Booted" 0.4s after `boot` returns, while this returns
+   * 17s later, once the system is up.
+   */
+  bootstatus(udid: string, timeoutMs: number): Promise<void>;
   shutdown(udid: string): Promise<void>;
   erase(udid: string): Promise<void>;
   /**
@@ -145,16 +208,32 @@ declare class Simctl {
    * Launch, optionally replacing a running copy.
    *
    * Environment variables do not go on the command line: simctl reads them from
-   * its **own** environment under a `SIMCTL_CHILD_` prefix. `ExecImpl` pins a
-   * minimal environment on purpose, so a caller wanting them has to say so, and
-   * this is where that would be threaded through.
+   * its **own** environment under a `SIMCTL_CHILD_` prefix. `ExecImpl` takes
+   * argv and pins a minimal environment on purpose, so the variables reach
+   * simctl through `/usr/bin/env` as `SIMCTL_CHILD_NAME=value` argv entries in
+   * front of xcrun — still no shell, and still one argv entry per value. Names
+   * are checked here because `env` reads everything up to the first entry with
+   * no `=` as an assignment, so a name holding one would shift the command.
+   *
+   * `stdout` and `stderr` may be the same path, and that is how a log capture
+   * uses them: measured on Xcode 27.0 with an iOS 27.0 runtime, a probe app
+   * writing to `print`, to stderr and to `Logger` in turn left one file with all
+   * three interleaved in order, nothing overwritten. The redirect *appends* — a
+   * second launch into the same file kept the first one's lines — and where it
+   * lands is not always the path given; see `SimulatorClient.locateRedirect`.
    */
   launch(udid: string, bundleId: string, opts?: {
     args?: string[];
     terminateExisting?: boolean;
     stdout?: string;
     stderr?: string;
+    env?: Record<string, string>;
   }): Promise<string>;
+  /**
+   * Remove an app and its data container. Irreversible, which is why the tool
+   * in front of this takes `confirm`.
+   */
+  uninstall(udid: string, bundleId: string): Promise<void>;
   terminate(udid: string, bundleId: string): Promise<void>;
   openUrl(udid: string, url: string): Promise<void>;
   /**
@@ -192,8 +271,6 @@ declare class Simctl {
    */
   push(udid: string, bundleId: string, payload: unknown): Promise<void>;
 }
-//#endregion
-//#region src/client/shape.d.ts
 type SimulatorSummary = {
   /**
    * The UDID. Called `id` because that is the name the shared `ScreenHost`
@@ -216,6 +293,12 @@ type SimulatorSummary = {
   available: boolean;
   unavailableReason?: string;
   lastBootedAt?: string;
+  /**
+   * The simulator's own filesystem root on this Mac. Never shown in a list row;
+   * it is how a launch log that the simulator wrote under its own `/tmp` is
+   * found again — see `SimulatorClient.locateRedirect`.
+   */
+  dataPath?: string;
 };
 /**
  * Flatten the runtime-keyed map `list devices` returns.
@@ -226,7 +309,7 @@ type SimulatorSummary = {
  * primary key: it is joined against `list runtimes` for a display name, 0..n
  * matches tolerated, and carried through verbatim besides.
  */
-declare const summarizeDevices: (devices: Record<string, RawSim[]>, runtimes: RawRuntime[], deviceTypes: RawDeviceType[]) => SimulatorSummary[];
+export declare const summarizeDevices: (devices: Record<string, RawSim[]>, runtimes: RawRuntime[], deviceTypes: RawDeviceType[]) => SimulatorSummary[];
 type SimAppSummary = {
   bundleId: string;
   name: string | undefined;
@@ -241,18 +324,18 @@ type SimAppSummary = {
   bundlePath: string | undefined;
   dataContainer: string | undefined;
 };
-declare const summarizeApps: (apps: Record<string, RawSimApp>, opts?: {
+export declare const summarizeApps: (apps: Record<string, RawSimApp>, opts?: {
   includeAll?: boolean;
 }) => SimAppSummary[];
 /** The public shape of one row of `ios_simulator_list`. */
-declare const toListRow: (sim: SimulatorSummary) => Record<string, unknown>;
-//#endregion
-//#region src/client/simulator.d.ts
+export declare const toListRow: (sim: SimulatorSummary) => Record<string, unknown>;
 type SimulatorClientOptions = {
   xcrunPath: string;
   sipsPath: string;
   plutilPath: string;
   openPath: string;
+  /** How launch environment variables reach simctl; see `Simctl.launch`. */
+  envPath?: string | undefined;
   execTimeoutMs: number;
   wdaTimeoutMs: number;
   wdaPort: number;
@@ -262,15 +345,18 @@ type SimulatorClientOptions = {
   defaultSimulatorId?: string | undefined;
   exec?: ExecImpl | undefined;
   fetch?: typeof fetch | undefined;
+  /** Override the launched app's liveness probe (tests). */
+  processAlive?: ProcessAlive | undefined;
   logger?: Logger | undefined;
 };
-declare class SimulatorClient implements ScreenHost<SimulatorSummary> {
+export declare class SimulatorClient implements ScreenHost<SimulatorSummary> {
   readonly simctl: Simctl;
   readonly exec: ExecImpl;
   readonly sipsPath: string;
   readonly plutilPath: string;
   readonly openPath: string;
   readonly execTimeoutMs: number;
+  readonly captures: LaunchCaptures;
   private readonly opts;
   private readonly wdaClients;
   /** `simctl list` is ~80ms and most tools want it twice; 2s collapses that. */
@@ -280,6 +366,11 @@ declare class SimulatorClient implements ScreenHost<SimulatorSummary> {
   listSimulators(opts?: {
     fresh?: boolean;
   }): Promise<SimulatorSummary[]>;
+  /**
+   * Drop the cached list. Called after a tool changes a simulator's state, so
+   * the next call within the cache window does not act on the state before it.
+   */
+  forgetSimulators(): void;
   /**
    * Resolve a hint to exactly one simulator, or refuse.
    *
@@ -313,6 +404,28 @@ declare class SimulatorClient implements ScreenHost<SimulatorSummary> {
    * what the profile describes and it changes only when Xcode does.
    */
   display(target: SimulatorSummary, capturePng?: string): Promise<DisplayInfo>;
+  /**
+   * Where a `simctl launch --stdout/--stderr` file actually landed.
+   *
+   * Not necessarily where it was asked to. The redirect is opened by the
+   * simulator's own launchd, which sees the simulator's filesystem, and that
+   * has its own `/tmp` and `/var/folders`. Measured on an iOS 27.0 runtime:
+   * `--stdout=/tmp/x/a.out` created `<dataPath>/tmp/x/a.out`, and a path under
+   * `/var/folders/…/T` — which is where `os.tmpdir()`, and so this server's
+   * default output directory, points — landed under `<dataPath>/var/folders/…`,
+   * the `/private` prefix of either making no difference. A path under `/Users`
+   * was written exactly where it said, missing directories created.
+   *
+   * Rather than encode which prefixes are remapped, which is a property of a
+   * runtime and can change with the next one, this looks: the path as given
+   * first, then the same path under the simulator's data root. Neither existing
+   * means the redirect went somewhere unforeseen, and the path as given is
+   * returned with `found: false` so the caller can say so.
+   */
+  locateRedirect(target: SimulatorSummary, path: string): Promise<{
+    path: string;
+    found: boolean;
+  }>;
   /** The capture lane that needs no runner — the whole reason this server is cheap to start. */
   screenshotPng(target: SimulatorSummary): Promise<string>;
   /**
@@ -327,11 +440,11 @@ declare class SimulatorClient implements ScreenHost<SimulatorSummary> {
    * reports which simulator actually owns the port.
    */
   wdaUrl(): string;
+  /** The simulator `resolveTarget` falls back to when no hint is given. */
+  get defaultSimulatorId(): string | undefined;
   get wdaPort(): number;
   wda(_target: SimulatorSummary): WdaClient;
 }
-//#endregion
-//#region src/config.d.ts
 /**
  * There are no credentials here, and unlike the device server there is barely
  * any setup either. Two lanes reach a simulator and both are local:
@@ -352,6 +465,7 @@ declare const ConfigSchema: z.ZodObject<{
   allowWrites: z.ZodDefault<z.ZodBoolean>;
   launchArgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
   outputDir: z.ZodDefault<z.ZodString>;
+  crashReportsDir: z.ZodDefault<z.ZodString>;
   maxTreeBytes: z.ZodDefault<z.ZodNumber>;
   xcrunPath: z.ZodDefault<z.ZodString>;
   sipsPath: z.ZodDefault<z.ZodString>;
@@ -359,25 +473,21 @@ declare const ConfigSchema: z.ZodObject<{
   openPath: z.ZodDefault<z.ZodString>;
 }, z.core.$strict>;
 type Config = z.infer<typeof ConfigSchema>;
-declare const defaultConfigPath: (env?: NodeJS.ProcessEnv) => string;
+export declare const defaultConfigPath: (env?: NodeJS.ProcessEnv) => string;
 /**
  * Environment first, config file second, **per field** — not whole-source.
  * A one-off `IOS_SIMULATOR_ALLOW_WRITES=0` has to beat a file that says `true`,
  * while a file that sets `simulatorId` keeps working when the environment says
  * nothing about it. Merging field by field is the only rule that gives both.
  */
-declare const loadConfig: (env?: NodeJS.ProcessEnv, configPath?: string) => Config;
-//#endregion
-//#region src/tools/runner.d.ts
+export declare const loadConfig: (env?: NodeJS.ProcessEnv, configPath?: string) => Config;
 /** Injected in tests so no xcodebuild is ever started by the suite. */
 type SpawnRunner = (command: string, args: string[], opts: {
   env: Record<string, string>;
   logPath: string;
 }) => Promise<number | undefined>;
-//#endregion
-//#region src/server.d.ts
-declare const SERVER_NAME: string;
-declare const SERVER_VERSION: string;
+export declare const SERVER_NAME: string;
+export declare const SERVER_VERSION: string;
 type CreateServerOptions = {
   config: Config;
   /** Override the process boundary (tests): `xcrun`, `plutil` and `sips` never run. */
@@ -386,6 +496,8 @@ type CreateServerOptions = {
   fetch?: typeof fetch;
   /** Override starting the runner (tests): no process is spawned. */
   spawnRunner?: SpawnRunner;
+  /** Override the launched-app liveness probe (tests): no real pid is signalled. */
+  processAlive?: ProcessAlive;
   logger?: Logger;
 };
 type CreatedServer = {
@@ -393,14 +505,13 @@ type CreatedServer = {
   client: SimulatorClient;
 };
 /**
- * A pure factory. The injectable seams — `exec`, `fetch` and `spawnRunner` —
- * are the whole reason the test suite can drive real tools through the real SDK
- * with no simulator, no Xcode, no WebDriverAgent and no process left running.
+ * A pure factory. The injectable seams — `exec`, `fetch`, `spawnRunner` and
+ * `processAlive`, plus `crashReportsDir` in the config — are the whole reason
+ * the test suite can drive real tools through the real SDK with no simulator,
+ * no Xcode, no WebDriverAgent and no process left running.
  * Nothing below `config.ts` reads `process.env`.
  */
-declare const createServer: (opts: CreateServerOptions) => CreatedServer;
-//#endregion
-//#region src/client/display.d.ts
+export declare const createServer: (opts: CreateServerOptions) => CreatedServer;
 type ScreenProfile = {
   mainScreenWidth?: number;
   mainScreenHeight?: number;
@@ -411,7 +522,7 @@ type PlistOpts = {
   exec: ExecImpl;
   timeoutMs: number;
 };
-declare const readScreenProfile: (deviceType: RawDeviceType, opts: PlistOpts) => Promise<ScreenProfile>;
+export declare const readScreenProfile: (deviceType: RawDeviceType, opts: PlistOpts) => Promise<ScreenProfile>;
 /**
  * Width and height straight out of a PNG's IHDR.
  *
@@ -419,7 +530,7 @@ declare const readScreenProfile: (deviceType: RawDeviceType, opts: PlistOpts) =>
  * and the bytes are already in hand: the signature is fixed, `IHDR` is always
  * the first chunk, and the two dimensions are big-endian at offsets 16 and 20.
  */
-declare const pngDimensions: (png: Buffer) => {
+export declare const pngDimensions: (png: Buffer) => {
   width: number;
   height: number;
 } | undefined;
@@ -435,15 +546,13 @@ declare const pngDimensions: (png: Buffer) => {
  * `io enumerate`'s `Power state` is about the framebuffer port rather than the
  * screen, so mapping it would be a lie.
  */
-declare const toDisplayInfo: (profile: ScreenProfile, capture?: {
+export declare const toDisplayInfo: (profile: ScreenProfile, capture?: {
   width: number;
   height: number;
 }) => DisplayInfo;
-//#endregion
-//#region src/client/errors.d.ts
 /** Raising the budget, or noticing the simulator died mid-call. */
-declare const TIMEOUT_REMEDY: string;
-declare const TOOLCHAIN_REMEDY: string;
+export declare const TIMEOUT_REMEDY: string;
+export declare const TOOLCHAIN_REMEDY: string;
 /**
  * How to get the runner up, from a shell.
  *
@@ -456,9 +565,9 @@ declare const TOOLCHAIN_REMEDY: string;
  * needs — but a remedy that sends a caller holding ios_simulator_restart_wda out
  * to a terminal is a remedy that wastes the tool it already has.
  */
-declare const START_RUNNER_SCRIPT_REMEDY: string;
+export declare const START_RUNNER_SCRIPT_REMEDY: string;
 /** The same thing, done with this server's own tool. */
-declare const START_RUNNER_TOOL_REMEDY: string;
+export declare const START_RUNNER_TOOL_REMEDY: string;
 /**
  * How to get the runner up, in whichever way the caller can actually reach.
  *
@@ -466,11 +575,11 @@ declare const START_RUNNER_TOOL_REMEDY: string;
  * it unconditionally would be the same mistake this fixes, pointed the other
  * way: a remedy naming a tool that is not in the list.
  */
-declare const startRunnerRemedy: (allowWrites: boolean) => string;
+export declare const startRunnerRemedy: (allowWrites: boolean) => string;
 /** What to do when WebDriverAgent does not answer at all. */
-declare const wdaUnavailableRemedy: (allowWrites: boolean) => string;
+export declare const wdaUnavailableRemedy: (allowWrites: boolean) => string;
 /** No simulator matched, or several did and none was named. */
-declare class SimulatorNotFoundError extends IosError$1 {
+export declare class SimulatorNotFoundError extends IosError$1 {
   readonly name = "SimulatorNotFoundError";
   constructor(message: string, remedy: string);
 }
@@ -482,7 +591,7 @@ declare class SimulatorNotFoundError extends IosError$1 {
  * "it is shut down" would otherwise be buried in a CoreSimulator envelope that
  * reads like a lookup bug.
  */
-declare class SimulatorNotBootedError extends IosError$1 {
+export declare class SimulatorNotBootedError extends IosError$1 {
   readonly name = "SimulatorNotBootedError";
   constructor(name: string, udid: string);
 }
@@ -493,26 +602,23 @@ declare class SimulatorNotBootedError extends IosError$1 {
  * at all: `simctl io` against one of these aborts with an uncaught
  * NSInternalInconsistencyException and a thirty-line stack trace.
  */
-declare class RuntimeUnavailableError extends IosError$1 {
+export declare class RuntimeUnavailableError extends IosError$1 {
   readonly name = "RuntimeUnavailableError";
   constructor(name: string, reason: string | undefined);
 }
 /** Thrown when a write path is reached while IOS_SIMULATOR_ALLOW_WRITES is off. */
-declare class WritesDisabledError extends IosError$1 {
+export declare class WritesDisabledError extends IosError$1 {
   readonly name = "WritesDisabledError";
   constructor(what: string);
 }
 /** A shut-down simulator captures nothing, and that is the usual cause here. */
-declare const EMPTY_SCREENSHOT_REMEDY: string;
-//#endregion
-//#region src/build-info.d.ts
+export declare const EMPTY_SCREENSHOT_REMEDY: string;
 type BuildInfo = {
   name: string;
   version: string;
   gitCommit: string;
   gitCommitDate: string;
 };
-declare const BUILD_INFO: BuildInfo;
-//#endregion
-export { BUILD_INFO, CommandError, CommandTimeoutError, type Config, type CreateServerOptions, type CreatedServer, EMPTY_SCREENSHOT_REMEDY, IosError, type RawDeviceType, type RawRuntime, type RawSim, type RawSimApp, RuntimeUnavailableError, SERVER_NAME, SERVER_VERSION, START_RUNNER_SCRIPT_REMEDY, START_RUNNER_TOOL_REMEDY, type SimAppSummary, Simctl, SimulatorClient, SimulatorNotBootedError, SimulatorNotFoundError, type SimulatorSummary, TIMEOUT_REMEDY, TOOLCHAIN_REMEDY, ToolchainError, WdaError, WdaUnavailableError, WritesDisabledError, assertNotBulkTarget, createServer, defaultConfigPath, loadConfig, parseSimctlError, pngDimensions, readScreenProfile, startRunnerRemedy, summarizeApps, summarizeDevices, toDisplayInfo, toListRow, wdaUnavailableRemedy };
+export declare const BUILD_INFO: BuildInfo;
+export { CommandError, CommandTimeoutError, type Config, type CreateServerOptions, type CreatedServer, IosError, type RawDeviceType, type RawRuntime, type RawSim, type RawSimApp, type SimAppSummary, type SimulatorSummary, ToolchainError, WdaError, WdaUnavailableError };
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../src/client/simctl.ts","../src/client/shape.ts","../src/client/simulator.ts","../src/config.ts","../src/tools/runner.ts","../src/server.ts","../src/client/display.ts","../src/client/errors.ts","../src/build-info.ts"],"mappings":"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"}
+{"version":3,"file":"index.d.ts","names":["IosError"],"sources":["../src/client/logs.ts","../src/client/simctl.ts","../src/client/shape.ts","../src/client/simulator.ts","../src/config.ts","../src/tools/runner.ts","../src/server.ts","../src/client/display.ts","../src/client/errors.ts","../src/build-info.ts"],"mappings":"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"}

package/dist/index.js

@@ -1,2 +1 @@
-import { A as WritesDisabledError, C as SimulatorNotBootedError, D as ToolchainError, E as TOOLCHAIN_REMEDY, M as wdaUnavailableRemedy, N as BUILD_INFO, O as WdaError, S as START_RUNNER_TOOL_REMEDY, T as TIMEOUT_REMEDY, _ as CommandTimeoutError, a as createServer, b as RuntimeUnavailableError, c as assertNotBulkTarget, d as summarizeDevices, f as toListRow, g as CommandError, h as toDisplayInfo, i as SERVER_VERSION, j as startRunnerRemedy, k as WdaUnavailableError, l as parseSimctlError, m as readScreenProfile, n as loadConfig, o as SimulatorClient, p as pngDimensions, r as SERVER_NAME, s as Simctl, t as defaultConfigPath, u as summarizeApps, v as EMPTY_SCREENSHOT_REMEDY, w as SimulatorNotFoundError, x as START_RUNNER_SCRIPT_REMEDY, y as IosError } from "./config-qc0zwYZr.js";
-export { BUILD_INFO, CommandError, CommandTimeoutError, EMPTY_SCREENSHOT_REMEDY, IosError, RuntimeUnavailableError, SERVER_NAME, SERVER_VERSION, START_RUNNER_SCRIPT_REMEDY, START_RUNNER_TOOL_REMEDY, Simctl, SimulatorClient, SimulatorNotBootedError, SimulatorNotFoundError, TIMEOUT_REMEDY, TOOLCHAIN_REMEDY, ToolchainError, WdaError, WdaUnavailableError, WritesDisabledError, assertNotBulkTarget, createServer, defaultConfigPath, loadConfig, parseSimctlError, pngDimensions, readScreenProfile, startRunnerRemedy, summarizeApps, summarizeDevices, toDisplayInfo, toListRow, wdaUnavailableRemedy };
+export { N as BUILD_INFO, g as CommandError, _ as CommandTimeoutError, v as EMPTY_SCREENSHOT_REMEDY, y as IosError, b as RuntimeUnavailableError, r as SERVER_NAME, i as SERVER_VERSION, x as START_RUNNER_SCRIPT_REMEDY, S as START_RUNNER_TOOL_REMEDY, s as Simctl, o as SimulatorClient, C as SimulatorNotBootedError, w as SimulatorNotFoundError, T as TIMEOUT_REMEDY, E as TOOLCHAIN_REMEDY, D as ToolchainError, O as WdaError, k as WdaUnavailableError, A as WritesDisabledError, c as assertNotBulkTarget, a as createServer, t as defaultConfigPath, n as loadConfig, l as parseSimctlError, p as pngDimensions, m as readScreenProfile, j as startRunnerRemedy, u as summarizeApps, d as summarizeDevices, h as toDisplayInfo, f as toListRow, M as wdaUnavailableRemedy } from "./config-HmqayUrt.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mgcrea/mcp-ios-simulator",
-  "version": "0.2.2",
+  "version": "0.4.0",
   "description": "Model Context Protocol server for driving iOS Simulators: screenshots, UI tree, taps, app lifecycle and device staging",
   "keywords": [
     "ios",
@@ -60,23 +60,23 @@
     "prepublishOnly": "pnpm build"
   },
   "dependencies": {
-    "@mgcrea/mcp-ios-core": "^0.2.0",
-    "@modelcontextprotocol/server": "^2.0.0",
-    "zod": "^4.4.3"
+    "@mgcrea/mcp-ios-core": "^0.4.0",
+    "@modelcontextprotocol/server": "^2.4.0",
+    "zod": "^4.6.7"
   },
   "devDependencies": {
-    "@modelcontextprotocol/client": "^2.0.0",
-    "@types/node": "^26.2.0",
-    "oxfmt": "^0.62.0",
-    "oxlint": "^1.77.0",
-    "tsdown": "^0.22.14",
-    "tsx": "^4.23.11",
+    "@modelcontextprotocol/client": "^2.4.0",
+    "@types/node": "^26.6.5",
+    "oxfmt": "^0.75.0",
+    "oxlint": "^1.90.0",
+    "tsdown": "^0.23.3",
+    "tsx": "^4.23.15",
     "typescript": "^7.0.2",
-    "vite": "^8.2.1",
-    "vitest": "^4.1.10"
+    "vite": "^8.3.5",
+    "vitest": "^5.0.5"
   },
   "engines": {
     "node": ">=22"
   },
-  "packageManager": "pnpm@11.13.1"
+  "packageManager": "pnpm@12.10.1"
 }