@ycodium-ai/plugin-devices 0.2.3510 → 0.2.3576

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/index.ts
-import * as NodePath6 from "node:path";
+import * as NodePath9 from "node:path";
 import { definePlugin, PLUGIN_PROXY_DIRECT } from "@ycodium-ai/plugin-api";
 
 // src/types.ts
@@ -21,7 +21,7 @@ var errorDetail = (error) => {
 
 // src/deviceActionInput.ts
 var invalid = (field, rule) => new DeviceError("invalid-input", `Invalid ${field}: ${rule}.`);
-var unsupported = (operation, platform) => new DeviceError("action-unsupported", `Device ${operation} is not supported on ${platform}.`);
+var unsupported = (operation, platform2) => new DeviceError("action-unsupported", `Device ${operation} is not supported on ${platform2}.`);
 var DEVICE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
 var IOS_BUNDLE_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._-]{0,254}$/;
 var ANDROID_PACKAGE_PATTERN = /^[A-Za-z][A-Za-z0-9_]*(?:\.[A-Za-z][A-Za-z0-9_]*)*$/;
@@ -89,12 +89,12 @@ var assertDeviceId = (id) => {
   }
   return id;
 };
-var appId = (platform, input) => {
-  const ok = typeof input === "string" && (platform === "ios" ? IOS_BUNDLE_ID_PATTERN.test(input) : input.length <= MAX_ANDROID_PACKAGE_LENGTH && ANDROID_PACKAGE_PATTERN.test(input));
+var appId = (platform2, input) => {
+  const ok = typeof input === "string" && (platform2 === "ios" ? IOS_BUNDLE_ID_PATTERN.test(input) : input.length <= MAX_ANDROID_PACKAGE_LENGTH && ANDROID_PACKAGE_PATTERN.test(input));
   if (!ok) {
     throw invalid(
-      platform === "ios" ? "bundle id" : "package name",
-      platform === "ios" ? "expected letters, digits, dots, hyphens and underscores" : "expected a dotted Java package name"
+      platform2 === "ios" ? "bundle id" : "package name",
+      platform2 === "ios" ? "expected letters, digits, dots, hyphens and underscores" : "expected a dotted Java package name"
     );
   }
   return input;
@@ -120,7 +120,7 @@ var pushPayload = (input) => {
   }
   return encoded;
 };
-var parseDeviceAction = (platform, input) => {
+var parseDeviceAction = (platform2, input) => {
   if (!isRecord(input)) throw invalid("action", "expected an object");
   const type = oneOf(
     [
@@ -171,7 +171,7 @@ var parseDeviceAction = (platform, input) => {
     case "setPermission":
       return {
         type,
-        appId: appId(platform, input["appId"]),
+        appId: appId(platform2, input["appId"]),
         permission: oneOf(PERMISSIONS, input["permission"], "permission"),
         decision: oneOf(DECISIONS, input["decision"], "decision")
       };
@@ -179,11 +179,11 @@ var parseDeviceAction = (platform, input) => {
       return { type, url: url(input["url"]) };
     case "launchApp":
     case "terminateApp":
-      return { type, appId: appId(platform, input["appId"]) };
+      return { type, appId: appId(platform2, input["appId"]) };
     case "sendPush":
       return {
         type,
-        appId: appId(platform, input["appId"]),
+        appId: appId(platform2, input["appId"]),
         payload: input["payload"]
       };
   }
@@ -225,10 +225,10 @@ var ANDROID_TOGGLES = /* @__PURE__ */ new Set([
   "reduceMotion",
   "networkEnabled"
 ]);
-var supportsAction = (platform, action) => {
-  if (!(platform === "ios" ? IOS_ACTIONS : ANDROID_ACTIONS).has(action.type)) return false;
+var supportsAction = (platform2, action) => {
+  if (!(platform2 === "ios" ? IOS_ACTIONS : ANDROID_ACTIONS).has(action.type)) return false;
   if (action.type === "setToggle") {
-    return (platform === "ios" ? IOS_TOGGLES : ANDROID_TOGGLES).has(action.setting);
+    return (platform2 === "ios" ? IOS_TOGGLES : ANDROID_TOGGLES).has(action.setting);
   }
   return true;
 };
@@ -239,11 +239,11 @@ var target = {
   deviceId: { type: "string", minLength: 1, maxLength: 128 }
 };
 var appId2 = { type: "string", minLength: 1, maxLength: 255 };
-var branch = (type, properties = {}, required = []) => ({
+var branch = (type, properties2 = {}, required = []) => ({
   type: "object",
   additionalProperties: false,
   required: ["deviceId", "type", ...required],
-  properties: { ...target, type: { const: type }, ...properties }
+  properties: { ...target, type: { const: type }, ...properties2 }
 });
 var detailPayload = {
   type: "object",
@@ -373,9 +373,9 @@ var registerCommands = (ctx, service) => {
         if (!signal.aborted) emit(state);
       });
       try {
-        await new Promise((resolve) => {
-          if (signal.aborted) resolve();
-          else signal.addEventListener("abort", () => resolve(), { once: true });
+        await new Promise((resolve3) => {
+          if (signal.aborted) resolve3();
+          else signal.addEventListener("abort", () => resolve3(), { once: true });
         });
       } finally {
         unsubscribe();
@@ -462,7 +462,7 @@ var registerCommands = (ctx, service) => {
   });
   ctx.command({
     name: "updateTool",
-    description: "Install this plugin's pinned version of one device tool without starting it.",
+    description: "Verify this plugin's bundled version of one device tool without downloading or starting it.",
     scope: "operate",
     payloadSchema: updatePayload,
     handle: (payload) => service.updateTool(payload["tool"] === "agent" ? "agent" : "hub")
@@ -494,7 +494,7 @@ var registerCommands = (ctx, service) => {
   });
   ctx.stream({
     name: "updateTools",
-    description: "Settings card action: install the pinned device tool versions.",
+    description: "Settings card action: verify the bundled device tool versions.",
     scope: "operate",
     payloadSchema: emptyPayload,
     handle: async (_payload, emit) => {
@@ -537,41 +537,1029 @@ var registerCommands = (ctx, service) => {
   });
 };
 
+// src/environment.ts
+import * as NodeFSP3 from "node:fs/promises";
+import * as NodePath3 from "node:path";
+
+// src/androidPackages.ts
+var repo = "https://dl.google.com/android/repository/";
+var archive = (name, file, sha1, bytes, destination = "sdk") => ({ name, url: `${repo}${file}`, sha1, bytes, destination });
+var platformTools = {
+  linux: archive(
+    "Platform-Tools 37.0.1",
+    "platform-tools_r37.0.1-linux.zip",
+    "477254aa5f903c15cf51001717bdf347fb6b53e0",
+    9054187
+  ),
+  darwin: archive(
+    "Platform-Tools 37.0.1",
+    "platform-tools_r37.0.1-darwin.zip",
+    "6ae73f4de6452dc57e62ec02b68eed92a4c21661",
+    16110554
+  ),
+  win32: archive(
+    "Platform-Tools 37.0.1",
+    "platform-tools_r37.0.1-win.zip",
+    "e03e78b1d80b396f1c3358e31251cb31740e1110",
+    8044989
+  )
+};
+var emulators = {
+  "linux-x64": archive(
+    "Android Emulator 37.2.12",
+    "emulator-linux_x64-16428233.zip",
+    "cd7362ea55dfb86a418958138dc396e74165dd01",
+    349654171
+  ),
+  "darwin-x64": archive(
+    "Android Emulator 37.2.12",
+    "emulator-darwin_x64-16428233.zip",
+    "0c08fc22f41f2e63976f5503d593f821ff11e30b",
+    488731099
+  ),
+  "darwin-arm64": archive(
+    "Android Emulator 37.2.12",
+    "emulator-darwin_aarch64-16428233.zip",
+    "3af4fe44ce82b3d88ae5678a53735f27ad729c15",
+    416112708
+  ),
+  "win32-x64": archive(
+    "Android Emulator 37.2.12",
+    "emulator-windows_x64-16428233.zip",
+    "488ed747e82de7e9bb5247becd1ac043c7e5e85d",
+    455342868
+  )
+};
+var androidArchives = (platform2, arch2) => {
+  const emulator = emulators[`${platform2}-${arch2}`];
+  const tools = platformTools[platform2];
+  if (!emulator || !tools) return null;
+  const arm = arch2 === "arm64";
+  const image = archive(
+    "Android 15 (API 35), AOSP revision 2",
+    `sys-img/android/${arm ? "arm64-v8a" : "x86_64"}-35_r02.zip`,
+    arm ? "2026a06409db630b56711afdbffb457c1dbaed49" : "2d857d170c0d1b827149565da34b3383e5306f7f",
+    arm ? 769099654 : 782404023,
+    "image"
+  );
+  return [tools, emulator, image];
+};
+
+// src/environmentArchive.ts
+import * as NodeCrypto from "node:crypto";
+import * as NodeFS from "node:fs";
+import * as NodeFSP from "node:fs/promises";
+import * as NodePath from "node:path";
+import * as NodeStream from "node:stream";
+import * as NodeStreamPromises from "node:stream/promises";
+import * as NodeZlib from "node:zlib";
+var childPath = (root, name) => {
+  if (name.includes("\\") || name.includes("\0")) throw new Error("Invalid archive path");
+  const result = NodePath.resolve(root, name);
+  if (!result.startsWith(`${NodePath.resolve(root)}${NodePath.sep}`))
+    throw new Error("Archive path escapes its destination");
+  return result;
+};
+var downloadArchive = async (item, directory, fetch) => {
+  await NodeFSP.mkdir(directory, { recursive: true });
+  const target2 = NodePath.join(directory, item.url.split("/").at(-1));
+  if ((await NodeFSP.lstat(target2).catch(() => null))?.isSymbolicLink())
+    throw new Error("Download cache entry must not be linked");
+  const verify = async () => {
+    const hash = NodeCrypto.createHash("sha1");
+    let size = 0;
+    for await (const bytes of NodeFS.createReadStream(target2)) {
+      hash.update(bytes);
+      size += bytes.length;
+    }
+    return size === item.bytes && hash.digest("hex") === item.sha1;
+  };
+  try {
+    if (await verify()) return target2;
+  } catch {
+  }
+  const temporary = `${target2}.${NodeCrypto.randomUUID()}.partial`;
+  try {
+    const response = await fetch(item.url);
+    if (!response.ok || !response.body)
+      throw new Error(`Downloading ${item.name} failed: HTTP ${response.status}`);
+    let size = 0;
+    const hash = NodeCrypto.createHash("sha1");
+    const meter = new NodeStream.Transform({
+      transform(chunk, _encoding, callback) {
+        size += chunk.length;
+        if (size > item.bytes) {
+          callback(new Error("Archive size exceeds the pinned length"));
+          return;
+        }
+        hash.update(chunk);
+        callback(null, chunk);
+      }
+    });
+    const body = response.body;
+    const chunks = async function* () {
+      const reader = body.getReader();
+      try {
+        while (true) {
+          const item2 = await reader.read();
+          if (item2.done) break;
+          yield item2.value;
+        }
+      } finally {
+        await reader.cancel().catch(() => void 0);
+        reader.releaseLock();
+      }
+    };
+    await NodeStreamPromises.pipeline(
+      NodeStream.Readable.from(chunks()),
+      meter,
+      NodeFS.createWriteStream(temporary, { flags: "wx" })
+    );
+    if (size !== item.bytes || hash.digest("hex") !== item.sha1)
+      throw new Error(`Integrity check failed for ${item.name}`);
+    await NodeFSP.rename(temporary, target2);
+    return target2;
+  } finally {
+    await NodeFSP.rm(temporary, { force: true });
+  }
+};
+var extractEnvironmentZip = async (file, destination, signal) => {
+  const handle = await NodeFSP.open(file, "r");
+  try {
+    const size = (await handle.stat()).size;
+    const tail = Buffer.alloc(Math.min(size, 65557));
+    await handle.read(tail, 0, tail.length, size - tail.length);
+    let end = tail.length - 22;
+    while (end >= 0 && tail.readUInt32LE(end) !== 101010256) end--;
+    if (end < 0) throw new Error("ZIP end record missing");
+    const count = tail.readUInt16LE(end + 10);
+    const centralSize = tail.readUInt32LE(end + 12);
+    const centralOffset = tail.readUInt32LE(end + 16);
+    if (count === 65535 || centralSize > 32 * 1024 * 1024 || centralOffset + centralSize > size)
+      throw new Error("Unsupported ZIP directory");
+    const directory = Buffer.alloc(centralSize);
+    await handle.read(directory, 0, centralSize, centralOffset);
+    let offset = 0;
+    for (let index = 0; index < count; index++) {
+      signal?.throwIfAborted();
+      if (directory.readUInt32LE(offset) !== 33639248)
+        throw new Error("Invalid ZIP directory entry");
+      const flags = directory.readUInt16LE(offset + 8);
+      const method = directory.readUInt16LE(offset + 10);
+      const compressed = directory.readUInt32LE(offset + 20);
+      const unpacked = directory.readUInt32LE(offset + 24);
+      const nameLength = directory.readUInt16LE(offset + 28);
+      const extraLength = directory.readUInt16LE(offset + 30);
+      const commentLength = directory.readUInt16LE(offset + 32);
+      const mode = directory.readUInt32LE(offset + 38) >>> 16;
+      const localOffset = directory.readUInt32LE(offset + 42);
+      const name = directory.subarray(offset + 46, offset + 46 + nameLength).toString("utf8");
+      offset += 46 + nameLength + extraLength + commentLength;
+      if (flags & 1 || ![0, 8].includes(method) || localOffset >= centralOffset)
+        throw new Error("Unsupported ZIP entry");
+      const target2 = childPath(destination, name);
+      if (name.endsWith("/")) {
+        await NodeFSP.mkdir(target2, { recursive: true });
+        continue;
+      }
+      await NodeFSP.mkdir(NodePath.dirname(target2), { recursive: true });
+      const header = Buffer.alloc(30);
+      await handle.read(header, 0, 30, localOffset);
+      if (header.readUInt32LE(0) !== 67324752) throw new Error("Invalid ZIP local header");
+      const dataOffset = localOffset + 30 + header.readUInt16LE(26) + header.readUInt16LE(28);
+      if (dataOffset + compressed > centralOffset)
+        throw new Error("ZIP data exceeds archive bounds");
+      const source = compressed ? NodeFS.createReadStream(file, { start: dataOffset, end: dataOffset + compressed - 1 }) : NodeStream.Readable.from([]);
+      const transforms = method === 8 ? [NodeZlib.createInflateRaw()] : [];
+      if ((mode & 61440) === 40960) {
+        if (unpacked > 4096) throw new Error("Invalid ZIP symbolic link");
+        const chunks = [];
+        let length = 0;
+        const collect = new NodeStream.Writable({
+          write(chunk, _encoding, callback) {
+            length += chunk.length;
+            if (length > 4096) {
+              callback(new Error("Invalid ZIP symbolic link"));
+              return;
+            }
+            chunks.push(Buffer.from(chunk));
+            callback();
+          }
+        });
+        await NodeStreamPromises.pipeline([source, ...transforms, collect], { signal });
+        const link = Buffer.concat(chunks).toString("utf8");
+        childPath(
+          destination,
+          NodePath.relative(destination, NodePath.resolve(NodePath.dirname(target2), link)).split(NodePath.sep).join("/")
+        );
+        await NodeFSP.symlink(link, target2);
+      } else {
+        let written = 0;
+        const limit = new NodeStream.Transform({
+          transform(chunk, _encoding, callback) {
+            written += chunk.length;
+            callback(
+              written > unpacked ? new Error("ZIP expands beyond its declared size") : null,
+              chunk
+            );
+          }
+        });
+        await NodeStreamPromises.pipeline(
+          [
+            source,
+            ...transforms,
+            limit,
+            NodeFS.createWriteStream(target2, { flags: "wx", mode: mode & 511 || 420 })
+          ],
+          { signal }
+        );
+        if (written !== unpacked) throw new Error("ZIP uncompressed length mismatch");
+      }
+    }
+  } finally {
+    await handle.close();
+  }
+};
+
+// src/environmentStorage.ts
+import * as NodeFSP2 from "node:fs/promises";
+import * as NodePath2 from "node:path";
+var ENVIRONMENT_MARKER = ".ycodium-devices-environment.json";
+var ANDROID_ENVIRONMENT_VERSION = "Android 15 / API 35 \xB7 Emulator 37.2.12";
+var environmentPaths = (root) => ({
+  root,
+  sdk: NodePath2.join(root, "sdk"),
+  user: NodePath2.join(root, "user"),
+  avd: NodePath2.join(root, "avd"),
+  temp: NodePath2.join(root, "temp"),
+  cache: NodePath2.join(root, "cache")
+});
+var environmentRoot = (dataDir, platform2, directory) => {
+  if (directory?.trim()) {
+    if (!NodePath2.isAbsolute(directory.trim()))
+      throw new Error("Choose an absolute directory on this machine");
+    return NodePath2.join(NodePath2.resolve(directory.trim()), `ycodium-devices-${platform2}`);
+  }
+  return NodePath2.join(dataDir, "environments", platform2);
+};
+var assertOwnedEnvironment = async (root) => {
+  const stat = await NodeFSP2.lstat(root);
+  if (!stat.isDirectory() || stat.isSymbolicLink())
+    throw new Error("Environment root is not a private directory");
+  if ((await NodeFSP2.lstat(NodePath2.join(root, ENVIRONMENT_MARKER))).isSymbolicLink())
+    throw new Error("Environment ownership record must not be linked");
+  const record = JSON.parse(
+    await NodeFSP2.readFile(NodePath2.join(root, ENVIRONMENT_MARKER), "utf8")
+  );
+  if (typeof record !== "object" || record === null || !("owner" in record) || record.owner !== "ycodium-devices" || !("sdk" in record) || record.sdk !== NodePath2.join(root, "sdk"))
+    throw new Error("Directory is not owned by the Devices plugin");
+};
+var assertPrivatePath = async (root, target2) => {
+  const relative3 = NodePath2.relative(NodePath2.resolve(root), NodePath2.resolve(target2));
+  if (!relative3 || relative3.startsWith(`..${NodePath2.sep}`) || relative3 === ".." || NodePath2.isAbsolute(relative3))
+    throw new Error("Private path escapes its environment");
+  let current = root;
+  for (const part of relative3.split(NodePath2.sep)) {
+    current = NodePath2.join(current, part);
+    const stat = await NodeFSP2.lstat(current).catch((error) => {
+      if (error instanceof Error && "code" in error && error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (!stat) break;
+    if (stat.isSymbolicLink()) throw new Error("Refusing a linked private environment path");
+  }
+};
+var assertPrivateEnvironmentPaths = async (root) => {
+  await assertOwnedEnvironment(root);
+  for (const name of ["sdk", "avd", "cache", "temp", "user", "home", "config", ".prepared"])
+    await assertPrivatePath(root, NodePath2.join(root, name));
+};
+var claimEnvironment = async (root) => {
+  let owned = false;
+  try {
+    await assertOwnedEnvironment(root);
+    owned = true;
+  } catch {
+  }
+  if (owned) {
+    await assertPrivateEnvironmentPaths(root);
+    return;
+  }
+  await NodeFSP2.mkdir(root, { recursive: true });
+  if ((await NodeFSP2.lstat(root)).isSymbolicLink() || (await NodeFSP2.readdir(root)).length !== 0)
+    throw new Error("Choose an empty directory; existing files will not be changed");
+  await NodeFSP2.writeFile(
+    NodePath2.join(root, ENVIRONMENT_MARKER),
+    JSON.stringify({ owner: "ycodium-devices", sdk: NodePath2.join(root, "sdk") }),
+    { flag: "wx" }
+  );
+};
+var directoryBytes = async (root) => {
+  try {
+    const stat = await NodeFSP2.lstat(root);
+    if (stat.isSymbolicLink()) return 0;
+    if (!stat.isDirectory()) return stat.size;
+    const children = await NodeFSP2.readdir(root);
+    let total = 0;
+    for (const child of children) total += await directoryBytes(NodePath2.join(root, child));
+    return total;
+  } catch {
+    return 0;
+  }
+};
+var freeBytes = async (root) => {
+  let probe = root;
+  while (true) {
+    try {
+      const stat = await NodeFSP2.statfs(probe);
+      return stat.bavail * stat.bsize;
+    } catch {
+    }
+    const parent = NodePath2.dirname(probe);
+    if (parent === probe) return null;
+    probe = parent;
+  }
+};
+var selectedPrivateRoot = async (dataDir) => {
+  try {
+    const record = JSON.parse(
+      await NodeFSP2.readFile(NodePath2.join(dataDir, "android-environment.json"), "utf8")
+    );
+    if (typeof record !== "object" || record === null || !("root" in record) || typeof record.root !== "string")
+      return null;
+    await assertOwnedEnvironment(record.root);
+    return record.root;
+  } catch {
+    return null;
+  }
+};
+var selectedPrivateSdk = async (dataDir) => {
+  const root = await selectedPrivateRoot(dataDir);
+  if (!root) return null;
+  return await privateEnvironmentReady(root) ? NodePath2.join(root, "sdk") : null;
+};
+var privateEnvironmentReady = async (root) => {
+  try {
+    await assertPrivateEnvironmentPaths(root);
+    const paths = environmentPaths(root);
+    if (await NodeFSP2.readFile(NodePath2.join(root, ".prepared"), "utf8") !== ANDROID_ENVIRONMENT_VERSION || await NodeFSP2.readFile(NodePath2.join(paths.sdk, ".ycodium-components"), "utf8") !== ANDROID_ENVIRONMENT_VERSION)
+      return false;
+    const avd = NodePath2.join(paths.avd, "Ycodium_API_35.avd");
+    await assertPrivatePath(root, NodePath2.join(avd, "config.ini"));
+    await assertPrivatePath(root, NodePath2.join(paths.avd, "Ycodium_API_35.ini"));
+    const config = await NodeFSP2.readFile(NodePath2.join(avd, "config.ini"), "utf8");
+    const image = /^image\.sysdir\.1=(system-images\/android-35\/default\/(?:x86_64|arm64-v8a)\/)\r?$/m.exec(
+      config
+    )?.[1];
+    if (!image) return false;
+    await assertPrivatePath(root, NodePath2.join(paths.sdk, image, "system.img"));
+    await NodeFSP2.access(NodePath2.join(paths.sdk, image, "system.img"));
+    if (!(await NodeFSP2.readFile(NodePath2.join(paths.avd, "Ycodium_API_35.ini"), "utf8")).includes(
+      `path=${avd}
+`
+    ))
+      return false;
+    for (const suffix of ["", ".exe"]) {
+      try {
+        await NodeFSP2.access(NodePath2.join(paths.sdk, "platform-tools", `adb${suffix}`));
+        await NodeFSP2.access(NodePath2.join(paths.sdk, "emulator", `emulator${suffix}`));
+        return true;
+      } catch {
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+};
+var cleanEnvironment = async (root, category) => {
+  await assertPrivateEnvironmentPaths(root);
+  const target2 = NodePath2.resolve(root, category === "cache" ? "cache" : "avd");
+  if (NodePath2.dirname(target2) !== NodePath2.resolve(root))
+    throw new Error("Cleanup escaped the private environment");
+  const bytes = await directoryBytes(target2);
+  if (category === "devices") {
+    const devices = await NodeFSP2.readdir(target2).catch(() => []);
+    for (const name of devices) {
+      if (name.endsWith(".lock"))
+        throw new Error("Power off private virtual devices before deleting their data");
+      if (!name.endsWith(".avd")) continue;
+      if ((await NodeFSP2.lstat(NodePath2.join(target2, name))).isSymbolicLink())
+        throw new Error("Cleanup refuses a linked virtual device");
+      const entries = await NodeFSP2.readdir(NodePath2.join(target2, name));
+      if (entries.some((entry) => entry.endsWith(".lock")))
+        throw new Error("Power off private virtual devices before deleting their data");
+    }
+  }
+  const stat = await NodeFSP2.lstat(target2).catch(() => null);
+  if (stat?.isSymbolicLink()) throw new Error("Cleanup refuses a linked directory");
+  await NodeFSP2.rm(target2, { recursive: true, force: true });
+  if (category === "devices") await NodeFSP2.rm(NodePath2.join(root, ".prepared"), { force: true });
+  return bytes;
+};
+
+// src/environment.ts
+var GIB = 1024 ** 3;
+var androidGuide = "https://developer.android.com/studio/run/emulator-acceleration";
+var appleGuide = "https://developer.apple.com/documentation/xcode/downloading-and-installing-additional-xcode-components";
+var DeviceEnvironments = class {
+  busy = false;
+  abort = new AbortController();
+  progress = { status: "idle" };
+  listeners = /* @__PURE__ */ new Set();
+  active = null;
+  nextJobId = 1;
+  options;
+  constructor(options) {
+    this.options = options;
+  }
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.progress);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  }
+  publish(progress) {
+    this.progress = progress;
+    for (const listener of this.listeners) listener(progress);
+  }
+  start(input) {
+    if (this.busy)
+      throw new DeviceError("invalid-input", "Another simulator preparation is already running");
+    const id = this.nextJobId++;
+    this.publish({ id, status: "working" });
+    this.active = this.prepare(
+      input,
+      (stage) => this.publish({ id, status: "working", stage })
+    ).then(
+      (plan) => this.publish({ id, status: "done", plan }),
+      (error) => {
+        this.options.log?.warn("Simulator preparation failed", {
+          detail: error instanceof Error ? error.message : String(error)
+        });
+        this.publish({ id, status: "failed" });
+      }
+    );
+    return this.progress;
+  }
+  async dispose() {
+    this.abort.abort();
+    await this.active;
+    this.listeners.clear();
+  }
+  async probe() {
+    const result = await this.options.process.run({
+      program: "host:node",
+      args: [
+        this.options.helperPath,
+        "environment-probe",
+        ...this.options.runtimeDir ? ["--tools", this.options.runtimeDir] : []
+      ],
+      cwd: this.options.dataDir,
+      timeoutMs: 6e4
+    });
+    if (result.exitCode !== 0)
+      throw new Error("Could not inspect the machine's simulator prerequisites");
+    const probe = JSON.parse(result.stdout.trim().split(/\r?\n/).at(-1) ?? "");
+    if (typeof probe !== "object" || probe === null || !("platform" in probe) || !("arch" in probe) || !("virtualization" in probe) || !("xcode" in probe))
+      throw new Error("Invalid simulator prerequisite report");
+    return probe;
+  }
+  async plan(input) {
+    const probe = await this.probe();
+    const selected = input.platform === "android" && !input.directory?.trim() ? await selectedPrivateRoot(this.options.dataDir) : null;
+    const root = selected ?? environmentRoot(this.options.dataDir, input.platform, input.directory);
+    const paths = environmentPaths(root);
+    const [free, cacheBytes, deviceDataBytes] = await Promise.all([
+      freeBytes(root),
+      directoryBytes(paths.cache),
+      directoryBytes(paths.avd)
+    ]);
+    if (input.platform === "ios") {
+      const version = input.version?.trim() ?? "";
+      const runtimePresent = probe.xcode.runtimes.some((runtime) => runtime.version === version);
+      return {
+        platform: "ios",
+        supported: probe.platform === "darwin" && probe.iosToolsAvailable !== false && probe.xcode.ready,
+        source: "apple",
+        root,
+        version,
+        downloadBytes: null,
+        requiredFreeBytes: 20 * GIB,
+        freeBytes: free,
+        ready: runtimePresent,
+        ...probe.platform === "darwin" && probe.iosToolsAvailable === false ? { reasonCode: "ios-tools-missing" } : !probe.xcode.ready ? { reasonCode: probe.xcode.reasonCode ?? "xcode-incomplete" } : !version ? { reasonCode: "ios-version-required" } : {},
+        licenses: [{ url: "https://www.apple.com/legal/sla/" }],
+        guidanceUrl: appleGuide,
+        cacheBytes,
+        deviceDataBytes
+      };
+    }
+    const archives = androidArchives(probe.platform, probe.arch);
+    const sdk = await this.options.externalSdk();
+    const prepared = await privateEnvironmentReady(root);
+    return {
+      platform: "android",
+      supported: archives !== null && probe.virtualization.available,
+      source: sdk.available && sdk.root !== paths.sdk ? "external" : "private",
+      ...sdk.available && sdk.root ? { existingSdkRoot: sdk.root } : {},
+      root,
+      version: ANDROID_ENVIRONMENT_VERSION,
+      downloadBytes: archives?.reduce((sum, item) => sum + item.bytes, 0) ?? null,
+      requiredFreeBytes: 12 * GIB,
+      freeBytes: free,
+      ready: sdk.available && (sdk.root !== paths.sdk || prepared),
+      ...!archives ? { reasonCode: "android-platform-unsupported" } : !probe.virtualization.available ? { reasonCode: probe.virtualization.reasonCode ?? "virtualization-unavailable" } : {},
+      licenses: [
+        {
+          url: "https://developer.android.com/studio/terms"
+        }
+      ],
+      guidanceUrl: androidGuide,
+      cacheBytes,
+      deviceDataBytes
+    };
+  }
+  async exclusively(operation) {
+    if (this.busy)
+      throw new DeviceError(
+        "invalid-input",
+        "Another simulator preparation or cleanup is already running"
+      );
+    this.busy = true;
+    try {
+      return await operation();
+    } finally {
+      this.busy = false;
+    }
+  }
+  async prepare(input, progress = () => void 0) {
+    return this.exclusively(async () => {
+      const plan = await this.plan(input);
+      this.abort.signal.throwIfAborted();
+      if (!input.acceptLicenses)
+        throw new DeviceError(
+          "invalid-input",
+          "Accept the component licenses before preparing a simulator"
+        );
+      if (!plan.supported)
+        throw new DeviceError(
+          "platform-unavailable",
+          `Simulator preparation is unavailable: ${plan.reasonCode ?? "unsupported platform"}. See ${plan.guidanceUrl}`
+        );
+      if (plan.freeBytes === null || plan.freeBytes < plan.requiredFreeBytes)
+        throw new DeviceError(
+          "boot-disk-space",
+          "There is not enough free disk space to prepare this simulator"
+        );
+      if (input.platform === "ios" && (!input.confirmAppleInstall || !/^\d+\.\d+(?:\.\d+)?$/.test(plan.version)))
+        throw new DeviceError(
+          "invalid-input",
+          "Choose an explicit iOS version and confirm installation into Apple's shared simulator environment"
+        );
+      const release = await this.options.beforeMutation();
+      try {
+        await claimEnvironment(plan.root);
+        await assertPrivateEnvironmentPaths(plan.root);
+        const paths = environmentPaths(plan.root);
+        for (const directory of [
+          paths.cache,
+          paths.temp,
+          paths.user,
+          NodePath3.join(plan.root, "home"),
+          NodePath3.join(plan.root, "config")
+        ])
+          await NodeFSP3.mkdir(directory, { recursive: true });
+        if (input.platform === "ios") await this.prepareIos(plan, progress);
+        else await this.prepareAndroid(plan, progress);
+      } finally {
+        await release?.();
+      }
+      await this.options.afterPrepared();
+      return this.plan(input);
+    });
+  }
+  async prepareAndroid(plan, progress) {
+    const probe = await this.probe();
+    const archives = androidArchives(probe.platform, probe.arch);
+    if (!archives) throw new Error("Android host target is unsupported");
+    const paths = environmentPaths(plan.root);
+    const staging = await NodeFSP3.mkdtemp(NodePath3.join(paths.temp, "prepare-"));
+    try {
+      const existing2 = await NodeFSP3.lstat(paths.sdk).catch(() => null);
+      if (existing2) {
+        if (existing2.isSymbolicLink() || !existing2.isDirectory() || await NodeFSP3.readFile(NodePath3.join(paths.sdk, ".ycodium-components"), "utf8").catch(
+          () => ""
+        ) !== plan.version)
+          throw new Error(
+            "An unrecognized private SDK already exists; its installation will not be overwritten"
+          );
+      } else {
+        for (const item of archives) {
+          progress(item.name);
+          this.abort.signal.throwIfAborted();
+          const file = await downloadArchive(
+            item,
+            paths.cache,
+            (url2, init) => this.options.fetch(url2, { ...init, signal: this.abort.signal })
+          );
+          await extractEnvironmentZip(
+            file,
+            item.destination === "sdk" ? staging : NodePath3.join(staging, "system-images", "android-35", "default"),
+            this.abort.signal
+          );
+        }
+        await NodeFSP3.writeFile(NodePath3.join(staging, ".ycodium-components"), plan.version);
+        await NodeFSP3.rename(staging, paths.sdk);
+      }
+      await this.createPrivateAvd(paths.root, probe.arch === "arm64" ? "arm64-v8a" : "x86_64");
+      this.abort.signal.throwIfAborted();
+      progress("validate");
+      const validated = await this.options.process.run({
+        program: "host:node",
+        args: [this.options.helperPath, "validate-android", "--sdk", paths.sdk],
+        cwd: this.options.dataDir,
+        timeoutMs: 6e4
+      });
+      if (validated.exitCode !== 0)
+        throw new Error(`The private SDK could not be validated. ${validated.stderr.trim()}`);
+      await NodeFSP3.writeFile(NodePath3.join(plan.root, ".prepared"), plan.version);
+      await NodeFSP3.writeFile(
+        NodePath3.join(this.options.dataDir, "android-environment.json"),
+        JSON.stringify({ root: plan.root })
+      );
+    } finally {
+      await NodeFSP3.rm(staging, { recursive: true, force: true });
+    }
+  }
+  async createPrivateAvd(root, abi) {
+    const paths = environmentPaths(root);
+    const name = "Ycodium_API_35";
+    const avd = NodePath3.join(paths.avd, `${name}.avd`);
+    await assertPrivatePath(root, avd);
+    await assertPrivatePath(root, NodePath3.join(paths.avd, `${name}.ini`));
+    const existing2 = await NodeFSP3.lstat(avd).catch(() => null);
+    if (existing2) {
+      if (existing2.isSymbolicLink() || !existing2.isDirectory())
+        throw new Error("Private virtual device is not a directory");
+      await NodeFSP3.access(NodePath3.join(avd, "config.ini"));
+      await NodeFSP3.access(NodePath3.join(paths.avd, `${name}.ini`));
+      return;
+    }
+    await NodeFSP3.mkdir(avd, { recursive: true });
+    const config = {
+      AvdId: name,
+      "avd.ini.displayname": "Ycodium Android 15",
+      "abi.type": abi,
+      "hw.cpu.arch": abi === "arm64-v8a" ? "arm64" : "x86_64",
+      "hw.cpu.ncore": "2",
+      "hw.ramSize": "2048",
+      "hw.lcd.width": "1080",
+      "hw.lcd.height": "1920",
+      "hw.lcd.density": "420",
+      "hw.gpu.enabled": "yes",
+      "hw.gpu.mode": "auto",
+      "hw.keyboard": "yes",
+      "disk.dataPartition.size": "4G",
+      "image.sysdir.1": `system-images/android-35/default/${abi}/`,
+      "tag.id": "default",
+      "tag.display": "Default Android System Image",
+      "PlayStore.enabled": "false"
+    };
+    await NodeFSP3.writeFile(
+      NodePath3.join(avd, "config.ini"),
+      Object.entries(config).map(([key2, value]) => `${key2}=${value}`).join("\n") + "\n",
+      { flag: "wx" }
+    );
+    await NodeFSP3.writeFile(
+      NodePath3.join(paths.avd, `${name}.ini`),
+      `avd.ini.encoding=UTF-8
+path=${avd}
+target=android-35
+`,
+      { flag: "wx" }
+    );
+  }
+  async prepareIos(plan, progress) {
+    if (plan.ready) return;
+    const cache = NodePath3.join(plan.root, "cache", `ios-${plan.version}`);
+    await NodeFSP3.mkdir(cache, { recursive: true });
+    progress(`iOS ${plan.version}`);
+    if (await this.runApple([
+      "-downloadPlatform",
+      "iOS",
+      "-exportPath",
+      cache,
+      "-buildVersion",
+      plan.version
+    ]) !== 0)
+      throw new Error(
+        "Apple could not download this iOS runtime; check the selected Xcode version, network and Apple account in Xcode"
+      );
+    const names = (await NodeFSP3.readdir(cache)).filter((name) => name.endsWith(".dmg"));
+    if (names.length !== 1)
+      throw new Error("Apple did not return a unique simulator runtime archive");
+    progress("apple-install");
+    if (await this.runApple(["-importPlatform", NodePath3.join(cache, names[0])]) !== 0)
+      throw new Error(
+        "Apple could not import the runtime. Complete any required permissions in Xcode; Ycodium will not elevate privileges"
+      );
+    if (!(await this.probe()).xcode.runtimes.some((runtime) => runtime.version === plan.version))
+      throw new Error("The requested iOS runtime is still unavailable after Apple's import");
+  }
+  async runApple(args) {
+    this.abort.signal.throwIfAborted();
+    const handle = await this.options.process.spawn({
+      program: "host:node",
+      args: [this.options.helperPath, "run", "--", "xcodebuild", ...args],
+      cwd: this.options.dataDir
+    });
+    const signal = AbortSignal.any([this.abort.signal, AbortSignal.timeout(36e5)]);
+    const terminate = () => {
+      void handle.kill().catch(() => void 0);
+    };
+    signal.addEventListener("abort", terminate, { once: true });
+    if (signal.aborted) terminate();
+    const drain = async (stream) => {
+      for await (const _chunk of stream) {
+      }
+    };
+    try {
+      const [code] = await Promise.all([handle.exited, drain(handle.stdout), drain(handle.stderr)]);
+      signal.throwIfAborted();
+      return code;
+    } finally {
+      signal.removeEventListener("abort", terminate);
+    }
+  }
+  cleanup(input) {
+    return this.exclusively(async () => {
+      if (!input.confirm || input.platform === "ios" && input.category === "devices")
+        throw new DeviceError(
+          "invalid-input",
+          "Confirm cleanup of private download cache or Android virtual device data; Apple runtimes are managed in Xcode"
+        );
+      const release = input.category === "devices" ? await this.options.beforeMutation() : void 0;
+      try {
+        const plan = await this.plan(input);
+        const releasedBytes = await cleanEnvironment(plan.root, input.category);
+        await this.options.afterPrepared();
+        return { releasedBytes };
+      } finally {
+        await release?.();
+      }
+    });
+  }
+};
+
+// src/environmentCommands.ts
+var properties = {
+  platform: { type: "string", enum: ["android", "ios"] },
+  directory: { type: "string" },
+  version: { type: "string" }
+};
+var schema = (extra = {}, required = []) => ({
+  type: "object",
+  additionalProperties: false,
+  properties: { ...properties, ...extra },
+  required: ["platform", ...required]
+});
+var request = (payload) => ({
+  platform: payload["platform"] === "ios" ? "ios" : "android",
+  ...typeof payload["directory"] === "string" ? { directory: payload["directory"] } : {},
+  ...typeof payload["version"] === "string" ? { version: payload["version"] } : {}
+});
+var registerEnvironmentCommands = (ctx, environments) => {
+  ctx.command({
+    name: "environmentPlan",
+    description: "Inspect simulator prerequisites, selected storage, download size and licenses without downloading or modifying the machine.",
+    scope: "read",
+    payloadSchema: schema(),
+    handle: (payload) => environments.plan(request(payload))
+  });
+  ctx.command({
+    name: "prepareEnvironment",
+    description: "Start user-triggered simulator preparation. Progress is read from environmentProgress; command completion only acknowledges the request.",
+    scope: "operate",
+    payloadSchema: schema(
+      { acceptLicenses: { type: "boolean" }, confirmAppleInstall: { type: "boolean" } },
+      ["acceptLicenses", "confirmAppleInstall"]
+    ),
+    handle: (payload) => environments.start({
+      ...request(payload),
+      acceptLicenses: payload["acceptLicenses"] === true,
+      confirmAppleInstall: payload["confirmAppleInstall"] === true
+    })
+  });
+  ctx.stream({
+    name: "environmentProgress",
+    description: "Current user-triggered simulator preparation progress; subscribing does not start preparation.",
+    scope: "read",
+    payloadSchema: { type: "object", properties: {}, additionalProperties: false },
+    handle: async (_payload, emit, signal) => {
+      const unsubscribe = environments.subscribe((progress) => {
+        if (!signal.aborted) emit(progress);
+      });
+      try {
+        await new Promise((resolve3) => {
+          if (signal.aborted) resolve3();
+          else signal.addEventListener("abort", () => resolve3(), { once: true });
+        });
+      } finally {
+        unsubscribe();
+      }
+    }
+  });
+  ctx.command({
+    name: "cleanupEnvironment",
+    description: "User-confirmed cleanup of private download cache or Android virtual device data. Never deletes external SDKs, external virtual devices or Apple runtimes.",
+    scope: "operate",
+    payloadSchema: schema(
+      { category: { type: "string", enum: ["cache", "devices"] }, confirm: { type: "boolean" } },
+      ["category", "confirm"]
+    ),
+    handle: (payload) => environments.cleanup({
+      ...request(payload),
+      category: payload["category"] === "devices" ? "devices" : "cache",
+      confirm: payload["confirm"] === true
+    })
+  });
+};
+
+// src/probe.ts
+var MIN_NODE_VERSION = [22, 12, 0];
+var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var parseMachineProbe = (stdout) => {
+  const line = stdout.trim().split(/\r?\n/).at(-1) ?? "";
+  let value;
+  try {
+    value = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (!isRecord2(value) || !isRecord2(value["android"])) return null;
+  const android = value["android"];
+  if (typeof value["node"] !== "string" || typeof value["execPath"] !== "string" || typeof value["platform"] !== "string") {
+    return null;
+  }
+  return {
+    node: value["node"],
+    execPath: value["execPath"],
+    electron: typeof value["electron"] === "string" ? value["electron"] : null,
+    platform: value["platform"],
+    ...typeof value["arch"] === "string" ? { arch: value["arch"] } : {},
+    xcrun: value["xcrun"] === true,
+    ...typeof value["androidValidated"] === "boolean" ? { androidValidated: value["androidValidated"] } : {},
+    ...typeof value["iosRuntimeAvailable"] === "boolean" ? { iosRuntimeAvailable: value["iosRuntimeAvailable"] } : {},
+    ...typeof value["iosToolsAvailable"] === "boolean" ? { iosToolsAvailable: value["iosToolsAvailable"] } : {},
+    android: {
+      root: typeof android["root"] === "string" ? android["root"] : null,
+      adb: android["adb"] === true,
+      emulator: android["emulator"] === true,
+      avdmanager: android["avdmanager"] === true,
+      legacyAvdmanager: android["legacyAvdmanager"] === true
+    }
+  };
+};
+var nodeVersionSupported = (version) => {
+  const match = /^v?(\d+)\.(\d+)\.(\d+)/.exec(version);
+  if (!match) return false;
+  const parts = [Number(match[1]), Number(match[2]), Number(match[3])];
+  for (let index = 0; index < MIN_NODE_VERSION.length; index += 1) {
+    const actual = parts[index];
+    const required = MIN_NODE_VERSION[index];
+    if (actual !== required) return actual > required;
+  }
+  return true;
+};
+var unavailable = (platform2, reasonCode, reason, sdkRoot) => ({
+  platform: platform2,
+  available: false,
+  reasonCode,
+  reason,
+  ...sdkRoot === void 0 ? {} : { sdkRoot }
+});
+var platformAvailability = (probe, platform2) => {
+  if (platform2 === "ios") {
+    if (probe.platform !== "darwin") {
+      return unavailable("ios", "ios-needs-macos", "iOS Simulators need macOS with Xcode.");
+    }
+    if (probe.iosToolsAvailable === false)
+      return unavailable(
+        "ios",
+        "ios-tools-missing",
+        "The bundled iOS Simulator streaming helpers are missing or could not load. Repair or update Ycodium on this machine."
+      );
+    if (!probe.xcrun) {
+      return unavailable("ios", "xcode-missing", "Xcode command line tools were not found.");
+    }
+    if (probe.iosRuntimeAvailable === false)
+      return unavailable(
+        "ios",
+        "ios-runtime-missing",
+        "An iOS Simulator runtime is missing. Choose an explicit version in simulator preparation or install one in Xcode Settings."
+      );
+    return { platform: platform2, available: true };
+  }
+  const sdk = probe.android;
+  if (!sdk.root) {
+    return unavailable(
+      "android",
+      "android-sdk-missing",
+      "Android SDK was not found. Install it with Android Studio or set its location in the Devices settings."
+    );
+  }
+  if (!sdk.adb) {
+    return unavailable(
+      "android",
+      "android-platform-tools-missing",
+      `Android SDK Platform-Tools are missing from ${sdk.root}. Install them in Android Studio's SDK Manager.`,
+      sdk.root
+    );
+  }
+  if (!sdk.emulator) {
+    return unavailable(
+      "android",
+      "android-emulator-missing",
+      `Android Emulator is missing from ${sdk.root}. Install it in Android Studio's SDK Manager.`,
+      sdk.root
+    );
+  }
+  if (probe.androidValidated === false)
+    return unavailable(
+      "android",
+      "android-sdk-invalid",
+      "The Android SDK tools could not run. Check the SDK installation or prepare a private environment.",
+      sdk.root
+    );
+  return { platform: platform2, available: true, sdkRoot: sdk.root };
+};
+var probeMachine = async (input) => {
+  const args = [input.helperPath, "probe"];
+  if (input.runtimeDir) args.push("--tools", input.runtimeDir);
+  if (input.sdkOverride.trim().length > 0) args.push("--sdk", input.sdkOverride.trim());
+  const result = await input.process.run({ program: "host:node", args, cwd: input.cwd, timeoutMs: 3e4 }).catch((error) => {
+    throw new DeviceError(
+      "node-unavailable",
+      `Could not run Node.js to check device support: ${errorDetail(error)}`,
+      { cause: error }
+    );
+  });
+  const probe = result.exitCode === 0 ? parseMachineProbe(result.stdout) : null;
+  if (!probe) {
+    throw new DeviceError(
+      "node-unavailable",
+      `Checking device support failed: ${result.stderr.trim() || "the helper returned no result"}.`
+    );
+  }
+  if (!nodeVersionSupported(probe.node)) {
+    throw new DeviceError(
+      "node-unavailable",
+      `Device support requires Node.js 22.12 or newer; this Ycodium runs on ${probe.node}. Update Ycodium on this machine.`
+    );
+  }
+  return probe;
+};
+
+// src/localHost.ts
+import * as NodePath8 from "node:path";
+
 // src/agentDevice.ts
-import * as NodeCrypto from "node:crypto";
-import * as NodeFSP from "node:fs/promises";
-import * as NodePath from "node:path";
+import * as NodeCrypto2 from "node:crypto";
+import * as NodeFSP4 from "node:fs/promises";
+import * as NodePath4 from "node:path";
 var DAEMON_READY_TIMEOUT_MS = 3e4;
 var DAEMON_POLL_MS = 100;
-var key = (value) => NodeCrypto.createHash("sha256").update(value).digest("hex").slice(0, 24);
-var agentDeviceConfigPath = (dataDir, hostId) => NodePath.join(dataDir, "hosts", `${key(hostId)}.json`);
+var key = (value) => NodeCrypto2.createHash("sha256").update(value).digest("hex").slice(0, 24);
+var agentDeviceConfigPath = (dataDir, hostId) => NodePath4.join(dataDir, "hosts", `${key(hostId)}.json`);
 var agentDeviceSession = (threadId, hostId, deviceId) => `ycodium-${key(JSON.stringify([threadId, hostId, deviceId]))}`;
 var agentDeviceTargetArgs = (device) => device.platform === "ios" ? ["--platform", "ios", "--udid", device.id] : ["--platform", "android", "--serial", device.id];
 var writeAgentDeviceConfig = async (file, endpoint) => {
-  await NodeFSP.mkdir(NodePath.dirname(file), { recursive: true });
+  await NodeFSP4.mkdir(NodePath4.dirname(file), { recursive: true });
   const content = JSON.stringify({
     daemonBaseUrl: endpoint.baseUrl,
     daemonAuthToken: endpoint.token
   });
-  const existing2 = await NodeFSP.readFile(file, "utf8").catch(() => "");
+  const existing2 = await NodeFSP4.readFile(file, "utf8").catch(() => "");
   if (existing2 === content) return;
-  const temporary = NodePath.join(
-    NodePath.dirname(file),
-    `.endpoint-${NodeCrypto.randomUUID()}.json`
+  const temporary = NodePath4.join(
+    NodePath4.dirname(file),
+    `.endpoint-${NodeCrypto2.randomUUID()}.json`
   );
   try {
-    await NodeFSP.writeFile(temporary, content, { mode: 384 });
-    await NodeFSP.rename(temporary, file);
+    await NodeFSP4.writeFile(temporary, content, { mode: 384 });
+    await NodeFSP4.rename(temporary, file);
   } finally {
-    await NodeFSP.rm(temporary, { force: true }).catch(() => void 0);
+    await NodeFSP4.rm(temporary, { force: true }).catch(() => void 0);
   }
 };
 var LAUNCHER_DIR = "bin";
 var ensureAgentDeviceLauncher = async (input) => {
-  const directory = NodePath.join(input.dataDir, LAUNCHER_DIR);
-  await NodeFSP.mkdir(directory, { recursive: true });
-  const launcherPath = NodePath.join(directory, "agent-device-launcher.mjs");
-  await NodeFSP.writeFile(
+  const directory = NodePath4.join(input.dataDir, LAUNCHER_DIR);
+  await NodeFSP4.mkdir(directory, { recursive: true });
+  const launcherPath = NodePath4.join(directory, "agent-device-launcher.mjs");
+  await NodeFSP4.writeFile(
     launcherPath,
     `import { spawn } from "node:child_process";
 const args = process.argv.slice(2);
@@ -589,15 +1577,16 @@ const env = { ...process.env };
 delete env.AGENT_DEVICE_DAEMON_BASE_URL;
 delete env.AGENT_DEVICE_DAEMON_AUTH_TOKEN;
 delete env.AGENT_DEVICE_CONFIG;
-const child = spawn(${JSON.stringify(input.nodePath)}, [${JSON.stringify(input.entryPath)}, ...args], { stdio: "inherit", env, windowsHide: true });
+const prefix = ${JSON.stringify(input.helperPath ? [input.helperPath, "node", ...input.sdkRoot ? ["--sdk", input.sdkRoot] : [], "--", input.entryPath] : [input.entryPath])};
+const child = spawn(${JSON.stringify(input.nodePath)}, [...prefix, ...args], { stdio: "inherit", env, windowsHide: true });
 child.on("error", error => { console.error(error.message); process.exitCode = 1; });
 child.on("exit", code => { process.exitCode = code ?? 1; });
 `
   );
   if (input.platform === "win32") {
-    const command2 = NodePath.join(directory, "agent-device.cmd");
+    const command2 = NodePath4.join(directory, "agent-device.cmd");
     const electron2 = input.electron ? "set ELECTRON_RUN_AS_NODE=1\r\n" : "";
-    await NodeFSP.writeFile(
+    await NodeFSP4.writeFile(
       command2,
       `@echo off\r
 ${electron2}"${input.nodePath}" "${launcherPath}" %*\r
@@ -606,15 +1595,15 @@ ${electron2}"${input.nodePath}" "${launcherPath}" %*\r
     return command2;
   }
   const quote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
-  const command = NodePath.join(directory, "agent-device");
+  const command = NodePath4.join(directory, "agent-device");
   const electron = input.electron ? "ELECTRON_RUN_AS_NODE=1 " : "";
-  await NodeFSP.writeFile(
+  await NodeFSP4.writeFile(
     command,
     `#!/bin/sh
 ${electron}exec ${quote(input.nodePath)} ${quote(launcherPath)} "$@"
 `
   );
-  await NodeFSP.chmod(command, 493);
+  await NodeFSP4.chmod(command, 493);
   return command;
 };
 var parseDaemonFile = (raw) => {
@@ -634,7 +1623,7 @@ var parseDaemonFile = (raw) => {
     version: typeof record["version"] === "string" ? record["version"] : void 0
   };
 };
-var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var defaultSleep = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
 var daemonEnvironment = (stateDir) => ({
   AGENT_DEVICE_STATE_DIR: stateDir,
   AGENT_DEVICE_DAEMON_SERVER_MODE: "http",
@@ -654,10 +1643,10 @@ var AgentDaemon = class {
     this.sleep = options.sleep ?? defaultSleep;
   }
   get daemonFilePath() {
-    return NodePath.join(this.options.stateDir, "daemon.json");
+    return NodePath4.join(this.options.stateDir, "daemon.json");
   }
   async readDaemonFile() {
-    const raw = await NodeFSP.readFile(this.daemonFilePath, "utf8").catch(() => null);
+    const raw = await NodeFSP4.readFile(this.daemonFilePath, "utf8").catch(() => null);
     return raw === null ? null : parseDaemonFile(raw);
   }
   async healthy(port) {
@@ -686,11 +1675,11 @@ var AgentDaemon = class {
    */
   async ensure(input) {
     this.entryPath = input.entryPath;
-    await NodeFSP.mkdir(this.options.stateDir, { recursive: true });
+    await NodeFSP4.mkdir(this.options.stateDir, { recursive: true });
     const existing2 = await this.readDaemonFile();
     if (existing2 !== null) {
       if (await this.healthy(existing2.httpPort)) return this.toEndpoint(existing2, input.entryPath);
-      await NodeFSP.rm(this.daemonFilePath, { force: true }).catch(() => void 0);
+      await NodeFSP4.rm(this.daemonFilePath, { force: true }).catch(() => void 0);
     }
     const args = [this.options.helperPath, "node"];
     if (input.sdkRoot !== null) args.push("--sdk", input.sdkRoot);
@@ -752,8 +1741,8 @@ var agentDeviceQuickStart = (device, targetArgs, command) => {
 };
 
 // src/hubProcess.ts
-import * as NodeFSP2 from "node:fs/promises";
-import * as NodePath2 from "node:path";
+import * as NodeFSP5 from "node:fs/promises";
+import * as NodePath5 from "node:path";
 
 // ../../packages/ycodium-fetch-ports/src/fetchPorts.ts
 import * as NodeNet from "node:net";
@@ -844,12 +1833,12 @@ var FETCH_BLOCKED_PORTS = /* @__PURE__ */ new Set([
 var isFetchSafePort = (port) => !FETCH_BLOCKED_PORTS.has(port);
 var MAX_SAFE_PORT_ATTEMPTS = 50;
 var systemAssigned = () => 0;
-var listenOnce = (server, host, port) => new Promise((resolve, reject) => {
+var listenOnce = (server, host, port) => new Promise((resolve3, reject) => {
   server.once("error", reject);
   server.listen(port, host, () => {
     server.off("error", reject);
     const address = server.address();
-    resolve(typeof address === "object" && address !== null ? address.port : 0);
+    resolve3(typeof address === "object" && address !== null ? address.port : 0);
   });
 });
 var listenOnSafePort = async (server, options = {}) => {
@@ -858,7 +1847,7 @@ var listenOnSafePort = async (server, options = {}) => {
   for (let attempt = 0; attempt < MAX_SAFE_PORT_ATTEMPTS; attempt++) {
     const port = await listenOnce(server, host, portForAttempt(attempt));
     if (isFetchSafePort(port)) return port;
-    await new Promise((resolve) => server.close(() => resolve()));
+    await new Promise((resolve3) => server.close(() => resolve3()));
   }
   throw new Error(`\u8FDE\u7EED ${String(MAX_SAFE_PORT_ATTEMPTS)} \u6B21\u5206\u5230 fetch \u7684\u574F\u7AEF\u53E3`);
 };
@@ -866,7 +1855,7 @@ var reserveFetchSafePort = async (options = {}) => {
   const probe = NodeNet.createServer();
   try {
     const port = await listenOnSafePort(probe, options);
-    await new Promise((resolve) => probe.close(() => resolve()));
+    await new Promise((resolve3) => probe.close(() => resolve3()));
     if (port <= 0) throw new Error("\u65E0\u6CD5\u53D6\u5F97\u76D1\u542C\u7AEF\u53E3");
     return port;
   } catch (cause) {
@@ -900,7 +1889,7 @@ var nodeProcessProbe = {
     }
   }
 };
-var defaultSleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var defaultSleep2 = (ms) => new Promise((resolve3) => setTimeout(resolve3, ms));
 var parseBreakawayWarning = (line) => {
   try {
     const record = JSON.parse(line);
@@ -953,7 +1942,7 @@ var HubProcess = class {
     this.sleep = options.sleep ?? defaultSleep2;
   }
   get statePath() {
-    return NodePath2.join(this.options.stateDir, "hub.json");
+    return NodePath5.join(this.options.stateDir, "hub.json");
   }
   get running() {
     return this.current?.hub ?? null;
@@ -974,7 +1963,7 @@ var HubProcess = class {
     let previous = null;
     try {
       const parsed = JSON.parse(
-        await NodeFSP2.readFile(this.statePath, "utf8")
+        await NodeFSP5.readFile(this.statePath, "utf8")
       );
       if (Number.isSafeInteger(parsed.pid) && Number.isSafeInteger(parsed.port) && typeof parsed.entryPath === "string") {
         previous = parsed;
@@ -991,18 +1980,18 @@ var HubProcess = class {
         this.probe.terminate(previous.pid);
       }
     }
-    await NodeFSP2.rm(this.statePath, { force: true }).catch(() => void 0);
+    await NodeFSP5.rm(this.statePath, { force: true }).catch(() => void 0);
   }
   async spawnOnce(launch) {
     await this.reapStale();
-    await NodeFSP2.mkdir(this.options.stateDir, { recursive: true });
+    await NodeFSP5.mkdir(this.options.stateDir, { recursive: true });
     const port = await (this.options.reservePort ?? (() => reserveFetchSafePort()))();
     const origin = `http://127.0.0.1:${String(port)}`;
     const args = [
       this.options.helperPath,
       "node",
       "--shim",
-      NodePath2.join(this.options.stateDir, "emulator-shim")
+      NodePath5.join(this.options.stateDir, "emulator-shim")
     ];
     if (launch.sdkRoot !== null) args.push("--sdk", launch.sdkRoot);
     args.push(
@@ -1053,7 +2042,7 @@ ${tail}` : ""}`
     }
     const hub = { origin, port, pid: handle.pid, startedAt: this.now() };
     const record = { pid: handle.pid, port, entryPath: launch.entryPath };
-    await NodeFSP2.writeFile(this.statePath, JSON.stringify(record)).catch(() => void 0);
+    await NodeFSP5.writeFile(this.statePath, JSON.stringify(record)).catch(() => void 0);
     this.current = { hub, handle };
     this.options.log.info("Device hub started", { pid: handle.pid, port });
     this.options.onStarted?.(hub);
@@ -1090,115 +2079,21 @@ ${tail}` : ""}`
     const current = this.current;
     this.current = null;
     if (current !== null) await current.handle.kill().catch(() => void 0);
-    await NodeFSP2.rm(this.statePath, { force: true }).catch(() => void 0);
+    await NodeFSP5.rm(this.statePath, { force: true }).catch(() => void 0);
   }
 };
 
-// src/toolchain.ts
-import * as NodeFSP4 from "node:fs/promises";
-import * as NodePath4 from "node:path";
-
-// src/npmRuntime.ts
-import * as NodeCrypto2 from "node:crypto";
-import * as NodeFSP3 from "node:fs/promises";
-import * as NodePath3 from "node:path";
-var MANAGED_NPM_VERSION = "11.21.0";
-var MANAGED_NPM_INTEGRITY = "sha512-Zov8KhamNneiLdELtj5YALtNmJW4L4fCLTzjfpzXG2w6MSHcf0UxgdlK5uloCuksWT+7mGUU7wi79cO6RqivPg==";
-var DEFAULT_REGISTRY = "https://registry.npmjs.org";
-var managedNpmPaths = (dataDir, version = MANAGED_NPM_VERSION) => {
-  const installDir = NodePath3.join(dataDir, "npm", version);
-  return {
-    installDir,
-    cliPath: NodePath3.join(installDir, "bin", "npm-cli.js"),
-    sentinelPath: NodePath3.join(installDir, ".install-complete"),
-    shimDir: NodePath3.join(dataDir, "npm", "node-shim")
-  };
-};
-var integrityMatches = (bytes, integrity) => {
-  const [algorithm, expected] = integrity.split("-", 2);
-  if (algorithm !== "sha512" || expected === void 0) return false;
-  return NodeCrypto2.createHash("sha512").update(bytes).digest("base64") === expected;
-};
-var fileExists = (file) => NodeFSP3.access(file).then(
-  () => true,
-  () => false
-);
-var failed = (step, detail) => new DeviceError(
-  "install-failed",
-  `Preparing npm ${MANAGED_NPM_VERSION} failed while ${step}.${detail ? ` ${detail}` : ""}`
-);
-var ensureManagedNpm = async (input) => {
-  const paths = managedNpmPaths(input.dataDir);
-  const sentinel = await NodeFSP3.readFile(paths.sentinelPath, "utf8").catch(() => null);
-  if (sentinel?.trim() === MANAGED_NPM_VERSION && await fileExists(paths.cliPath)) return paths;
-  const registry = (input.registry ?? DEFAULT_REGISTRY).replace(/\/+$/, "");
-  const url2 = `${registry}/npm/-/npm-${MANAGED_NPM_VERSION}.tgz`;
-  let bytes;
-  try {
-    const response = await input.fetch(url2, { signal: AbortSignal.timeout(5 * 6e4) });
-    if (!response.ok)
-      throw failed("downloading", `The registry answered ${String(response.status)}.`);
-    bytes = new Uint8Array(await response.arrayBuffer());
-  } catch (cause) {
-    if (cause instanceof DeviceError) throw cause;
-    throw failed("downloading", errorDetail(cause));
-  }
-  if (!integrityMatches(bytes, MANAGED_NPM_INTEGRITY)) {
-    throw failed("verifying the download", "The archive does not match the pinned checksum.");
-  }
-  const parent = NodePath3.dirname(paths.installDir);
-  await NodeFSP3.mkdir(parent, { recursive: true });
-  const staging = await NodeFSP3.mkdtemp(NodePath3.join(parent, ".staging-"));
-  const archive = NodePath3.join(
-    parent,
-    `.npm-${MANAGED_NPM_VERSION}-${NodeCrypto2.randomUUID()}.tgz`
-  );
-  try {
-    await NodeFSP3.writeFile(archive, bytes);
-    const result = await input.process.run({
-      program: "host:node",
-      args: [input.helperPath, "extract", "--", archive, staging],
-      cwd: input.dataDir,
-      timeoutMs: 12e4
-    });
-    if (result.exitCode !== 0) throw failed("unpacking", result.stderr.trim());
-    if (!await fileExists(NodePath3.join(staging, "bin", "npm-cli.js"))) {
-      throw failed("unpacking", "The archive has no bin/npm-cli.js.");
-    }
-    await NodeFSP3.writeFile(
-      NodePath3.join(staging, ".install-complete"),
-      `${MANAGED_NPM_VERSION}
-`
-    );
-    await NodeFSP3.rm(paths.installDir, { recursive: true, force: true });
-    await NodeFSP3.rename(staging, paths.installDir);
-    return paths;
-  } finally {
-    await NodeFSP3.rm(staging, { recursive: true, force: true }).catch(() => void 0);
-    await NodeFSP3.rm(archive, { force: true }).catch(() => void 0);
-  }
-};
-var runManagedNpm = (input) => input.process.run({
-  program: "host:node",
-  args: [
-    input.helperPath,
-    "npm",
-    "--shim",
-    input.npm.shimDir,
-    "--",
-    input.npm.cliPath,
-    ...input.args
-  ],
-  cwd: input.cwd,
-  timeoutMs: input.timeoutMs,
-  maxOutputBytes: 256 * 1024
-});
+// src/serveSimHelpers.ts
+import * as NodeFSP7 from "node:fs/promises";
+import * as NodePath7 from "node:path";
 
 // src/toolchain.ts
+import * as NodeFSP6 from "node:fs/promises";
+import * as NodePath6 from "node:path";
+import * as NodeOS from "node:os";
 var DEVICE_HUB_VERSION = "0.12.0";
 var AGENT_DEVICE_VERSION = "0.21.12";
-var INSTALL_TIMEOUT_MS = 10 * 6e4;
-var VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+(?:-[a-zA-Z0-9.-]+)?$/;
+var runtimeTarget = `${NodeOS.platform()}-${NodeOS.arch()}`;
 var HUB_SPEC = {
   tool: "hub",
   packageName: "expo-device-hub",
@@ -1212,358 +2107,57 @@ var AGENT_DEVICE_SPEC = {
   entry: ["bin", "agent-device.mjs"]
 };
 var toolSpec = (tool) => tool === "hub" ? HUB_SPEC : AGENT_DEVICE_SPEC;
-var toolsRoot = (dataDir) => NodePath4.join(dataDir, "tools");
-var toolPaths = (dataDir, spec, version = spec.version) => {
-  const installDir = NodePath4.join(toolsRoot(dataDir), spec.packageName, version);
+var bundledToolPaths = (pluginDir, spec, runtimeDir) => {
+  const installDir = runtimeDir ?? NodePath6.join(pluginDir, "runtime", runtimeTarget);
   return {
     installDir,
-    entryPath: NodePath4.join(installDir, "node_modules", spec.packageName, ...spec.entry),
-    sentinelPath: NodePath4.join(installDir, ".install-complete")
+    entryPath: NodePath6.join(installDir, "node_modules", spec.packageName, ...spec.entry),
+    sentinelPath: NodePath6.join(installDir, "node_modules", spec.packageName, "package.json")
   };
 };
-var agentDeviceStateDir = (dataDir) => NodePath4.join(dataDir, "agent-device");
-var fileExists2 = async (file) => {
+var agentDeviceStateDir = (dataDir) => NodePath6.join(dataDir, "agent-device");
+var isToolInstalled = async (pluginDir, spec, runtimeDir) => {
+  const paths = bundledToolPaths(pluginDir, spec, runtimeDir);
   try {
-    await NodeFSP4.access(file);
+    const runtime = JSON.parse(
+      await NodeFSP6.readFile(NodePath6.join(paths.installDir, "manifest.json"), "utf8")
+    );
+    if (typeof runtime !== "object" || runtime === null || !("schemaVersion" in runtime) || runtime.schemaVersion !== 1 || !("target" in runtime) || runtime.target !== runtimeTarget)
+      return false;
+    await NodeFSP6.access(NodePath6.join(paths.installDir, "inventory.json"));
+    const manifest = JSON.parse(await NodeFSP6.readFile(paths.sentinelPath, "utf8"));
+    if (typeof manifest !== "object" || manifest === null || !("version" in manifest) || manifest.version !== spec.version)
+      return false;
+    await NodeFSP6.access(paths.entryPath);
     return true;
   } catch {
     return false;
   }
 };
-var readSentinel = async (file) => {
-  try {
-    return (await NodeFSP4.readFile(file, "utf8")).trim();
-  } catch {
-    return null;
-  }
-};
-var isInstalled = async (paths, version) => await readSentinel(paths.sentinelPath) === version && await fileExists2(paths.entryPath);
-var isToolInstalled = (dataDir, spec) => isInstalled(toolPaths(dataDir, spec), spec.version);
-var installQueue = Promise.resolve();
-var serialized = (task) => {
-  const next = installQueue.then(task, task);
-  installQueue = next.catch(() => void 0);
-  return next;
-};
-var installFailed = (spec, step, detail, cause) => new DeviceError(
-  "install-failed",
-  `Installing ${spec.packageName} ${spec.version} failed while ${step}.${detail ? ` ${detail}` : ""}`,
-  cause === void 0 ? void 0 : { cause }
-);
-var ensureTool = (input) => serialized(async () => {
-  const { dataDir, spec } = input;
-  const paths = toolPaths(dataDir, spec);
-  if (await isInstalled(paths, spec.version)) return paths;
-  const parentDir = NodePath4.dirname(paths.installDir);
-  await NodeFSP4.rm(paths.installDir, { recursive: true, force: true });
-  await NodeFSP4.mkdir(parentDir, { recursive: true });
-  const npm = await ensureManagedNpm({
-    dataDir,
-    helperPath: input.helperPath,
-    process: input.process,
-    fetch: input.fetch
-  });
-  const stagingDir = await NodeFSP4.mkdtemp(NodePath4.join(parentDir, ".staging-"));
-  try {
-    const result = await runManagedNpm({
-      helperPath: input.helperPath,
-      process: input.process,
-      npm,
-      args: [
-        "install",
-        "--prefix",
-        stagingDir,
-        "--no-fund",
-        "--no-audit",
-        `${spec.packageName}@${spec.version}`
-      ],
-      cwd: dataDir,
-      timeoutMs: INSTALL_TIMEOUT_MS
-    }).catch((error) => {
-      throw installFailed(spec, "running npm install", errorDetail(error), error);
-    });
-    if (result.timedOut) throw installFailed(spec, "running npm install", "npm timed out.");
-    if (result.exitCode !== 0) {
-      throw installFailed(
-        spec,
-        "running npm install",
-        `npm exited with code ${String(result.exitCode)}.`
-      );
-    }
-    const stagedEntry = NodePath4.join(
-      stagingDir,
-      "node_modules",
-      spec.packageName,
-      ...spec.entry
-    );
-    if (!await fileExists2(stagedEntry)) {
-      throw installFailed(spec, "verifying the installed entry point");
-    }
-    await NodeFSP4.writeFile(NodePath4.join(stagingDir, ".install-complete"), `${spec.version}
-`);
-    try {
-      await NodeFSP4.rename(stagingDir, paths.installDir);
-    } catch (error) {
-      if (!await isInstalled(paths, spec.version)) {
-        throw installFailed(spec, "publishing the install", errorDetail(error), error);
-      }
-    }
-    return paths;
-  } finally {
-    await NodeFSP4.rm(stagingDir, { recursive: true, force: true }).catch(() => void 0);
-  }
-});
-var inspectTool = async (dataDir, spec, runningVersion) => {
-  const directory = NodePath4.join(toolsRoot(dataDir), spec.packageName);
-  let names = [];
-  try {
-    names = await NodeFSP4.readdir(directory);
-  } catch {
-    names = [];
-  }
-  const completed = [];
-  for (const version of names) {
-    if (!VERSION_PATTERN.test(version)) continue;
-    if (await isInstalled(toolPaths(dataDir, spec, version), version)) completed.push(version);
-  }
-  completed.sort((a, b) => a.localeCompare(b, "en", { numeric: true }));
-  return { requiredVersion: spec.version, installedVersions: completed, runningVersion };
-};
-
-// src/maintenance.ts
-var TOOL_MAINTENANCE_SCRIPT = String.raw`
-const maintenanceFs = require('node:fs');
-const maintenancePath = require('node:path');
-const maintenanceAlive = pid => {
-  try { process.kill(pid, 0); return true; }
-  catch (error) { return error.code !== 'ESRCH'; }
-};
-async function withToolMaintenance(root, operation) {
-  maintenanceFs.mkdirSync(root, { recursive: true });
-  const lock = maintenancePath.join(root, '.maintenance-lock');
-  const nonce = require('node:crypto').randomUUID();
-  const ownerFile = process.pid + '.' + nonce + '.json';
-  const candidate = lock + '.' + nonce;
-  const deadline = Date.now() + 30000;
-  const removeEmptyLock = () => {
-    try { maintenanceFs.rmdirSync(lock); }
-    catch (error) { if (!['ENOENT', 'ENOTEMPTY', 'EEXIST', 'EPERM'].includes(error.code)) throw error; }
-  };
-  maintenanceFs.mkdirSync(candidate);
-  try {
-    maintenanceFs.writeFileSync(maintenancePath.join(candidate, ownerFile), JSON.stringify({ pid: process.pid }));
-    while (true) {
-      try {
-        maintenanceFs.renameSync(candidate, lock);
-        break;
-      }
-      catch (error) {
-        if (!['EEXIST', 'ENOTEMPTY', 'EPERM', 'EACCES'].includes(error.code)) throw error;
-        let files = [];
-        try { files = maintenanceFs.readdirSync(lock); } catch (error) { if (error.code !== 'ENOENT') throw error; }
-        if (files.length === 1) {
-          const previousFile = maintenancePath.join(lock, files[0]);
-          let previous;
-          try { previous = JSON.parse(maintenanceFs.readFileSync(previousFile, 'utf8')); } catch {}
-          if (Number.isSafeInteger(previous?.pid) && previous.pid > 0 && !maintenanceAlive(previous.pid)) {
-            try { maintenanceFs.unlinkSync(previousFile); } catch (error) { if (error.code !== 'ENOENT') throw error; }
-          }
-        }
-        removeEmptyLock();
-        if (Date.now() >= deadline) throw Error('Device tool maintenance is locked. Retry when the other operation finishes.');
-        await new Promise(resolve => setTimeout(resolve, 50));
-      }
-    }
-    try { return operation(); }
-    finally {
-      maintenanceFs.unlinkSync(maintenancePath.join(lock, ownerFile));
-      removeEmptyLock();
-    }
-  } finally {
-    maintenanceFs.rmSync(candidate, { recursive: true, force: true });
-  }
-}
-function pruneTools(root, specs) {
-  return withToolMaintenance(root, () => {
-    const scan = process.platform === 'win32'
-      ? require('node:child_process').spawnSync('powershell.exe', ['-NoProfile', '-NonInteractive', '-Command', 'Get-CimInstance Win32_Process | Select-Object -ExpandProperty CommandLine'], { encoding: 'utf8', timeout: 10000, windowsHide: true })
-      : require('node:child_process').spawnSync('ps', ['-ax', '-o', 'command='], { encoding: 'utf8', timeout: 10000 });
-    if (scan.status !== 0 || !scan.stdout) return;
-    for (const [name, required] of specs) {
-      const parent = maintenancePath.join(root, name);
-      let names;
-      try { names = maintenanceFs.readdirSync(parent); } catch { continue; }
-      const completed = [];
-      for (const version of names) {
-        if (!/^[0-9]+\.[0-9]+\.[0-9]+(?:-[a-zA-Z0-9.-]+)?$/.test(version)) continue;
-        const directory = maintenancePath.join(parent, version);
-        try {
-          if (!maintenanceFs.lstatSync(directory).isDirectory()) continue;
-          if (maintenanceFs.readFileSync(maintenancePath.join(directory, '.install-complete'), 'utf8').trim() !== version) continue;
-          completed.push({ version, directory, modified: maintenanceFs.statSync(maintenancePath.join(directory, '.install-complete')).mtimeMs });
-        } catch {}
-      }
-      if (!completed.some(value => value.version === required)) continue;
-      const previous = completed.filter(value => value.version !== required).sort((a, b) => b.modified - a.modified || b.version.localeCompare(a.version, 'en', { numeric: true }))[0]?.version;
-      for (const { version, directory } of completed) {
-        if (version === required || version === previous || scan.stdout.includes(directory + maintenancePath.sep)) continue;
-        maintenanceFs.rmSync(directory, { recursive: true, force: true });
-      }
-    }
-  });
-}
-`;
-var pruneTool = async (input) => {
-  const call = `pruneTools(${JSON.stringify(toolsRoot(input.dataDir))}, ${JSON.stringify([
-    [input.spec.packageName, input.spec.version]
-  ])})`;
-  const result = await input.process.run({
-    program: "host:node",
-    args: [
-      "-e",
-      `${TOOL_MAINTENANCE_SCRIPT}
-${call}.catch(error => { console.error(error.message); process.exitCode = 1; });`
-    ],
-    cwd: input.dataDir,
-    timeoutMs: 6e4
-  });
-  return { ok: result.exitCode === 0, detail: result.stderr.trim() };
-};
-
-// src/probe.ts
-var MIN_NODE_VERSION = [22, 12, 0];
-var isRecord2 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-var parseMachineProbe = (stdout) => {
-  const line = stdout.trim().split(/\r?\n/).at(-1) ?? "";
-  let value;
-  try {
-    value = JSON.parse(line);
-  } catch {
-    return null;
-  }
-  if (!isRecord2(value) || !isRecord2(value["android"])) return null;
-  const android = value["android"];
-  if (typeof value["node"] !== "string" || typeof value["execPath"] !== "string" || typeof value["platform"] !== "string") {
-    return null;
-  }
-  return {
-    node: value["node"],
-    execPath: value["execPath"],
-    electron: typeof value["electron"] === "string" ? value["electron"] : null,
-    platform: value["platform"],
-    xcrun: value["xcrun"] === true,
-    android: {
-      root: typeof android["root"] === "string" ? android["root"] : null,
-      adb: android["adb"] === true,
-      emulator: android["emulator"] === true,
-      avdmanager: android["avdmanager"] === true,
-      legacyAvdmanager: android["legacyAvdmanager"] === true
-    }
-  };
-};
-var nodeVersionSupported = (version) => {
-  const match = /^v?(\d+)\.(\d+)\.(\d+)/.exec(version);
-  if (!match) return false;
-  const parts = [Number(match[1]), Number(match[2]), Number(match[3])];
-  for (let index = 0; index < MIN_NODE_VERSION.length; index += 1) {
-    const actual = parts[index];
-    const required = MIN_NODE_VERSION[index];
-    if (actual !== required) return actual > required;
-  }
-  return true;
-};
-var unavailable = (platform, reasonCode, reason, sdkRoot) => ({
-  platform,
-  available: false,
-  reasonCode,
-  reason,
-  ...sdkRoot === void 0 ? {} : { sdkRoot }
-});
-var platformAvailability = (probe, platform) => {
-  if (platform === "ios") {
-    if (probe.platform !== "darwin") {
-      return unavailable("ios", "ios-needs-macos", "iOS Simulators need macOS with Xcode.");
-    }
-    if (!probe.xcrun) {
-      return unavailable("ios", "xcode-missing", "Xcode command line tools were not found.");
-    }
-    return { platform, available: true };
-  }
-  const sdk = probe.android;
-  if (!sdk.root) {
-    return unavailable(
-      "android",
-      "android-sdk-missing",
-      "Android SDK was not found. Install it with Android Studio or set its location in the Devices settings."
-    );
-  }
-  if (!sdk.adb) {
-    return unavailable(
-      "android",
-      "android-platform-tools-missing",
-      `Android SDK Platform-Tools are missing from ${sdk.root}. Install them in Android Studio's SDK Manager.`,
-      sdk.root
-    );
-  }
-  if (!sdk.emulator) {
-    return unavailable(
-      "android",
-      "android-emulator-missing",
-      `Android Emulator is missing from ${sdk.root}. Install it in Android Studio's SDK Manager.`,
-      sdk.root
-    );
-  }
-  if (!sdk.avdmanager) {
-    return sdk.legacyAvdmanager ? unavailable(
-      "android",
-      "android-cmdline-tools-legacy",
-      `The Android SDK command-line tools in ${sdk.root} appear to be an older, unsupported version. Install Android SDK Command-line Tools (latest) in Android Studio's SDK Manager under SDK Tools.`,
-      sdk.root
-    ) : unavailable(
-      "android",
-      "android-cmdline-tools-missing",
-      `Android SDK Command-line Tools (latest) are missing from ${sdk.root}. Install them in Android Studio's SDK Manager.`,
-      sdk.root
-    );
-  }
-  return { platform, available: true };
-};
-var probeMachine = async (input) => {
-  const args = [input.helperPath, "probe"];
-  if (input.sdkOverride.trim().length > 0) args.push("--sdk", input.sdkOverride.trim());
-  const result = await input.process.run({ program: "host:node", args, cwd: input.cwd, timeoutMs: 3e4 }).catch((error) => {
+var ensureTool = async (input) => {
+  const pluginDir = input.pluginDir ?? NodePath6.dirname(NodePath6.dirname(input.helperPath));
+  if (!await isToolInstalled(pluginDir, input.spec, input.runtimeDir)) {
     throw new DeviceError(
-      "node-unavailable",
-      `Could not run Node.js to check device support: ${errorDetail(error)}`,
-      { cause: error }
-    );
-  });
-  const probe = result.exitCode === 0 ? parseMachineProbe(result.stdout) : null;
-  if (!probe) {
-    throw new DeviceError(
-      "node-unavailable",
-      `Checking device support failed: ${result.stderr.trim() || "the helper returned no result"}.`
-    );
-  }
-  if (!nodeVersionSupported(probe.node)) {
-    throw new DeviceError(
-      "node-unavailable",
-      `Device support requires Node.js 22.12 or newer; this Ycodium runs on ${probe.node}. Update Ycodium on this machine.`
+      "install-failed",
+      `Bundled ${input.spec.packageName} ${input.spec.version} is missing or incomplete. Repair or update Ycodium on this machine.`
     );
   }
-  return probe;
+  return bundledToolPaths(pluginDir, input.spec, input.runtimeDir);
 };
+var inspectTool = async (pluginDir, spec, runningVersion, runtimeDir) => ({
+  requiredVersion: spec.version,
+  installedVersions: await isToolInstalled(pluginDir, spec, runtimeDir) ? [spec.version] : [],
+  runningVersion
+});
 
 // src/serveSimHelpers.ts
-import * as NodeFSP5 from "node:fs/promises";
-import * as NodePath5 from "node:path";
-var existing = (file) => NodeFSP5.access(file).then(
+var existing = (file) => NodeFSP7.access(file).then(
   () => file,
   () => null
 );
-var serveSimHelpers = async (dataDir) => {
-  const dist = NodePath5.join(
-    toolPaths(dataDir, HUB_SPEC).installDir,
+var serveSimHelpers = async (dataDir, runtimeDir) => {
+  const dist = NodePath7.join(
+    bundledToolPaths(dataDir, HUB_SPEC, runtimeDir).installDir,
     "node_modules",
     HUB_SPEC.packageName,
     "vendor",
@@ -1571,8 +2165,8 @@ var serveSimHelpers = async (dataDir) => {
     "dist"
   );
   const [axSettings2, cli] = await Promise.all([
-    existing(NodePath5.join(dist, "simax", "serve-sim-ax-settings")),
-    existing(NodePath5.join(dist, "serve-sim.js"))
+    existing(NodePath7.join(dist, "simax", "serve-sim-ax-settings")),
+    existing(NodePath7.join(dist, "serve-sim.js"))
   ]);
   return { axSettings: axSettings2, cli };
 };
@@ -1589,6 +2183,7 @@ var LocalDeviceHost = class {
   agent;
   agentEndpoint = null;
   lock = Promise.resolve();
+  environmentMutating = false;
   options;
   constructor(options) {
     this.options = options;
@@ -1612,6 +2207,8 @@ var LocalDeviceHost = class {
   /** 生命周期操作串行：两个调用者同时要起 hub 时只起一次。 */
   installInput(spec) {
     return {
+      pluginDir: this.pluginDir,
+      ...this.options.runtimeDir ? { runtimeDir: this.options.runtimeDir } : {},
       dataDir: this.options.dataDir,
       spec,
       helperPath: this.options.helperPath,
@@ -1619,6 +2216,9 @@ var LocalDeviceHost = class {
       fetch: this.options.downloadFetch
     };
   }
+  get pluginDir() {
+    return this.options.pluginDir ?? NodePath8.dirname(NodePath8.dirname(this.options.helperPath));
+  }
   serialized(task) {
     const next = this.lock.then(task, task);
     this.lock = next.catch(() => void 0);
@@ -1626,37 +2226,39 @@ var LocalDeviceHost = class {
   }
   async machine(refresh = false) {
     if (this.probeCache !== null && !refresh) return this.probeCache;
+    const privateSdk = this.options.sdkOverride.trim() ? null : await selectedPrivateSdk(this.options.dataDir);
     this.probeCache = await probeMachine({
       helperPath: this.options.helperPath,
       process: this.options.process,
       cwd: this.options.dataDir,
-      sdkOverride: this.options.sdkOverride
+      sdkOverride: this.options.sdkOverride.trim() || privateSdk || "",
+      runtimeDir: bundledToolPaths(this.pluginDir, HUB_SPEC, this.options.runtimeDir).installDir
     });
     return this.probeCache;
   }
-  async platformAvailability(platform) {
-    return platformAvailability(await this.machine(), platform);
+  async platformAvailability(platform2) {
+    return platformAvailability(await this.machine(), platform2);
   }
   async platforms(refresh = false) {
     const probe = await this.machine(refresh);
-    return DEVICE_PLATFORMS.map((platform) => platformAvailability(probe, platform));
+    return DEVICE_PLATFORMS.map((platform2) => platformAvailability(probe, platform2));
   }
   async toolVersion(spec) {
     const running = spec.tool === "hub" ? this.hub.running !== null ? HUB_SPEC.version : null : this.agentEndpoint?.version ?? null;
-    return inspectTool(this.options.dataDir, spec, running);
+    return inspectTool(this.pluginDir, spec, running, this.options.runtimeDir);
   }
   /** 不装不起，只读现状。探测失败（比如没有 Node）时平台一律按不可用报。 */
   async summary(refresh = false) {
     const [platforms, hubInstalled, agentDeviceInstalled, hub, agent] = await Promise.all([
       this.platforms(refresh).catch(
-        (error) => DEVICE_PLATFORMS.map((platform) => ({
-          platform,
+        (error) => DEVICE_PLATFORMS.map((platform2) => ({
+          platform: platform2,
           available: false,
           reason: errorDetail(error)
         }))
       ),
-      isToolInstalled(this.options.dataDir, HUB_SPEC),
-      isToolInstalled(this.options.dataDir, AGENT_DEVICE_SPEC),
+      isToolInstalled(this.pluginDir, HUB_SPEC, this.options.runtimeDir),
+      isToolInstalled(this.pluginDir, AGENT_DEVICE_SPEC, this.options.runtimeDir),
       this.toolVersion(HUB_SPEC),
       this.toolVersion(AGENT_DEVICE_SPEC)
     ]);
@@ -1670,7 +2272,7 @@ var LocalDeviceHost = class {
     };
   }
   async installIfNeeded(spec, onPhase) {
-    if (!await isToolInstalled(this.options.dataDir, spec)) {
+    if (!await isToolInstalled(this.pluginDir, spec, this.options.runtimeDir)) {
       onPhase(
         "installing",
         installPhaseDetail(spec.tool, await this.toolVersion(spec), spec.version)
@@ -1678,31 +2280,25 @@ var LocalDeviceHost = class {
     }
     return ensureTool(this.installInput(spec));
   }
-  async prune(spec) {
-    const result = await pruneTool({
-      dataDir: this.options.dataDir,
-      spec,
-      process: this.options.process
-    }).catch((error) => ({
-      ok: false,
-      detail: error instanceof Error ? error.message : String(error)
-    }));
-    if (!result.ok) {
-      this.options.log.warn("Reclaiming old device tool versions failed", {
-        tool: spec.tool,
-        detail: result.detail
-      });
-    }
-  }
   async startHub(onPhase) {
+    if (this.environmentMutating)
+      throw new DeviceError(
+        "invalid-input",
+        "Simulator environment preparation or cleanup is in progress"
+      );
     const probe = await this.machine();
     const running = this.hub.running;
-    if (running !== null) return { hostId: this.id, hubOrigin: running.origin, probe };
+    if (running !== null)
+      return {
+        hostId: this.id,
+        hubOrigin: running.origin,
+        probe,
+        helperPath: this.options.helperPath
+      };
     const tool = await this.installIfNeeded(HUB_SPEC, onPhase);
     onPhase("starting");
     const hub = await this.hub.ensure({ entryPath: tool.entryPath, sdkRoot: probe.android.root });
-    await this.prune(HUB_SPEC);
-    return { hostId: this.id, hubOrigin: hub.origin, probe };
+    return { hostId: this.id, hubOrigin: hub.origin, probe, helperPath: this.options.helperPath };
   }
   /** 首次使用时装 hub 并起来；幂等，hub 已在跑就直接返回。 */
   ensureReady(onPhase) {
@@ -1720,7 +2316,6 @@ var LocalDeviceHost = class {
         sdkRoot: ready.probe.android.root
       });
       this.agentEndpoint = endpoint;
-      await this.prune(AGENT_DEVICE_SPEC);
       return { ...ready, agentDevice: endpoint };
     });
   }
@@ -1739,6 +2334,11 @@ var LocalDeviceHost = class {
    * Node 起脚本。只传 argv，不过 shell。
    */
   async runTool(program, args, options = {}) {
+    if (this.environmentMutating)
+      throw new DeviceError(
+        "invalid-input",
+        "Simulator environment preparation or cleanup is in progress"
+      );
     const stdin = options.stdin === void 0 ? {} : { stdin: options.stdin };
     const base = {
       program: "host:node",
@@ -1770,7 +2370,7 @@ var LocalDeviceHost = class {
   async actionTools() {
     return {
       run: (program, args, options) => this.runTool(program, args, options),
-      helpers: await serveSimHelpers(this.options.dataDir)
+      helpers: await serveSimHelpers(this.pluginDir, this.options.runtimeDir)
     };
   }
   /** 只停 agent-device；用户自己在面板里看设备不受影响。 */
@@ -1788,6 +2388,25 @@ var LocalDeviceHost = class {
       this.agentEndpoint = null;
     });
   }
+  beginEnvironmentMutation() {
+    return this.serialized(async () => {
+      if (this.environmentMutating)
+        throw new DeviceError("invalid-input", "Another environment mutation is in progress");
+      this.environmentMutating = true;
+      try {
+        await this.hub.stop();
+        await this.agent.stop();
+        this.agentEndpoint = null;
+      } catch (error) {
+        this.environmentMutating = false;
+        throw error;
+      }
+      return () => {
+        this.probeCache = null;
+        this.environmentMutating = false;
+      };
+    });
+  }
 };
 
 // src/deviceActions.ts
@@ -2156,23 +2775,23 @@ var readDeviceDetail = async (tools, device) => {
 var BOOT_TIMEOUT_MS = 3 * 6e4;
 var SCREENSHOT_TIMEOUT_MS = 2e4;
 var DEFAULT_TIMEOUT_MS = 15e3;
-var vendorPrefix = (platform) => platform === "ios" ? "/vendor/serve-sim" : "/vendor/serve-emu";
+var vendorPrefix = (platform2) => platform2 === "ios" ? "/vendor/serve-sim" : "/vendor/serve-emu";
 var isRecord3 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
 var parseHubDevice = (value) => {
   if (!isRecord3(value)) return null;
-  const { id, name, version, platform, booted, physical } = value;
-  if (typeof id !== "string" || typeof name !== "string" || typeof version !== "string" || platform !== "ios" && platform !== "android" || typeof booted !== "boolean" || typeof physical !== "boolean") {
+  const { id, name, version, platform: platform2, booted, physical } = value;
+  if (typeof id !== "string" || typeof name !== "string" || typeof version !== "string" || platform2 !== "ios" && platform2 !== "android" || typeof booted !== "boolean" || typeof physical !== "boolean") {
     return null;
   }
-  return { id, name, version, platform, booted, physical };
+  return { id, name, version, platform: platform2, booted, physical };
 };
 var parseHubDeviceList = (value) => {
   if (!isRecord3(value)) return null;
   const simulators = value["simulators"];
-  const emulators = value["emulators"];
-  if (!Array.isArray(simulators) || !Array.isArray(emulators)) return null;
+  const emulators2 = value["emulators"];
+  if (!Array.isArray(simulators) || !Array.isArray(emulators2)) return null;
   const devices = [];
-  for (const entry of [...simulators, ...emulators]) {
+  for (const entry of [...simulators, ...emulators2]) {
     const device = parseHubDevice(entry);
     if (device === null) return null;
     devices.push(device);
@@ -2266,14 +2885,14 @@ var HubClient = class {
   shutdownIos(udid) {
     return this.action(`${vendorPrefix("ios")}/grid/api/shutdown`, "shutdown", { udid });
   }
-  shutdownDevice(platform, id) {
-    return this.action("/api/devices/shutdown", "shutdown", { platform, id });
+  shutdownDevice(platform2, id) {
+    return this.action("/api/devices/shutdown", "shutdown", { platform: platform2, id });
   }
-  async screenshot(platform, deviceId) {
+  async screenshot(platform2, deviceId) {
     let response;
     try {
       response = await this.fetch(
-        `${this.origin}${vendorPrefix(platform)}/api/screenshot?device=${encodeURIComponent(deviceId)}`,
+        `${this.origin}${vendorPrefix(platform2)}/api/screenshot?device=${encodeURIComponent(deviceId)}`,
         { method: "POST", signal: AbortSignal.timeout(SCREENSHOT_TIMEOUT_MS) }
       );
     } catch (cause) {
@@ -2306,6 +2925,9 @@ var classifyBootFailure = (error) => {
 // src/service.ts
 var sameDevice = (a, hostId, deviceId) => a.hostId === hostId && a.id === deviceId;
 var DeviceService = class {
+  environmentMutating = false;
+  environmentGeneration = 0;
+  pendingOpens = 0;
   state = {
     hosts: [],
     hostStatuses: {},
@@ -2345,6 +2967,7 @@ var DeviceService = class {
     }));
   }
   onPhase = (phase, detail) => {
+    if (this.environmentMutating) return;
     this.setHostStatus({ status: phase, ...detail });
   };
   resolveHost(hostId) {
@@ -2353,28 +2976,30 @@ var DeviceService = class {
     }
   }
   async withStatus(task) {
+    const generation = this.environmentGeneration;
     try {
       return await task();
     } catch (error) {
       const message = error instanceof DeviceError ? error.message : errorDetail(error);
-      this.setHostStatus({
-        status: "failed",
-        code: error instanceof DeviceError ? error.code : "host-unavailable",
-        message
-      });
+      if (!this.environmentMutating && generation === this.environmentGeneration)
+        this.setHostStatus({
+          status: "failed",
+          code: error instanceof DeviceError ? error.code : "host-unavailable",
+          message
+        });
       throw error;
     }
   }
   /** 起 hub 并刷新设备。机器一个平台都跑不了时什么都不装，返回 null。 */
   async readinessIfSupported() {
     const platforms = await this.host.platforms();
-    if (!platforms.some((platform) => platform.available)) return null;
+    if (!platforms.some((platform2) => platform2.available)) return null;
     return this.readiness();
   }
   async readiness() {
     return this.withStatus(async () => {
       const ready = await this.host.ensureReady(this.onPhase);
-      if (this.state.hostStatuses[this.host.id]?.status !== "ready") {
+      if (!this.environmentMutating && this.state.hostStatuses[this.host.id]?.status !== "ready") {
         this.setHostStatus({ status: "ready" });
       }
       return ready;
@@ -2414,8 +3039,10 @@ var DeviceService = class {
     return list.errors.length > 0 ? { devices, detail: list.errors.join("\n") } : { devices };
   }
   async refresh(ready) {
+    const generation = this.environmentGeneration;
     const { devices, detail } = await this.withStatus(() => this.fetchDevices(ready));
     const summary = await this.host.summary();
+    if (this.environmentMutating || generation !== this.environmentGeneration) return this.state;
     return this.publish((state) => ({
       ...state,
       hosts: [summary],
@@ -2433,8 +3060,11 @@ var DeviceService = class {
   }
   /** 列设备：能跑的话起 hub 再刷新；跑不了只更新宿主现状。失败记在宿主状态里，不抛。 */
   async list() {
+    if (this.environmentMutating) return this.state;
+    const generation = this.environmentGeneration;
     try {
       const ready = await this.readinessIfSupported();
+      if (this.environmentMutating || generation !== this.environmentGeneration) return this.state;
       if (ready === null) return await this.inspect();
       return await this.refresh(ready);
     } catch {
@@ -2442,6 +3072,19 @@ var DeviceService = class {
     }
   }
   async open(input) {
+    if (this.environmentMutating)
+      throw new DeviceError(
+        "invalid-input",
+        "Simulator environment preparation or cleanup is in progress"
+      );
+    this.pendingOpens++;
+    try {
+      return await this.openDevice(input);
+    } finally {
+      this.pendingOpens--;
+    }
+  }
+  async openDevice(input) {
     this.resolveHost(input.hostId);
     const availability = await this.host.platformAvailability(input.platform);
     if (!availability.available) {
@@ -2520,11 +3163,11 @@ var DeviceService = class {
     }));
     return session;
   }
-  async shutdownDevice(deviceId, platform) {
+  async shutdownDevice(deviceId, platform2) {
     const ready = await this.readiness();
     const hub = this.hub(ready);
     try {
-      const result = platform === "ios" ? await hub.shutdownIos(deviceId) : await hub.shutdownDevice(platform, deviceId);
+      const result = platform2 === "ios" ? await hub.shutdownIos(deviceId) : await hub.shutdownDevice(platform2, deviceId);
       if (!result.ok) {
         throw new DeviceError(
           "hub-rejected",
@@ -2534,7 +3177,7 @@ var DeviceService = class {
     } catch (error) {
       const devices = await this.fetchDevices(ready).catch(() => null);
       const known = devices?.devices.find((device) => device.id === deviceId);
-      if (platform !== "ios" || known?.booted !== false) throw error;
+      if (platform2 !== "ios" || known?.booted !== false) throw error;
     }
     this.publish((state) => ({
       ...state,
@@ -2640,7 +3283,8 @@ var DeviceService = class {
       entryPath: ready.agentDevice.entryPath,
       nodePath: ready.probe.execPath,
       electron: ready.probe.electron !== null,
-      platform: ready.probe.platform
+      platform: ready.probe.platform,
+      ...ready.helperPath ? { helperPath: ready.helperPath, sdkRoot: ready.probe.android.root } : {}
     });
     return {
       command,
@@ -2657,6 +3301,28 @@ var DeviceService = class {
     await this.host.installTool(tool);
     return this.inspect();
   }
+  async beginEnvironmentMutation() {
+    if (this.environmentMutating || this.pendingOpens > 0 || this.state.sessions.length > 0 || this.state.bootingDevices.length > 0)
+      throw new DeviceError(
+        "invalid-input",
+        "Close device sessions and wait for device operations to finish before preparing or deleting an environment"
+      );
+    this.environmentMutating = true;
+    this.environmentGeneration++;
+    let release;
+    try {
+      release = await this.host.beginEnvironmentMutation();
+    } catch (error) {
+      this.environmentMutating = false;
+      throw error;
+    }
+    this.setHostStatus({ status: "idle" });
+    return async () => {
+      release();
+      this.environmentMutating = false;
+      await this.inspect(true);
+    };
+  }
   /** 插件停用时：停辅助进程，模拟器本身不关。 */
   async stop() {
     await this.host.stop();
@@ -2730,7 +3396,7 @@ var deviceToolkit = (service) => ({
   tools: [
     {
       name: "device_list",
-      description: "List iOS Simulators and Android Emulators on this machine, which platforms it can run, and which devices are already open in this conversation's Devices panel. Call this before device_open when you do not know a device id.",
+      description: "List iOS Simulators and Android Emulators on this machine for mobile app UI and interaction verification, including SwiftUI, UIKit, Jetpack Compose, Flutter and React Native apps. Reports which platforms this machine can run and which devices are already open in this conversation's Devices panel. Call this before device_open when you do not know a device id.",
       inputSchema: { type: "object", properties: { hostId: HOST_ID_PROPERTY } },
       handle: guard(async (input, invocation) => {
         const threadId = requireThread(invocation);
@@ -2746,7 +3412,7 @@ var deviceToolkit = (service) => ({
     },
     {
       name: "device_open",
-      description: "Open a simulator or emulator for this conversation: boots it if needed, starts its live stream, and shows it in the user's Devices panel. Returns the agent-device command line pinned to the device; drive the device with that command afterwards.",
+      description: "Open an iOS simulator or Android emulator for this conversation, such as when checking a mobile app's screens, navigation, forms and interactions. Boots it if needed, starts its live stream, and shows it in the user's Devices panel. Returns the agent-device command line pinned to the device; use that command to inspect and drive the app afterwards.",
       inputSchema: {
         type: "object",
         properties: {
@@ -2857,12 +3523,14 @@ var deviceToolkit = (service) => ({
 var HUB_SERVICE = "hub";
 var index_default = definePlugin({
   id: "devices",
-  apiVersion: 43,
+  apiVersion: 47,
   activate: async (ctx) => {
     const direct = (input, init) => ctx.proxies.fetch(PLUGIN_PROXY_DIRECT).then((fetchDirect) => fetchDirect(input, init));
     const host = new LocalDeviceHost({
+      pluginDir: ctx.paths.pluginDir,
+      ...ctx.paths.runtimeDir ? { runtimeDir: ctx.paths.runtimeDir } : {},
       dataDir: ctx.paths.dataDir,
-      helperPath: NodePath6.join(ctx.paths.pluginDir, "dist", "helper.mjs"),
+      helperPath: NodePath9.join(ctx.paths.pluginDir, "dist", "helper.mjs"),
       process: ctx.process,
       fetch: direct,
       downloadFetch: ctx.http,
@@ -2884,8 +3552,31 @@ var index_default = definePlugin({
     });
     ctx.toolkit(deviceToolkit(service));
     registerCommands(ctx, service);
+    const environments = new DeviceEnvironments({
+      dataDir: ctx.paths.dataDir,
+      helperPath: NodePath9.join(ctx.paths.pluginDir, "dist", "helper.mjs"),
+      runtimeDir: bundledToolPaths(ctx.paths.pluginDir, HUB_SPEC, ctx.paths.runtimeDir).installDir,
+      process: ctx.process,
+      fetch: ctx.http,
+      log: ctx.log,
+      externalSdk: async () => {
+        const probe = await host.machine(true);
+        return {
+          root: probe.android.root,
+          available: platformAvailability(probe, "android").available
+        };
+      },
+      beforeMutation: () => service.beginEnvironmentMutation(),
+      afterPrepared: async () => {
+        await service.inspect(true);
+      }
+    });
+    registerEnvironmentCommands(ctx, environments);
     ctx.settingsCard(SETTINGS_CARD);
-    ctx.onDispose(() => service.stop());
+    ctx.onDispose(async () => {
+      await environments.dispose();
+      await service.stop();
+    });
   }
 });
 export {