@alumnium/xcode 0.0.0-stage → 0.24.0-alpha.1

package/src/index.cjs

@@ -0,0 +1,1065 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode
+      ? (__toESMCache_node ??= new WeakMap())
+      : (__toESMCache_esm ??= new WeakMap());
+    var cached = cache.get(mod);
+    if (cached) return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to =
+    isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default")
+      ? __defProp(target, "default", { value: mod, enumerable: true })
+      : target;
+  if ((mod && typeof mod === "object") || typeof mod === "function") {
+    for (let key of __getOwnPropNames(mod))
+      if (!__hasOwnProp.call(to, key))
+        __defProp(to, key, {
+          get: __accessProp.bind(mod, key),
+          enumerable: true,
+        });
+  }
+  if (canCache) cache.set(mod, to);
+  return to;
+};
+var __toCommonJS = (from) => {
+  var entry = (__moduleCache ??= new WeakMap()).get(from),
+    desc;
+  if (entry) return entry;
+  entry = __defProp({}, "__esModule", { value: true });
+  if ((from && typeof from === "object") || typeof from === "function") {
+    for (var key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(entry, key))
+        __defProp(entry, key, {
+          get: __accessProp.bind(from, key),
+          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable,
+        });
+  }
+  __moduleCache.set(from, entry);
+  return entry;
+};
+var __moduleCache;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name),
+    });
+};
+var __legacyDecorateClassTS = function (decorators, target, key, desc) {
+  var c = arguments.length,
+    r =
+      c < 3
+        ? target
+        : desc === null
+          ? (desc = Object.getOwnPropertyDescriptor(target, key))
+          : desc,
+    d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if ((d = decorators[i]))
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return (c > 3 && r && Object.defineProperty(target, key, r), r);
+};
+
+// xcode/src/index.ts
+var exports_src = {};
+__export(exports_src, {
+  Alumni: () => Alumni,
+  XcodeAccessibilityTree: () => XcodeAccessibilityTree,
+  XcodeDriver: () => XcodeDriver,
+  XcodeSession: () => XcodeSession,
+});
+module.exports = __toCommonJS(exports_src);
+
+// xcode/src/Alumni.ts
+var import_core = require("@alumnium/core");
+
+// xcode/src/drivers/XcodeDriver.ts
+var import_internal = require("@alumnium/core/internal");
+var { tracer } = import_internal.Telemetry.get(
+  "packages/typescript/xcode/src/drivers/XcodeDriver.ts",
+);
+var { span } = tracer.dec();
+var stateful = import_internal.BaseDriver.stateful;
+
+class XcodeDriver extends import_internal.BaseDriver {
+  kind = "xcode";
+  platform = "ios";
+  supportedTools = new Set([
+    import_internal.ClickTool,
+    import_internal.DragAndDropTool,
+    import_internal.DragSliderTool,
+    import_internal.NavigateBackTool,
+    import_internal.PressKeyTool,
+    import_internal.ScrollTool,
+    import_internal.TypeTool,
+  ]);
+  delay = 0;
+  session;
+  constructor(session) {
+    super();
+    this.session = session;
+  }
+  async fetchAccessibilityTree() {
+    if (this.delay > 0) await import_internal.sleep(this.delay * 1000);
+    return (await this.session.capture()).tree;
+  }
+  async click(id) {
+    const node = await this.#resolve(id);
+    const point = this.#pointOf(node);
+    await this.#perform(`t ${point.x} ${point.y}`, node.activationBundleId);
+  }
+  async type(id, text) {
+    const node = await this.#resolve(id);
+    const point = this.#pointOf(node);
+    await this.#perform(`t ${point.x} ${point.y}`, node.activationBundleId);
+    const focused = await this.#resolveNode(node);
+    const value =
+      focused.value === focused.attributes["placeholderValue"]
+        ? ""
+        : (focused.value ?? "");
+    const input = "\b".repeat([...value].length) + text;
+    if (input) {
+      await this.#perform(`sender keyboard kbd ${this.#encodeText(input)}`);
+    }
+  }
+  async pressKey(key) {
+    const keys = {
+      Backspace: "\b",
+      Enter: `
+`,
+      Tab: "\t",
+      Escape: "\x1B",
+      Space: " ",
+      ArrowUp: "",
+      ArrowDown: "",
+      ArrowLeft: "",
+      ArrowRight: "",
+    };
+    await this.#perform(`sender keyboard kbd ${this.#encodeText(keys[key])}`);
+  }
+  async dragAndDrop(fromId, toId) {
+    const previous = await this.#tree();
+    const from = previous.elementById(fromId);
+    const to = previous.elementById(toId);
+    if (from.activationBundleId !== to.activationBundleId)
+      throw new Error("Xcode cannot drag between applications");
+    const fresh = (
+      await this.session.capture(undefined, from.activationBundleId)
+    ).tree;
+    const start = fresh.resolve(from);
+    const end = fresh.resolve(to);
+    if (start.activationBundleId !== end.activationBundleId)
+      throw new Error("Xcode cannot drag between applications");
+    const a = this.#pointOf(start);
+    const b = this.#pointOf(end);
+    await this.#perform(
+      `drag ${a.x} ${a.y} ${b.x} ${b.y}`,
+      start.activationBundleId,
+    );
+  }
+  async dragSlider(id, value) {
+    if (value < 0 || value > 100)
+      throw new Error("Slider value must be between 0 and 100");
+    const node = await this.#resolve(id);
+    if (node.type !== "Slider" || !node.frame)
+      throw new Error("Xcode target must be a slider with a frame");
+    const start = this.#pointOf(node);
+    const end = node.frame.x + (node.frame.width * value) / 100;
+    await this.#perform(
+      `drag ${start.x} ${start.y} ${end} ${start.y}`,
+      node.activationBundleId,
+    );
+  }
+  async scrollTo(id) {
+    const target = (await this.#tree()).elementById(id);
+    for (let attempt = 0; attempt < 10; attempt++) {
+      const tree = (await this.session.capture()).tree;
+      const node = tree.resolve(target);
+      if (node.hitPoint) return;
+      let container = node.parent;
+      while (
+        container &&
+        !["ScrollView", "Table", "CollectionView", "Window"].includes(
+          container.type,
+        )
+      )
+        container = container.parent;
+      if (!container?.frame || !node.frame)
+        throw new Error(
+          "Xcode cannot determine a scroll container for this element",
+        );
+      const frame = container.frame;
+      const x = frame.x + frame.width / 2;
+      const top = frame.y + frame.height * 0.25;
+      const bottom = frame.y + frame.height * 0.75;
+      const up = node.frame.y > frame.y + frame.height / 2;
+      await this.#perform(
+        `t ${x} ${up ? bottom : top} f ${x} ${up ? top : bottom} 0.3`,
+        node.activationBundleId,
+      );
+    }
+    throw new Error("Xcode element did not become hittable after scrolling");
+  }
+  async back() {
+    const tree = (await this.session.capture()).tree;
+    const bar = tree.find((node) => node.type === "NavigationBar");
+    const back = bar?.children.find(
+      (node) =>
+        node.type === "Button" &&
+        node.hitPoint &&
+        (/^back$/i.test(node.label ?? "") ||
+          /^(back|back-button|backButton)$/i.test(node.identifier ?? "")),
+    );
+    if (!back) {
+      const window = tree.find((node) => node.type === "Window");
+      if (!bar || !window?.frame)
+        throw new Error("Xcode could not find a navigation back button");
+      const frame = window.frame;
+      const y = frame.y + frame.height / 2;
+      await this.#perform(
+        `t ${frame.x + 1} ${y} f ${frame.x + frame.width * 0.75} ${y} 0.3`,
+        window.activationBundleId,
+      );
+      return;
+    }
+    const point = this.#pointOf(back);
+    await this.#perform(`t ${point.x} ${point.y}`, back.activationBundleId);
+  }
+  async wait(seconds) {
+    await this.#perform(`w ${Math.max(1, Math.min(30, seconds))}`);
+  }
+  screenshot() {
+    return this.session.screenshot();
+  }
+  quit() {
+    return this.session.close();
+  }
+  app() {
+    return import_internal.AppId.parse(this.session.appId);
+  }
+  title() {
+    return "";
+  }
+  url() {
+    return "";
+  }
+  checkNavigationPolicy() {}
+  findElement() {
+    throw new Error("Element handles are not supported on Xcode");
+  }
+  visit() {
+    throw new Error("Opening URLs is not supported by Xcode MCP");
+  }
+  executeScript() {
+    throw new Error("Executing JavaScript is not supported on Xcode");
+  }
+  switchToNextTab() {
+    throw new Error("Tab switching is not supported on Xcode");
+  }
+  switchToPreviousTab() {
+    throw new Error("Tab switching is not supported on Xcode");
+  }
+  waitForSelector() {
+    throw new Error("CSS selectors are not supported on Xcode");
+  }
+  printToPdf() {
+    throw new Error("Printing to PDF is not supported on Xcode");
+  }
+  async #tree() {
+    return await this.getAccessibilityTree();
+  }
+  async #resolve(id) {
+    return this.#resolveNode((await this.#tree()).elementById(id));
+  }
+  async #resolveNode(target) {
+    return (
+      await this.session.capture(undefined, target.activationBundleId)
+    ).tree.resolve(target);
+  }
+  async #perform(command, bundleId) {
+    try {
+      await this.session.capture(command, bundleId);
+    } finally {
+      this.resetAccessibilityTree();
+    }
+  }
+  #pointOf(node) {
+    if (!node.hitPoint || node.attributes["enabled"] === "false") {
+      throw new Error(
+        `Xcode element ${node.identifier || node.label || node.type} is not hittable`,
+      );
+    }
+    return node.hitPoint;
+  }
+  #encodeText(text) {
+    return [...text]
+      .map((character) => `\\u{${character.codePointAt(0).toString(16)}}`)
+      .join("");
+  }
+}
+__legacyDecorateClassTS(
+  [
+    span(
+      "driver.fetch_accessibility_tree",
+      import_internal.BaseDriver.spanAttrs,
+    ),
+  ],
+  XcodeDriver.prototype,
+  "fetchAccessibilityTree",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.click", import_internal.BaseDriver.spanAttrs), stateful],
+  XcodeDriver.prototype,
+  "click",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.type", import_internal.BaseDriver.spanAttrs), stateful],
+  XcodeDriver.prototype,
+  "type",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.press_key", import_internal.BaseDriver.spanAttrs), stateful],
+  XcodeDriver.prototype,
+  "pressKey",
+  null,
+);
+__legacyDecorateClassTS(
+  [
+    span("driver.drag_and_drop", import_internal.BaseDriver.spanAttrs),
+    stateful,
+  ],
+  XcodeDriver.prototype,
+  "dragAndDrop",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.drag_slider", import_internal.BaseDriver.spanAttrs), stateful],
+  XcodeDriver.prototype,
+  "dragSlider",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.scroll_to", import_internal.BaseDriver.spanAttrs), stateful],
+  XcodeDriver.prototype,
+  "scrollTo",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.back", import_internal.BaseDriver.spanAttrs), stateful],
+  XcodeDriver.prototype,
+  "back",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.wait", import_internal.BaseDriver.spanAttrs), stateful],
+  XcodeDriver.prototype,
+  "wait",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.screenshot", import_internal.BaseDriver.spanAttrs)],
+  XcodeDriver.prototype,
+  "screenshot",
+  null,
+);
+__legacyDecorateClassTS(
+  [span("driver.quit", import_internal.BaseDriver.spanAttrs)],
+  XcodeDriver.prototype,
+  "quit",
+  null,
+);
+
+// xcode/src/drivers/XcodeSession.ts
+var import_node_crypto = require("node:crypto");
+var import_promises = require("node:fs/promises");
+var import_node_os = __toESM(require("node:os"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_client = require("@modelcontextprotocol/sdk/client/index.js");
+var import_stdio = require("@modelcontextprotocol/sdk/client/stdio.js");
+var import_zod2 = require("zod");
+var import_internal3 = require("@alumnium/core/internal");
+
+// xcode/src/accessibility/XcodeAccessibilityTree.ts
+var import_domhandler = require("domhandler");
+var import_zod = require("zod");
+var import_internal2 = require("@alumnium/core/internal");
+
+class XcodeAccessibilityTree extends import_internal2.BaseAccessibilityTree {
+  #roots;
+  #nodes;
+  get kind() {
+    return "xcode";
+  }
+  constructor(source, roots) {
+    super(source);
+    this.#roots = roots ?? parseHierarchy(source);
+    this.#nodes = this.#roots.flatMap(flatten);
+  }
+  toStr() {
+    return (this.xml ??= import_internal2.XmlRenderer.render(
+      this.#roots.map(toXml),
+      {
+        compactAttrs: false,
+      },
+    ));
+  }
+  elementById(id) {
+    const node = this.#nodes.find((candidate) => candidate.id === id);
+    if (!node) throw new Error(`No element with raw_id=${id} found`);
+    return node;
+  }
+  scopeToArea(id) {
+    const node = this.#nodes.find((candidate) => candidate.id === id);
+    return node ? new XcodeAccessibilityTree(this.toStr(), [node]) : this;
+  }
+  resolve(target) {
+    let matches = this.#nodes.filter((candidate) =>
+      sameIdentity(candidate, target),
+    );
+    if (!target.identifier || matches.length > 1) {
+      const context = ancestorIdentity(target);
+      matches = matches.filter(
+        (candidate) => ancestorIdentity(candidate) === context,
+      );
+    }
+    const first = matches[0];
+    if (
+      first?.hitPoint &&
+      matches.every(
+        (candidate) => actionIdentity(candidate) === actionIdentity(first),
+      )
+    ) {
+      return first;
+    }
+    if (matches.length !== 1) {
+      throw new Error(
+        `Xcode element ${target.identifier || target.label || target.type} is ${matches.length ? "ambiguous" : "no longer present"}; fetch a fresh accessibility tree`,
+      );
+    }
+    return matches[0];
+  }
+  find(predicate) {
+    return this.#nodes.find(predicate);
+  }
+}
+var NUMBER = "(-?\\d+(?:\\.\\d+)?)";
+var FRAME = new RegExp(
+  `\\{\\{${NUMBER},\\s*${NUMBER}\\},\\s*\\{${NUMBER},\\s*${NUMBER}\\}\\}`,
+);
+var HIT_POINT = new RegExp(`hitPoint:\\s*\\{${NUMBER},\\s*${NUMBER}\\}`);
+var QUOTED_ATTRIBUTE =
+  /(?:^|,\s*)(identifier|label|value|title|placeholderValue):\s*'((?:\\.|[^']|'(?!,\s|$))*)'(?=,\s|$)/g;
+var BOOLEAN_ATTRIBUTE =
+  /(?:^|,\s*)(enabled|selected|focused|isEnabled|isSelected|isFocused|isRemoteLeafPlaceholder):\s*(true|false|YES|NO|0|1)(?=,\s|$)/g;
+var POINT = import_zod.z.tuple([
+  import_zod.z.coerce.number().finite(),
+  import_zod.z.coerce.number().finite(),
+]);
+var RECT = import_zod.z.tuple([
+  import_zod.z.coerce.number().finite(),
+  import_zod.z.coerce.number().finite(),
+  import_zod.z.coerce.number().finite(),
+  import_zod.z.coerce.number().finite(),
+]);
+function parseHierarchy(source) {
+  const roots = [];
+  const stack = [];
+  let bundleId = "";
+  let id = 0;
+  for (const line of source.split(/\r?\n/)) {
+    const application = /^Application bundle identifier:\s*(.+)$/.exec(line);
+    if (application) {
+      bundleId = application[1].trim();
+      stack.length = 0;
+      continue;
+    }
+    const match = /^(\s*)([A-Z][A-Za-z0-9]*)(?=,|\s|$)(.*)$/.exec(line);
+    if (
+      !match ||
+      /^(Device|Application UI|Application pid|Application is)/.test(line)
+    )
+      continue;
+    const [, whitespace, type, description] = match;
+    if (type !== "Application" && !stack.length) continue;
+    const attributes = {};
+    for (const attr of description.matchAll(QUOTED_ATTRIBUTE)) {
+      attributes[attr[1]] = attr[2].replace(/\\(['\\])/g, "$1");
+    }
+    const value =
+      /(?:^|,\s*)value:\s*(.*?)(?=,\s*(?:(?:hitPoint|activationBundleId|enabled|selected|focused|is\w+):|(?:Disabled|Selected|Focused|Keyboard Focused)(?:,|$))|$)/.exec(
+        description,
+      );
+    if (value && attributes["value"] === undefined)
+      attributes["value"] = value[1].trim();
+    for (const attr of description.matchAll(BOOLEAN_ATTRIBUTE)) {
+      const name = attr[1].replace(/^is(?=[A-Z])/, "");
+      const normalized = name[0].toLowerCase() + name.slice(1);
+      attributes[normalized] = ["true", "YES", "1"].includes(attr[2])
+        ? "true"
+        : "false";
+    }
+    for (const [flag, attr] of [
+      ["Disabled", "enabled"],
+      ["Selected", "selected"],
+      ["Focused", "focused"],
+      ["Keyboard Focused", "focused"],
+    ]) {
+      if (new RegExp(`(?:^|,\\s*)${flag}(?=,|$)`).test(description))
+        attributes[attr] = flag === "Disabled" ? "false" : "true";
+    }
+    const frameMatch = FRAME.exec(description);
+    const hitMatch = HIT_POINT.exec(description);
+    const frame = frameMatch
+      ? RECT.parse(frameMatch.slice(1).map(Number))
+      : undefined;
+    const hitPoint = hitMatch
+      ? POINT.parse(hitMatch.slice(1).map(Number))
+      : undefined;
+    const indent = whitespace.length;
+    while (stack.length && stack.at(-1).indent >= indent) stack.pop();
+    const parent = stack.at(-1)?.node;
+    const node = {
+      id: ++id,
+      type,
+      identifier: attributes["identifier"],
+      name: attributes["identifier"] || attributes["label"],
+      label: attributes["label"],
+      value: attributes["value"],
+      frame: frame && {
+        x: frame[0],
+        y: frame[1],
+        width: frame[2],
+        height: frame[3],
+      },
+      hitPoint: hitPoint && { x: hitPoint[0], y: hitPoint[1] },
+      activationBundleId:
+        /activationBundleId:\s*([^,\s]+)/.exec(description)?.[1] ?? bundleId,
+      attributes,
+      children: [],
+      parent,
+    };
+    (parent?.children ?? roots).push(node);
+    stack.push({ indent, node });
+  }
+  if (!roots.length)
+    throw new Error(
+      "Xcode returned no application accessibility hierarchy; capture the device again",
+    );
+  return roots;
+}
+function flatten(node) {
+  return [node, ...node.children.flatMap(flatten)];
+}
+function toXml(node) {
+  const attributes = {
+    raw_id: String(node.id),
+    name: node.name ?? "",
+    ...node.attributes,
+  };
+  const element = new import_domhandler.Element(node.type, attributes);
+  element.children = node.children.map(toXml);
+  for (const child of element.children) child.parent = element;
+  return element;
+}
+function sameIdentity(candidate, target) {
+  return (
+    candidate.type === target.type &&
+    candidate.activationBundleId === target.activationBundleId &&
+    (target.identifier
+      ? candidate.identifier === target.identifier
+      : candidate.label === target.label)
+  );
+}
+function ancestorIdentity(node) {
+  const identities = [];
+  for (let parent = node.parent; parent; parent = parent.parent) {
+    identities.push(
+      JSON.stringify([
+        parent.type,
+        parent.identifier || parent.label || "",
+        parent.type === "Cell"
+          ? flatten(parent)
+              .filter((child) => child.type === "StaticText")
+              .map((child) => child.label ?? "")
+              .sort()
+          : [],
+      ]),
+    );
+  }
+  return identities.join("/");
+}
+function actionIdentity(node) {
+  return JSON.stringify([node.attributes, node.frame, node.hitPoint]);
+}
+
+// xcode/src/drivers/XcodeSession.ts
+var OpenWorkspace = import_zod2.z.object({
+  workspaceIdentifier: import_zod2.z.string(),
+  activeScheme: import_zod2.z.string().nullable().optional(),
+});
+var Schemes = import_zod2.z.object({
+  activeSchemeName: import_zod2.z.string().nullable().optional(),
+});
+var BuildSettings = import_zod2.z.array(
+  import_zod2.z.object({
+    buildSettings: import_zod2.z.object({
+      PRODUCT_TYPE: import_zod2.z.string().optional(),
+      PRODUCT_BUNDLE_IDENTIFIER: import_zod2.z.string().optional(),
+    }),
+  }),
+);
+var Session = import_zod2.z.object({
+  interactionSessionKey: import_zod2.z.string(),
+  deviceUUID: import_zod2.z.string(),
+  deviceIsSimulator: import_zod2.z.boolean(),
+});
+var PermissionStatus = import_zod2.z.object({
+  permission: import_zod2.z.object({
+    projectAccessAttempts: import_zod2.z
+      .array(
+        import_zod2.z.object({
+          agent: import_zod2.z.object({ name: import_zod2.z.string() }),
+          endpoints: import_zod2.z.array(import_zod2.z.string()),
+        }),
+      )
+      .default([]),
+  }),
+});
+var Capture = import_zod2.z.object({
+  hierarchyPath: import_zod2.z.string().optional(),
+  screenshotPath: import_zod2.z.string(),
+});
+var logger = import_internal3.Logger.get(
+  "packages/typescript/xcode/src/drivers/XcodeSession.ts",
+);
+
+class XcodeSession {
+  static TOOL_TIMEOUT_MS = 5 * 60000;
+  static APPROVE_INTERVAL_MS = 1000;
+  #client = new import_client.Client({
+    name: "alumnium",
+    version: import_internal3.ALUMNIUM_VERSION,
+  });
+  #props;
+  #key;
+  #appId;
+  #simulatorWindow = new import_internal3.SimulatorWindow();
+  #approving = false;
+  constructor(props) {
+    this.#props = props;
+    this.#appId = props.appId ?? "";
+  }
+  get appId() {
+    return this.#appId;
+  }
+  static async start(props) {
+    const session = new XcodeSession(props);
+    try {
+      await session.#start();
+      return session;
+    } catch (error) {
+      await session.close().catch(() => {});
+      throw error;
+    }
+  }
+  async #start() {
+    const { appPath, appReset, device, launchArgs, launchEnv } = this.#props;
+    const workspace =
+      appPath && /\.(xcodeproj|xcworkspace)[\\/]?$/i.test(appPath)
+        ? appPath
+        : undefined;
+    if (
+      !appPath &&
+      !this.#appId &&
+      (appReset || launchArgs?.length || Object.keys(launchEnv ?? {}).length)
+    )
+      throw new Error(
+        "An app is required to reset or launch with arguments or environment variables",
+      );
+    this.#startAutoApprove();
+    await this.#connect();
+    const sessionIdentifier = `Alumnium ${import_node_crypto.randomUUID()}`;
+    let workspaceIdentifier;
+    let activeScheme;
+    if (workspace) {
+      const opened = OpenWorkspace.parse(
+        await this.#call("XcodeOpenWorkspace", { path: workspace }),
+      );
+      workspaceIdentifier = opened.workspaceIdentifier;
+      activeScheme = opened.activeScheme;
+    }
+    const result = Session.parse(
+      await this.#call(
+        workspace
+          ? "DeviceInteractionStartWorkspaceSession"
+          : "DeviceInteractionStartSession",
+        {
+          sessionIdentifier,
+          ...(workspace ? { workspaceIdentifier } : {}),
+          ...(workspace
+            ? device && { deviceIdentifier: device }
+            : { deviceIdentifier: device ?? "iPhone Simulator" }),
+        },
+      ),
+    );
+    this.#key = result.interactionSessionKey;
+    if (!result.deviceIsSimulator)
+      throw new Error(
+        "XcodeDriver supports iOS simulators only; select a simulator using the device option",
+      );
+    await this.#simulatorWindow.open(result.deviceUUID, this.#props.headless);
+    if (workspace) {
+      await this.#call("DeviceInteractionInstallAndRun", {
+        interactionSessionKey: this.#key,
+        workspaceIdentifier,
+        ...(launchArgs && { commandLineArguments: launchArgs }),
+        ...(launchEnv && { environmentVariables: launchEnv }),
+      });
+      await this.#resolveWorkspaceApp(
+        workspace,
+        workspaceIdentifier,
+        result.deviceUUID,
+        activeScheme,
+      );
+    } else {
+      await this.#installApp(result.deviceUUID);
+    }
+    if (appReset) await this.#resetApp(result.deviceUUID);
+    if (!workspace || appReset) await this.#launchApp(result.deviceUUID);
+    await this.capture(undefined, this.#appId || undefined);
+  }
+  #startAutoApprove() {
+    if (!import_internal3.Env.ALUMNIUM_XCODE_AUTO_APPROVE || this.#approving)
+      return;
+    this.#approving = true;
+    this.#autoApprove();
+  }
+  async #autoApprove() {
+    let lastError;
+    while (this.#approving) {
+      try {
+        if (await this.#approvePending()) break;
+      } catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        if (message !== lastError)
+          logger.warn(`Xcode auto approve failed: ${message}`);
+        lastError = message;
+      }
+      await import_internal3.sleep(XcodeSession.APPROVE_INTERVAL_MS);
+    }
+    this.#approving = false;
+  }
+  async #approvePending() {
+    const { stdout } = await import_internal3.exec("xcrun", [
+      "mcp-server",
+      "status",
+      "--format",
+      "json",
+    ]);
+    const { permission } = PermissionStatus.parse(JSON.parse(stdout));
+    const ids = permission.projectAccessAttempts
+      .filter(({ agent }) => agent.name === "alumnium")
+      .flatMap(({ endpoints }) => endpoints);
+    if (!ids.length) return false;
+    logger.info(`Approving Xcode access requests: ${ids.join(", ")}`);
+    await import_internal3.exec("sudo", [
+      "xcrun",
+      "mcp-server",
+      "approve",
+      ...ids,
+      "--for-24-hours",
+    ]);
+    return true;
+  }
+  async #connect() {
+    try {
+      await this.#client.connect(
+        new import_stdio.StdioClientTransport({
+          command: "xcrun",
+          args: ["mcpbridge"],
+          env: Object.fromEntries(
+            Object.entries(process.env).filter(
+              (entry) => entry[1] !== undefined,
+            ),
+          ),
+          stderr: "pipe",
+        }),
+      );
+    } catch (error) {
+      throw (await this.#bridgeFailure(error)) ?? error;
+    }
+  }
+  async #bridgeFailure(cause) {
+    try {
+      await import_internal3.exec("xcrun", ["mcpbridge"], { timeout: 1e4 });
+    } catch (error) {
+      const output = (error instanceof Error ? error.message : "")
+        .replace(/^.*? exited with status \S+:\s*/s, "")
+        .trim();
+      let message = output;
+      try {
+        const parsed = import_zod2.z
+          .object({
+            error: import_zod2.z.object({ message: import_zod2.z.string() }),
+          })
+          .parse(JSON.parse(output));
+        message = parsed.error.message;
+      } catch {}
+      if (message)
+        return new Error(`Xcode mcpbridge failed: ${message}`, { cause });
+    }
+  }
+  async #resolveWorkspaceApp(
+    workspace,
+    workspaceIdentifier,
+    device,
+    activeScheme,
+  ) {
+    const scheme =
+      activeScheme ||
+      Schemes.parse(
+        await this.#call("XcodeListSchemes", { workspaceIdentifier }),
+      ).activeSchemeName;
+    if (!scheme) throw new Error("Xcode workspace has no active scheme");
+    const { stdout } = await import_internal3.exec(
+      "xcrun",
+      [
+        "xcodebuild",
+        /\.xcodeproj[\\/]?$/i.test(workspace) ? "-project" : "-workspace",
+        workspace,
+        "-scheme",
+        scheme,
+        "-destination",
+        `id=${device}`,
+        "-showBuildSettings",
+        "-json",
+      ],
+      { timeout: XcodeSession.TOOL_TIMEOUT_MS },
+    );
+    const apps = BuildSettings.parse(JSON.parse(stdout)).filter(
+      ({ buildSettings }) =>
+        buildSettings.PRODUCT_TYPE === "com.apple.product-type.application" &&
+        (!this.#appId ||
+          buildSettings.PRODUCT_BUNDLE_IDENTIFIER === this.#appId),
+    );
+    if (apps.length !== 1)
+      throw new Error(
+        "Xcode could not uniquely identify the active scheme's app",
+      );
+    this.#appId = import_zod2.z
+      .string()
+      .trim()
+      .min(1)
+      .parse(apps[0].buildSettings.PRODUCT_BUNDLE_IDENTIFIER);
+  }
+  async #installApp(device) {
+    const { appPath } = this.#props;
+    if (appPath) {
+      const { stdout } = await import_internal3.exec(
+        "/usr/libexec/PlistBuddy",
+        [
+          "-c",
+          "Print :CFBundleIdentifier",
+          import_node_path.default.join(appPath, "Info.plist"),
+        ],
+      );
+      this.#appId = import_zod2.z.string().trim().min(1).parse(stdout);
+      await import_internal3.exec(
+        "xcrun",
+        ["simctl", "install", device, appPath],
+        {
+          timeout: XcodeSession.TOOL_TIMEOUT_MS,
+        },
+      );
+    }
+  }
+  async #resetApp(device) {
+    if (!this.#appId)
+      throw new Error(
+        "Xcode could not determine the app bundle id for appReset",
+      );
+    if (this.#appId.toLowerCase() === "com.apple.springboard")
+      throw new Error("Xcode cannot reset SpringBoard");
+    const { stdout } = await import_internal3.exec("xcrun", [
+      "simctl",
+      "get_app_container",
+      device,
+      this.#appId,
+      "app",
+    ]);
+    const appPath = import_zod2.z.string().trim().min(1).parse(stdout);
+    const directory = await import_promises.mkdtemp(
+      import_node_path.default.join(
+        import_node_os.default.tmpdir(),
+        "alumnium-xcode-reset-",
+      ),
+    );
+    const savedApp = import_node_path.default.join(
+      directory,
+      import_node_path.default.basename(appPath),
+    );
+    try {
+      await import_promises.cp(appPath, savedApp, { recursive: true });
+      await import_internal3.exec("xcrun", [
+        "simctl",
+        "uninstall",
+        device,
+        this.#appId,
+      ]);
+      await import_internal3.exec(
+        "xcrun",
+        ["simctl", "install", device, savedApp],
+        {
+          timeout: XcodeSession.TOOL_TIMEOUT_MS,
+        },
+      );
+    } finally {
+      await import_promises.rm(directory, { recursive: true, force: true });
+    }
+  }
+  async #launchApp(device) {
+    const { launchArgs = [], launchEnv = {} } = this.#props;
+    if (!this.#appId) return;
+    await import_internal3.exec(
+      "xcrun",
+      [
+        "simctl",
+        "launch",
+        "--terminate-running-process",
+        device,
+        this.#appId,
+        ...launchArgs,
+      ],
+      {
+        env: {
+          ...process.env,
+          ...Object.fromEntries(
+            Object.entries(launchEnv).map(([key, value]) => [
+              `SIMCTL_CHILD_${key}`,
+              value,
+            ]),
+          ),
+        },
+      },
+    );
+  }
+  async capture(command, activationBundleId) {
+    if (!this.#key) throw new Error("Xcode session is not started");
+    const result = Capture.parse(
+      await this.#call("DeviceInteractionSynthesize", {
+        interactSessionKey: this.#key,
+        ...(command !== undefined && { interactionCommand: command }),
+        ...(activationBundleId && { activationBundleId }),
+      }),
+    );
+    if (!result.hierarchyPath) return this.#recapture();
+    return this.#readCapture(result);
+  }
+  async #recapture() {
+    const result = Capture.parse(
+      await this.#call("DeviceInteractionSynthesize", {
+        interactSessionKey: this.#key,
+      }),
+    );
+    if (!result.hierarchyPath)
+      throw new Error("Xcode could not capture the accessibility hierarchy");
+    return this.#readCapture(result);
+  }
+  async #readCapture(result) {
+    if (!result.hierarchyPath)
+      throw new Error("Xcode could not capture the accessibility hierarchy");
+    const source = await import_promises.readFile(
+      result.hierarchyPath,
+      "utf-8",
+    );
+    const tree = new XcodeAccessibilityTree(source);
+    if (!this.#props.appId && !this.#props.appPath)
+      this.#appId ||=
+        tree.find((node) => node.type === "Application")?.activationBundleId ??
+        "";
+    return { tree, screenshotPath: result.screenshotPath };
+  }
+  async screenshot() {
+    const { screenshotPath } = await this.capture();
+    return (await import_promises.readFile(screenshotPath)).toString("base64");
+  }
+  async close() {
+    this.#approving = false;
+    try {
+      if (this.#key) {
+        const key = this.#key;
+        this.#key = undefined;
+        await this.#call("DeviceInteractionEndSession", {
+          interactionSessionKey: key,
+        });
+      }
+    } finally {
+      try {
+        await this.#client.close();
+      } finally {
+        await this.#simulatorWindow.close();
+      }
+    }
+  }
+  async #call(name, args) {
+    const result = await this.#client.callTool(
+      { name, arguments: args },
+      undefined,
+      {
+        timeout: XcodeSession.TOOL_TIMEOUT_MS,
+      },
+    );
+    const content = import_zod2.z
+      .array(
+        import_zod2.z.object({
+          type: import_zod2.z.string(),
+          text: import_zod2.z.string().optional(),
+        }),
+      )
+      .parse(result.content);
+    const text = content
+      .filter((item) => item.type === "text")
+      .map((item) => item.text ?? "").join(`
+`);
+    if (result.isError) throw new Error(`Xcode ${name} failed: ${text}`);
+    return result.structuredContent ?? JSON.parse(text);
+  }
+}
+
+// xcode/src/Alumni.ts
+class Alumni extends import_core.Alumni {
+  constructor(driver, options = {}) {
+    super(new XcodeDriver(driver), options);
+  }
+  static accepts(driver) {
+    return driver instanceof XcodeSession;
+  }
+}
+
+//# debugId=B135B04791AA7C7E64756E2164756E21
+//# sourceMappingURL=index.cjs.map