@mgcrea/mcp-ios-simulator 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,475 @@
+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
+/**
+ * `xcrun simctl` — Apple's own simulator tool, and the half of this server that
+ * needs nothing installed and nothing signed.
+ *
+ * It covers strictly more here than `devicectl` does on a physical device: app
+ * lifecycle, but also the screen itself (`io screenshot`), the appearance, the
+ * status bar, permissions, location and push. Only the accessibility tree and
+ * synthetic touches need WebDriverAgent.
+ *
+ * Three output shapes, and knowing which is which explains the whole class:
+ *
+ *  - `list` takes `-j` and writes clean JSON to **stdout**. It is the only
+ *    subcommand that does; `listapps --json` does not exist.
+ *  - `listapps` writes an old-style NeXTSTEP plist. `plutil` converts it, but
+ *    `ExecImpl` has no stdin, so it goes through a temp file and two processes.
+ *  - everything else answers in prose, including `(null)` and `unknown`, which
+ *    are passed through rather than normalised — see the readers below.
+ */
+type SimctlOptions = {
+  xcrunPath: string;
+  plutilPath: string;
+  timeoutMs: number;
+  exec?: ExecImpl | undefined;
+  logger?: Logger | undefined;
+};
+type RawSim = {
+  udid: string;
+  name: string;
+  state: string;
+  isAvailable?: boolean;
+  availabilityError?: string;
+  deviceTypeIdentifier?: string;
+  lastBootedAt?: string;
+};
+type RawRuntime = {
+  identifier: string;
+  name?: string;
+  version?: string;
+  isAvailable?: boolean;
+};
+type RawDeviceType = {
+  identifier: string;
+  name?: string;
+  bundlePath?: string;
+  modelIdentifier?: string;
+};
+/** One app as `listapps` reports it, once plutil has turned it into JSON. */
+type RawSimApp = {
+  CFBundleIdentifier?: string;
+  CFBundleDisplayName?: string;
+  CFBundleName?: string;
+  CFBundleShortVersionString?: string;
+  CFBundleVersion?: string;
+  ApplicationType?: string;
+  Bundle?: string;
+  Path?: string;
+  DataContainer?: string;
+};
+/**
+ * Pull the human sentence out of a CoreSimulator error envelope.
+ *
+ *   An error was encountered processing the command (domain=…, code=405):
+ *   Unable to lookup in current state: Shutdown
+ *
+ * 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) => {
+  domain?: string;
+  code?: number;
+  message: string;
+};
+/**
+ * The one argument that must never reach simctl.
+ *
+ * `erase`, `delete` and `shutdown` all accept the literal string `all`, and
+ * `simctl erase all` wipes every simulator on the machine. A device hint that
+ * happens to be the word "all" is the single worst thing this server could
+ * 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 {
+  private readonly opts;
+  private readonly exec;
+  /** Device types change only when Xcode is updated; re-reading is pure cost. */
+  private deviceTypes;
+  constructor(opts: SimctlOptions);
+  /** Raw stdout, for the subcommands that answer in prose. */
+  private run;
+  /**
+   * `list` and only `list`. `-e` stops `/` being escaped as `\/`, which matters
+   * only for fixture readability but costs nothing.
+   */
+  private runJson;
+  /**
+   * A NeXTSTEP plist, via `plutil` and a temp file.
+   *
+   * The obvious `simctl listapps … | plutil -convert json -o - -` is not
+   * expressible: `ExecImpl` takes argv and no stdin, deliberately, because that
+   * is what keeps every caller value data rather than shell syntax. So simctl's
+   * stdout is written out and handed to plutil by path. A fresh directory per
+   * call rather than a shared one, so two concurrent tools cannot read each
+   * other's answer with nothing looking wrong.
+   */
+  private runPlist;
+  listDevices(): Promise<Record<string, RawSim[]>>;
+  listRuntimes(): Promise<RawRuntime[]>;
+  listDeviceTypes(): Promise<RawDeviceType[]>;
+  boot(udid: string): Promise<void>;
+  shutdown(udid: string): Promise<void>;
+  erase(udid: string): Promise<void>;
+  /** Attach the Simulator UI to whatever is booted. A `boot` alone is headless. */
+  openApp(openPath: string): Promise<void>;
+  listApps(udid: string): Promise<Record<string, RawSimApp>>;
+  install(udid: string, appPath: string): Promise<void>;
+  /**
+   * 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.
+   */
+  launch(udid: string, bundleId: string, opts?: {
+    args?: string[];
+    terminateExisting?: boolean;
+    stdout?: string;
+    stderr?: string;
+  }): Promise<string>;
+  terminate(udid: string, bundleId: string): Promise<void>;
+  openUrl(udid: string, url: string): Promise<void>;
+  /**
+   * A PNG of the screen, base64, with no WebDriverAgent involved.
+   *
+   * The documented `-` for stdout **does not work**: measured on Xcode 26.6, it
+   * writes a file literally named `-` into the current working directory and
+   * leaves stdout empty, exit code 0. So this passes a real path, like the
+   * device lane's `--json-output` does, and for the same reason uses a fresh
+   * directory per call.
+   *
+   * A successful capture also writes a `Note: No display specified…` line to
+   * stderr, so non-empty stderr is not a failure here.
+   */
+  screenshotPng(udid: string): Promise<string>;
+  /**
+   * Read a `simctl ui` option.
+   *
+   * `unknown` and `unsupported` are passed through rather than normalised: they
+   * mean genuinely different things — the runtime is too old, versus it failed
+   * to read — and collapsing them throws away a distinction a caller can act on.
+   */
+  uiGet(udid: string, option: string): Promise<string>;
+  uiSet(udid: string, option: string, value: string): Promise<void>;
+  statusBarOverride(udid: string, flags: string[]): Promise<void>;
+  statusBarClear(udid: string): Promise<void>;
+  statusBarList(udid: string): Promise<string>;
+  locationSet(udid: string, latitude: number, longitude: number): Promise<void>;
+  locationClear(udid: string): Promise<void>;
+  /** `grant` and `revoke` need a bundle id; `reset` does not. */
+  privacy(udid: string, action: string, service: string, bundleId?: string): Promise<void>;
+  /**
+   * A simulated remote push. The payload goes through a temp file rather than
+   * stdin, for the same argv-only reason as the plist lane.
+   */
+  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`
+   * contract uses — a physical device has two identifiers and a simulator has
+   * one, so there is nothing here to disambiguate. Rendered back as `udid` by
+   * `toListRow`, which is the word anyone reading the output will know it by.
+   */
+  id: string;
+  name: string;
+  /** `Booted` or `Shutdown`, verbatim from CoreSimulator. */
+  state: string;
+  runtime: string;
+  deviceType: string | undefined;
+  deviceTypeIdentifier: string | undefined;
+  /**
+   * False when the runtime is missing. Kept rather than filtered: "why can't I
+   * use that one" has to be answerable from the list, and an unavailable
+   * simulator is the one input that makes `simctl io` abort rather than fail.
+   */
+  available: boolean;
+  unavailableReason?: string;
+  lastBootedAt?: string;
+};
+/**
+ * Flatten the runtime-keyed map `list devices` returns.
+ *
+ * The key is a runtime *identifier* and identifiers are not unique — a machine
+ * carrying both iOS 26.4 and 26.4.1 has two entries under
+ * `com.apple.CoreSimulator.SimRuntime.iOS-26-4`. So the key is never used as a
+ * 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[];
+type SimAppSummary = {
+  bundleId: string;
+  name: string | undefined;
+  version: string | undefined;
+  build: string | undefined;
+  type: string | undefined;
+  /**
+   * Host filesystem paths, and the reason there is no `pull_container` tool: a
+   * simulator's containers are already on this machine, so reading an app's
+   * SwiftData store is an ordinary file read rather than a copy off a device.
+   */
+  bundlePath: string | undefined;
+  dataContainer: string | undefined;
+};
+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
+type SimulatorClientOptions = {
+  xcrunPath: string;
+  sipsPath: string;
+  plutilPath: string;
+  openPath: string;
+  execTimeoutMs: number;
+  wdaTimeoutMs: number;
+  wdaPort: number;
+  wdaUrl?: string | undefined;
+  defaultSimulatorId?: string | undefined;
+  exec?: ExecImpl | undefined;
+  fetch?: typeof fetch | undefined;
+  logger?: Logger | undefined;
+};
+declare class SimulatorClient implements ScreenHost<SimulatorSummary> {
+  readonly simctl: Simctl;
+  readonly exec: ExecImpl;
+  readonly sipsPath: string;
+  readonly plutilPath: string;
+  readonly openPath: string;
+  readonly execTimeoutMs: number;
+  private readonly opts;
+  private readonly wdaClients;
+  /** `simctl list` is ~80ms and most tools want it twice; 2s collapses that. */
+  private cache;
+  private profiles;
+  constructor(opts: SimulatorClientOptions);
+  listSimulators(opts?: {
+    fresh?: boolean;
+  }): Promise<SimulatorSummary[]>;
+  /**
+   * Resolve a hint to exactly one simulator, or refuse.
+   *
+   * The device server's rule — never guess between two — transfers, but
+   * "connected" has to become the right predicate. A typical machine carries
+   * dozens of simulators, most of them shut down and some of them unavailable,
+   * so the population is mostly non-candidates.
+   *
+   * Three things happen here that cannot happen further down:
+   *
+   *  - `all` and `unavailable` are refused outright. `simctl erase all` wipes
+   *    every simulator on the machine, and a hint is a string from a model.
+   *  - `booted` is resolved *here* rather than passed through. simctl's own
+   *    documentation says that with several booted it "will choose one of
+   *    them", and a coin flip that drives the wrong screen most of the time is
+   *    exactly what the refuse-to-guess rule exists to prevent.
+   *  - availability is checked before the target is returned, because `simctl
+   *    io` against an unavailable simulator aborts with an uncaught
+   *    NSInternalInconsistencyException rather than failing.
+   *
+   * State is deliberately *not* checked: `ios_simulator_list` and
+   * `ios_simulator_diagnostics` are useful against a shut-down simulator, so
+   * requiring booted is each tool's decision, via `requireBooted`.
+   */
+  resolveTarget(hint?: string): Promise<SimulatorSummary>;
+  private assertAvailable;
+  /** Every tool that needs a running simulator calls this; the resolver does not. */
+  requireBooted(sim: SimulatorSummary): SimulatorSummary;
+  /**
+   * Geometry. Cached per device *type* rather than per simulator, since that is
+   * what the profile describes and it changes only when Xcode does.
+   */
+  display(target: SimulatorSummary, capturePng?: string): Promise<DisplayInfo>;
+  /** The capture lane that needs no runner — the whole reason this server is cheap to start. */
+  screenshotPng(target: SimulatorSummary): Promise<string>;
+  /**
+   * 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.
+   */
+  wdaUrl(): string;
+  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:
+ *
+ *   * `xcrun simctl` — Apple's own tool. It covers app lifecycle, the device's
+ *     whole staged environment, and the screen itself: `simctl io screenshot`
+ *     needs no runner at all.
+ *   * WebDriverAgent — an HTTP server inside the simulator, on the *host's*
+ *     loopback since a simulator shares the host network stack. Only the
+ *     accessibility tree and synthetic touches go through it.
+ */
+declare const ConfigSchema: z.ZodObject<{
+  simulatorId: z.ZodOptional<z.ZodString>;
+  wdaUrl: z.ZodOptional<z.ZodURL>;
+  wdaPort: z.ZodDefault<z.ZodNumber>;
+  wdaTimeoutMs: z.ZodDefault<z.ZodNumber>;
+  execTimeoutMs: z.ZodDefault<z.ZodNumber>;
+  allowWrites: z.ZodDefault<z.ZodBoolean>;
+  launchArgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+  outputDir: z.ZodDefault<z.ZodString>;
+  maxTreeBytes: z.ZodDefault<z.ZodNumber>;
+  xcrunPath: z.ZodDefault<z.ZodString>;
+  sipsPath: z.ZodDefault<z.ZodString>;
+  plutilPath: z.ZodDefault<z.ZodString>;
+  openPath: z.ZodDefault<z.ZodString>;
+}, z.core.$strict>;
+type Config = z.infer<typeof ConfigSchema>;
+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
+/** 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;
+type CreateServerOptions = {
+  config: Config;
+  /** Override the process boundary (tests): `xcrun`, `plutil` and `sips` never run. */
+  exec?: ExecImpl;
+  /** Override HTTP to WebDriverAgent (tests). */
+  fetch?: typeof fetch;
+  /** Override starting the runner (tests): no process is spawned. */
+  spawnRunner?: SpawnRunner;
+  logger?: Logger;
+};
+type CreatedServer = {
+  server: McpServer;
+  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.
+ * Nothing below `config.ts` reads `process.env`.
+ */
+declare const createServer: (opts: CreateServerOptions) => CreatedServer;
+//#endregion
+//#region src/client/display.d.ts
+type ScreenProfile = {
+  mainScreenWidth?: number;
+  mainScreenHeight?: number;
+  mainScreenScale?: number;
+};
+declare const readScreenProfile: (deviceType: RawDeviceType, opts: {
+  plutilPath: string;
+  exec: ExecImpl;
+  timeoutMs: number;
+}) => Promise<ScreenProfile>;
+/**
+ * Width and height straight out of a PNG's IHDR.
+ *
+ * Cheaper than shelling to `sips` for the one number that must not be stale,
+ * 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) => {
+  width: number;
+  height: number;
+} | undefined;
+/**
+ * Assemble a `DisplayInfo`.
+ *
+ * `orientation` is derived by comparing the capture's own aspect against the
+ * profile's portrait dimensions, and is `"unknown"` when there is no capture to
+ * compare — never guessed as `"portrait"`, because the whole point of the field
+ * is telling a caller whether the screen they are about to read is rotated.
+ *
+ * `backlightState` is left undefined: a simulator has no backlight, and
+ * `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?: {
+  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;
+/**
+ * How to get the runner up. Much shorter than the device server's equivalent,
+ * and that is the headline difference between the two: a simulator runner needs
+ * no Apple team, no signing, no trust prompt and no tunnel.
+ */
+declare const START_RUNNER_REMEDY: string;
+/** What to do when WebDriverAgent does not answer at all. */
+declare const WDA_UNAVAILABLE_REMEDY: string;
+/** No simulator matched, or several did and none was named. */
+declare class SimulatorNotFoundError extends IosError$1 {
+  readonly name = "SimulatorNotFoundError";
+  constructor(message: string, remedy: string);
+}
+/**
+ * The simulator exists but is shut down.
+ *
+ * Its own error class because the fix is a single specific call and nothing
+ * else: almost every simctl subcommand fails this way, `listapps` included, so
+ * "it is shut down" would otherwise be buried in a CoreSimulator envelope that
+ * reads like a lookup bug.
+ */
+declare class SimulatorNotBootedError extends IosError$1 {
+  readonly name = "SimulatorNotBootedError";
+  constructor(name: string, udid: string);
+}
+/**
+ * The simulator's runtime is not installed, so CoreSimulator cannot service it.
+ *
+ * Worth its own class because the failure it prevents is not an error message
+ * 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 {
+  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 {
+  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
+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_REMEDY, type SimAppSummary, Simctl, SimulatorClient, SimulatorNotBootedError, SimulatorNotFoundError, type SimulatorSummary, TIMEOUT_REMEDY, TOOLCHAIN_REMEDY, ToolchainError, WDA_UNAVAILABLE_REMEDY, WdaError, WdaUnavailableError, WritesDisabledError, assertNotBulkTarget, createServer, defaultConfigPath, loadConfig, parseSimctlError, pngDimensions, readScreenProfile, summarizeApps, summarizeDevices, toDisplayInfo, toListRow };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +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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"}

package/dist/index.js

@@ -0,0 +1,2 @@
+import { A as WritesDisabledError, C as SimulatorNotFoundError, D as WDA_UNAVAILABLE_REMEDY, E as ToolchainError, O as WdaError, S as SimulatorNotBootedError, T as TOOLCHAIN_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 BUILD_INFO, 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 TIMEOUT_REMEDY, x as START_RUNNER_REMEDY, y as IosError } from "./config-C1TH-p-c.js";
+export { BUILD_INFO, CommandError, CommandTimeoutError, EMPTY_SCREENSHOT_REMEDY, IosError, RuntimeUnavailableError, SERVER_NAME, SERVER_VERSION, START_RUNNER_REMEDY, Simctl, SimulatorClient, SimulatorNotBootedError, SimulatorNotFoundError, TIMEOUT_REMEDY, TOOLCHAIN_REMEDY, ToolchainError, WDA_UNAVAILABLE_REMEDY, WdaError, WdaUnavailableError, WritesDisabledError, assertNotBulkTarget, createServer, defaultConfigPath, loadConfig, parseSimctlError, pngDimensions, readScreenProfile, summarizeApps, summarizeDevices, toDisplayInfo, toListRow };

package/package.json

@@ -0,0 +1,81 @@
+{
+  "name": "@mgcrea/mcp-ios-simulator",
+  "version": "0.1.0",
+  "description": "Model Context Protocol server for driving iOS Simulators: screenshots, UI tree, taps, app lifecycle and device staging",
+  "keywords": [
+    "ios",
+    "mcp",
+    "model-context-protocol",
+    "simctl",
+    "simulator",
+    "webdriveragent"
+  ],
+  "homepage": "https://github.com/mgcrea/mcp-ios-simulator#readme",
+  "license": "MIT",
+  "author": "Olivier Louvignes <olivier@mgcrea.io>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mgcrea/mcp-ios-simulator.git"
+  },
+  "bin": {
+    "ios-simulator-mcp": "dist/cli.js",
+    "ios-simulator-wda": "scripts/wda.sh"
+  },
+  "files": [
+    "dist",
+    "scripts/wda.sh"
+  ],
+  "os": [
+    "darwin"
+  ],
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "imports": {
+    "#/*": "./src/*.ts",
+    "#test/*": "./test/*.ts"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "start": "node dist/cli.js",
+    "lint": "oxlint",
+    "lint:fix": "oxlint --fix",
+    "format": "oxfmt --write .",
+    "format:check": "oxfmt --check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit",
+    "release": "pnpm dlx release-it",
+    "prepublishOnly": "pnpm build"
+  },
+  "dependencies": {
+    "@mgcrea/mcp-ios-core": "^0.1.0",
+    "@modelcontextprotocol/server": "^2.0.0",
+    "zod": "^4.4.3"
+  },
+  "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",
+    "typescript": "^7.0.2",
+    "vite": "^8.2.1",
+    "vitest": "^4.1.10"
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "packageManager": "pnpm@11.13.1"
+}