@ycodium-ai/plugin-devices 0.0.0-stage → 0.2.2800

package/dist/index.js

@@ -0,0 +1,2870 @@
+// src/index.ts
+import * as NodePath6 from "node:path";
+import { definePlugin, PLUGIN_PROXY_DIRECT } from "@ycodium-ai/plugin-api";
+
+// src/types.ts
+var DEVICE_PLATFORMS = ["ios", "android"];
+var LOCAL_DEVICE_HOST_ID = "local";
+var DeviceError = class extends Error {
+  code;
+  constructor(code, message, options) {
+    super(message, options);
+    this.name = "DeviceError";
+    this.code = code;
+  }
+};
+var errorDetail = (error) => {
+  if (!(error instanceof Error)) return String(error);
+  const code = error.code;
+  return typeof code === "string" && /^E[A-Z0-9]+$/.test(code) ? code : error.message;
+};
+
+// 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 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_]*)*$/;
+var URL_PATTERN = /^[A-Za-z][A-Za-z0-9+.-]*:[A-Za-z0-9\-._~:/?#[\]@&=+,;%]*$/;
+var MAX_URL_LENGTH = 2048;
+var MAX_ANDROID_PACKAGE_LENGTH = 255;
+var MAX_PUSH_BYTES = 4096;
+var APPEARANCES = ["light", "dark"];
+var TEXT_SIZES = ["small", "default", "large", "extra-large"];
+var TOGGLES = [
+  "reduceMotion",
+  "increaseContrast",
+  "reduceTransparency",
+  "showBorders",
+  "voiceOver",
+  "networkEnabled"
+];
+var LIQUID_GLASS = ["clear", "tinted"];
+var COLOR_FILTERS = [
+  "none",
+  "grayscale",
+  "red-green",
+  "green-red",
+  "blue-yellow"
+];
+var ORIENTATIONS = [
+  "portrait",
+  "landscape_left",
+  "portrait_upside_down",
+  "landscape_right"
+];
+var PERMISSIONS = [
+  "camera",
+  "microphone",
+  "photos",
+  "contacts",
+  "calendar",
+  "reminders",
+  "location",
+  "notifications",
+  "motion",
+  "media-library",
+  "faceid"
+];
+var DECISIONS = ["grant", "revoke", "reset"];
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var oneOf = (values, input, field) => {
+  const found = values.find((value) => value === input);
+  if (found === void 0) throw invalid(field, `expected one of ${values.join(", ")}`);
+  return found;
+};
+var boolean = (input, field) => {
+  if (typeof input !== "boolean") throw invalid(field, "expected true or false");
+  return input;
+};
+var coordinate = (input, field, limit) => {
+  if (typeof input !== "number" || !Number.isFinite(input) || Math.abs(input) > limit) {
+    throw invalid(field, `expected a number between -${String(limit)} and ${String(limit)}`);
+  }
+  return input;
+};
+var assertDeviceId = (id) => {
+  if (typeof id !== "string" || !DEVICE_ID_PATTERN.test(id)) {
+    throw invalid("device id", "expected a simulator udid or adb serial");
+  }
+  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));
+  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"
+    );
+  }
+  return input;
+};
+var url = (input) => {
+  if (typeof input !== "string" || input.length > MAX_URL_LENGTH || !URL_PATTERN.test(input)) {
+    throw invalid("url", "expected a URL with a scheme and no spaces, quotes or shell characters");
+  }
+  return input;
+};
+var pushPayload = (input) => {
+  const payload = typeof input === "string" ? { aps: { alert: input } } : input;
+  if (!isRecord(payload)) throw invalid("push payload", "expected a string or an object");
+  let encoded;
+  try {
+    encoded = JSON.stringify(payload);
+  } catch {
+    encoded = void 0;
+  }
+  if (encoded === void 0) throw invalid("push payload", "could not be encoded as JSON");
+  if (new TextEncoder().encode(encoded).length > MAX_PUSH_BYTES) {
+    throw invalid("push payload", `larger than ${String(MAX_PUSH_BYTES)} bytes`);
+  }
+  return encoded;
+};
+var parseDeviceAction = (platform, input) => {
+  if (!isRecord(input)) throw invalid("action", "expected an object");
+  const type = oneOf(
+    [
+      "setAppearance",
+      "setTextSize",
+      "setToggle",
+      "setLiquidGlass",
+      "setColorFilter",
+      "setOrientation",
+      "setLocation",
+      "clearLocation",
+      "setPermission",
+      "openUrl",
+      "launchApp",
+      "terminateApp",
+      "shake",
+      "sendPush"
+    ],
+    input["type"],
+    "action type"
+  );
+  switch (type) {
+    case "setAppearance":
+      return { type, value: oneOf(APPEARANCES, input["value"], "appearance") };
+    case "setTextSize":
+      return { type, value: oneOf(TEXT_SIZES, input["value"], "text size") };
+    case "setToggle":
+      return {
+        type,
+        setting: oneOf(TOGGLES, input["setting"], "setting"),
+        value: boolean(input["value"], "value")
+      };
+    case "setLiquidGlass":
+      return { type, value: oneOf(LIQUID_GLASS, input["value"], "liquid glass") };
+    case "setColorFilter":
+      return { type, value: oneOf(COLOR_FILTERS, input["value"], "color filter") };
+    case "setOrientation":
+      return { type, value: oneOf(ORIENTATIONS, input["value"], "orientation") };
+    case "setLocation":
+      return {
+        type,
+        latitude: coordinate(input["latitude"], "latitude", 90),
+        longitude: coordinate(input["longitude"], "longitude", 180)
+      };
+    case "clearLocation":
+    case "shake":
+      return { type };
+    case "setPermission":
+      return {
+        type,
+        appId: appId(platform, input["appId"]),
+        permission: oneOf(PERMISSIONS, input["permission"], "permission"),
+        decision: oneOf(DECISIONS, input["decision"], "decision")
+      };
+    case "openUrl":
+      return { type, url: url(input["url"]) };
+    case "launchApp":
+    case "terminateApp":
+      return { type, appId: appId(platform, input["appId"]) };
+    case "sendPush":
+      return {
+        type,
+        appId: appId(platform, input["appId"]),
+        payload: input["payload"]
+      };
+  }
+};
+var IOS_ACTIONS = /* @__PURE__ */ new Set([
+  "setAppearance",
+  "setTextSize",
+  "setToggle",
+  "setLiquidGlass",
+  "setColorFilter",
+  "setLocation",
+  "clearLocation",
+  "setPermission",
+  "openUrl",
+  "launchApp",
+  "terminateApp",
+  "sendPush"
+]);
+var ANDROID_ACTIONS = /* @__PURE__ */ new Set([
+  "setAppearance",
+  "setTextSize",
+  "setToggle",
+  "setOrientation",
+  "setLocation",
+  "clearLocation",
+  "setPermission",
+  "openUrl",
+  "launchApp",
+  "terminateApp"
+]);
+var IOS_TOGGLES = /* @__PURE__ */ new Set([
+  "reduceMotion",
+  "increaseContrast",
+  "reduceTransparency",
+  "showBorders",
+  "voiceOver"
+]);
+var ANDROID_TOGGLES = /* @__PURE__ */ new Set([
+  "reduceMotion",
+  "networkEnabled"
+]);
+var supportsAction = (platform, action) => {
+  if (!(platform === "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 true;
+};
+
+// src/deviceActionSchema.ts
+var target = {
+  hostId: { type: "string", minLength: 1 },
+  deviceId: { type: "string", minLength: 1, maxLength: 128 }
+};
+var appId2 = { type: "string", minLength: 1, maxLength: 255 };
+var branch = (type, properties = {}, required = []) => ({
+  type: "object",
+  additionalProperties: false,
+  required: ["deviceId", "type", ...required],
+  properties: { ...target, type: { const: type }, ...properties }
+});
+var detailPayload = {
+  type: "object",
+  additionalProperties: false,
+  required: ["deviceId"],
+  properties: target
+};
+var actionPayload = {
+  type: "object",
+  oneOf: [
+    branch("setAppearance", { value: { enum: [...APPEARANCES] } }, ["value"]),
+    branch("setTextSize", { value: { enum: [...TEXT_SIZES] } }, ["value"]),
+    branch("setToggle", { setting: { enum: [...TOGGLES] }, value: { type: "boolean" } }, [
+      "setting",
+      "value"
+    ]),
+    branch("setLiquidGlass", { value: { enum: [...LIQUID_GLASS] } }, ["value"]),
+    branch("setColorFilter", { value: { enum: [...COLOR_FILTERS] } }, ["value"]),
+    branch("setOrientation", { value: { enum: [...ORIENTATIONS] } }, ["value"]),
+    branch(
+      "setLocation",
+      {
+        latitude: { type: "number", minimum: -90, maximum: 90 },
+        longitude: { type: "number", minimum: -180, maximum: 180 }
+      },
+      ["latitude", "longitude"]
+    ),
+    branch("clearLocation"),
+    branch(
+      "setPermission",
+      { appId: appId2, permission: { enum: [...PERMISSIONS] }, decision: { enum: [...DECISIONS] } },
+      ["appId", "permission", "decision"]
+    ),
+    branch("openUrl", { url: { type: "string", minLength: 1, maxLength: 2048 } }, ["url"]),
+    branch("launchApp", { appId: appId2 }, ["appId"]),
+    branch("terminateApp", { appId: appId2 }, ["appId"]),
+    branch("shake"),
+    branch("sendPush", { appId: appId2, payload: { type: ["string", "object"] } }, ["appId", "payload"])
+  ]
+};
+
+// src/commands.ts
+var emptyPayload = {
+  type: "object",
+  properties: {},
+  additionalProperties: false
+};
+var deviceTarget = {
+  hostId: { type: "string", minLength: 1 },
+  deviceId: { type: "string", minLength: 1 }
+};
+var openPayload = {
+  type: "object",
+  additionalProperties: false,
+  required: ["threadId", "deviceId", "platform"],
+  properties: {
+    threadId: { type: "string", minLength: 1 },
+    ...deviceTarget,
+    platform: { type: "string", enum: ["ios", "android"] },
+    boot: { type: "boolean" }
+  }
+};
+var closePayload = {
+  type: "object",
+  additionalProperties: false,
+  required: ["threadId"],
+  properties: {
+    threadId: { type: "string", minLength: 1 },
+    ...deviceTarget,
+    shutdown: { type: "boolean" }
+  }
+};
+var shutdownPayload = {
+  type: "object",
+  additionalProperties: false,
+  required: ["deviceId", "platform"],
+  properties: { ...deviceTarget, platform: { type: "string", enum: ["ios", "android"] } }
+};
+var updatePayload = {
+  type: "object",
+  additionalProperties: false,
+  required: ["tool"],
+  properties: { tool: { type: "string", enum: ["hub", "agent"] } }
+};
+var optional = (value) => typeof value === "string" && value.length > 0 ? value : void 0;
+var versionParams = (prefix, version) => ({
+  [`${prefix}Required`]: version?.requiredVersion ?? "\u2014",
+  [`${prefix}Installed`]: version === void 0 || version.installedVersions.length === 0 ? "\u2014" : version.installedVersions.join(", "),
+  [`${prefix}Running`]: version?.runningVersion ?? "\u2014"
+});
+var SETTINGS_CARD = {
+  titleKey: "settings.card.title",
+  descriptionKey: "settings.card.description",
+  actions: [
+    {
+      id: "check-tools",
+      labelKey: "settings.checkTools.label",
+      descriptionKey: "settings.checkTools.description",
+      command: "checkTools"
+    },
+    {
+      id: "update-tools",
+      labelKey: "settings.updateTools.label",
+      descriptionKey: "settings.updateTools.description",
+      command: "updateTools"
+    }
+  ],
+  fields: [
+    {
+      key: "androidSdk",
+      kind: "text",
+      labelKey: "settings.androidSdk.label",
+      descriptionKey: "settings.androidSdk.description",
+      placeholderKey: "settings.androidSdk.placeholder"
+    }
+  ]
+};
+var registerCommands = (ctx, service) => {
+  ctx.stream({
+    name: "state",
+    description: "Device hosts, devices, and which conversation has which device open.",
+    scope: "read",
+    payloadSchema: emptyPayload,
+    buffer: { latest: 8 },
+    handle: async (_payload, emit, signal) => {
+      const unsubscribe = service.subscribe((state) => {
+        if (!signal.aborted) emit(state);
+      });
+      try {
+        await new Promise((resolve) => {
+          if (signal.aborted) resolve();
+          else signal.addEventListener("abort", () => resolve(), { once: true });
+        });
+      } finally {
+        unsubscribe();
+      }
+    }
+  });
+  ctx.command({
+    name: "refresh",
+    description: "Start the device hub if this machine can run a simulator, then list devices.",
+    scope: "operate",
+    payloadSchema: emptyPayload,
+    handle: () => service.list()
+  });
+  ctx.command({
+    name: "inspect",
+    description: "Read the device host's platforms and tool versions without installing or starting anything.",
+    scope: "read",
+    payloadSchema: emptyPayload,
+    handle: () => service.inspect(true)
+  });
+  ctx.command({
+    name: "detail",
+    description: "Read a booted device's settings and foreground app.",
+    scope: "read",
+    payloadSchema: detailPayload,
+    handle: (payload) => service.detail({
+      hostId: optional(payload["hostId"]),
+      deviceId: String(payload["deviceId"])
+    })
+  });
+  ctx.command({
+    name: "action",
+    description: "Run one settings or app action on a booted device, then return its refreshed detail.",
+    scope: "operate",
+    payloadSchema: actionPayload,
+    // 整份 payload 交给服务，由 parseDeviceAction 重新逐字段校验。
+    handle: (payload) => service.action({
+      ...payload,
+      hostId: optional(payload["hostId"]),
+      deviceId: String(payload["deviceId"])
+    })
+  });
+  ctx.command({
+    name: "open",
+    description: "Open a device in a conversation, booting it if needed.",
+    scope: "operate",
+    payloadSchema: openPayload,
+    handle: (payload) => service.open({
+      threadId: String(payload["threadId"]),
+      hostId: optional(payload["hostId"]),
+      deviceId: String(payload["deviceId"]),
+      platform: payload["platform"] === "ios" ? "ios" : "android",
+      ...typeof payload["boot"] === "boolean" ? { boot: payload["boot"] } : {}
+    })
+  });
+  ctx.command({
+    name: "close",
+    description: "Close a device in a conversation; optionally power it off.",
+    scope: "operate",
+    payloadSchema: closePayload,
+    handle: async (payload) => {
+      await service.close({
+        threadId: String(payload["threadId"]),
+        hostId: optional(payload["hostId"]),
+        deviceId: optional(payload["deviceId"]),
+        shutdown: payload["shutdown"] === true
+      });
+      return {};
+    }
+  });
+  ctx.command({
+    name: "shutdown",
+    description: "Power a simulator or emulator off.",
+    scope: "operate",
+    payloadSchema: shutdownPayload,
+    handle: async (payload) => {
+      await service.shutdown({
+        hostId: optional(payload["hostId"]),
+        deviceId: String(payload["deviceId"]),
+        platform: payload["platform"] === "ios" ? "ios" : "android"
+      });
+      return {};
+    }
+  });
+  ctx.command({
+    name: "updateTool",
+    description: "Install this plugin's pinned version of one device tool without starting it.",
+    scope: "operate",
+    payloadSchema: updatePayload,
+    handle: (payload) => service.updateTool(payload["tool"] === "agent" ? "agent" : "hub")
+  });
+  ctx.stream({
+    name: "checkTools",
+    description: "Settings card action: read the installed and running device tool versions.",
+    scope: "operate",
+    payloadSchema: emptyPayload,
+    handle: async (_payload, emit) => {
+      const send = (item) => emit(item);
+      try {
+        const state = await service.inspect(true);
+        const tools = state.hosts[0]?.tools;
+        send({
+          kind: "status",
+          statusKey: "settings.checkTools.versions",
+          params: { ...versionParams("hub", tools?.hub), ...versionParams("agent", tools?.agent) }
+        });
+        send({ kind: "done", fills: {}, messageKey: "settings.checkTools.done" });
+      } catch (error) {
+        send({
+          kind: "failed",
+          reasonKey: "settings.checkTools.failed",
+          detail: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  });
+  ctx.stream({
+    name: "updateTools",
+    description: "Settings card action: install the pinned device tool versions.",
+    scope: "operate",
+    payloadSchema: emptyPayload,
+    handle: async (_payload, emit) => {
+      const order = ["hub", "agent"];
+      const states = new Map(
+        order.map((tool) => [tool, "pending"])
+      );
+      const report = () => emit({
+        kind: "steps",
+        steps: order.map((tool) => ({
+          id: tool,
+          labelKey: `settings.updateTools.${tool}`,
+          state: states.get(tool) ?? "pending"
+        }))
+      });
+      for (const tool of order) {
+        states.set(tool, "running");
+        report();
+        try {
+          await service.updateTool(tool);
+          states.set(tool, "done");
+        } catch (error) {
+          states.set(tool, "failed");
+          report();
+          emit({
+            kind: "failed",
+            reasonKey: "settings.updateTools.failed",
+            detail: error instanceof Error ? error.message : String(error)
+          });
+          return;
+        }
+      }
+      report();
+      emit({
+        kind: "done",
+        fills: {},
+        messageKey: "settings.updateTools.done"
+      });
+    }
+  });
+};
+
+// src/agentDevice.ts
+import * as NodeCrypto from "node:crypto";
+import * as NodeFSP from "node:fs/promises";
+import * as NodePath 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 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 });
+  const content = JSON.stringify({
+    daemonBaseUrl: endpoint.baseUrl,
+    daemonAuthToken: endpoint.token
+  });
+  const existing2 = await NodeFSP.readFile(file, "utf8").catch(() => "");
+  if (existing2 === content) return;
+  const temporary = NodePath.join(
+    NodePath.dirname(file),
+    `.endpoint-${NodeCrypto.randomUUID()}.json`
+  );
+  try {
+    await NodeFSP.writeFile(temporary, content, { mode: 384 });
+    await NodeFSP.rename(temporary, file);
+  } finally {
+    await NodeFSP.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(
+    launcherPath,
+    `import { spawn } from "node:child_process";
+const args = process.argv.slice(2);
+// \u5E2E\u52A9\u4E0E\u7248\u672C\u4E0D\u78B0\u8BBE\u5907\uFF1A\u5355\u72EC\u7684 help/version\uFF0C\u6216\u4EFB\u4F55\u547D\u4EE4\u540E\u5E26 --help / -h\uFF08\u5FEB\u901F\u4E0A\u624B\u91CC\u6559 agent \u8FD9\u6837\u67E5\u53C2\u6570\uFF09\u3002
+const informational =
+  (args.length === 1 && ["help", "--help", "-h", "--version", "version"].includes(args[0])) ||
+  args.includes("--help") ||
+  args.includes("-h");
+const hasValue = flag => { const index = args.indexOf(flag); return index >= 0 && !!args[index + 1] && !args[index + 1].startsWith("--"); };
+if (!informational && !(hasValue("--config") && hasValue("--session"))) {
+  console.error("Call device_open first and include its --config and --session flags.");
+  process.exit(1);
+}
+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 });
+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 electron2 = input.electron ? "set ELECTRON_RUN_AS_NODE=1\r\n" : "";
+    await NodeFSP.writeFile(
+      command2,
+      `@echo off\r
+${electron2}"${input.nodePath}" "${launcherPath}" %*\r
+`
+    );
+    return command2;
+  }
+  const quote = (value) => `'${value.replaceAll("'", `'"'"'`)}'`;
+  const command = NodePath.join(directory, "agent-device");
+  const electron = input.electron ? "ELECTRON_RUN_AS_NODE=1 " : "";
+  await NodeFSP.writeFile(
+    command,
+    `#!/bin/sh
+${electron}exec ${quote(input.nodePath)} ${quote(launcherPath)} "$@"
+`
+  );
+  await NodeFSP.chmod(command, 493);
+  return command;
+};
+var parseDaemonFile = (raw) => {
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof value !== "object" || value === null) return null;
+  const record = value;
+  if (!Number.isSafeInteger(record["httpPort"]) || typeof record["token"] !== "string") return null;
+  return {
+    httpPort: record["httpPort"],
+    token: record["token"],
+    pid: Number.isSafeInteger(record["pid"]) ? record["pid"] : void 0,
+    version: typeof record["version"] === "string" ? record["version"] : void 0
+  };
+};
+var defaultSleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var daemonEnvironment = (stateDir) => ({
+  AGENT_DEVICE_STATE_DIR: stateDir,
+  AGENT_DEVICE_DAEMON_SERVER_MODE: "http",
+  AGENT_DEVICE_DAEMON_IDLE_TIMEOUT_MS: "0",
+  AGENT_DEVICE_NO_UPDATE_NOTIFIER: "1",
+  FORCE_COLOR: "0",
+  NO_COLOR: "1"
+});
+var AgentDaemon = class {
+  entryPath = null;
+  now;
+  sleep;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.now = options.now ?? Date.now;
+    this.sleep = options.sleep ?? defaultSleep;
+  }
+  get daemonFilePath() {
+    return NodePath.join(this.options.stateDir, "daemon.json");
+  }
+  async readDaemonFile() {
+    const raw = await NodeFSP.readFile(this.daemonFilePath, "utf8").catch(() => null);
+    return raw === null ? null : parseDaemonFile(raw);
+  }
+  async healthy(port) {
+    try {
+      const response = await this.options.fetch(`http://127.0.0.1:${String(port)}/health`, {
+        signal: AbortSignal.timeout(2e3)
+      });
+      await response.arrayBuffer().catch(() => void 0);
+      return response.status === 200;
+    } catch {
+      return false;
+    }
+  }
+  toEndpoint(file, entryPath) {
+    return {
+      baseUrl: `http://127.0.0.1:${String(file.httpPort)}`,
+      token: file.token,
+      entryPath,
+      version: file.version ?? null,
+      pid: file.pid ?? null
+    };
+  }
+  /**
+   * agent-device 没有 `daemon start`：状态目录里第一条命令会拉起守护进程并等它应答，
+   * `devices` 是最便宜的一条。之后读它写出的 daemon.json。
+   */
+  async ensure(input) {
+    this.entryPath = input.entryPath;
+    await NodeFSP.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);
+    }
+    const args = [this.options.helperPath, "node"];
+    if (input.sdkRoot !== null) args.push("--sdk", input.sdkRoot);
+    args.push("--", input.entryPath, "devices", "--json");
+    const timeoutMs = this.options.readyTimeoutMs ?? DAEMON_READY_TIMEOUT_MS;
+    await this.options.process.run({
+      program: "host:node",
+      args,
+      cwd: this.options.stateDir,
+      env: daemonEnvironment(this.options.stateDir),
+      timeoutMs
+    }).catch(() => void 0);
+    const deadline = this.now() + timeoutMs;
+    while (true) {
+      const file = await this.readDaemonFile();
+      if (file !== null) return this.toEndpoint(file, input.entryPath);
+      if (this.now() > deadline) {
+        throw new DeviceError(
+          "agent-timeout",
+          `Agent tools did not start within ${String(timeoutMs)} ms.`
+        );
+      }
+      await this.sleep(DAEMON_POLL_MS);
+    }
+  }
+  /** 守护进程是 agent-device 自己脱离出去的，宿主停插件时杀不到它，所以显式停。 */
+  async stop() {
+    const entryPath = this.entryPath;
+    if (entryPath === null) return;
+    await this.options.process.run({
+      program: "host:node",
+      args: [entryPath, "daemon", "stop", "--state-dir", this.options.stateDir],
+      cwd: this.options.stateDir,
+      env: { AGENT_DEVICE_NO_UPDATE_NOTIFIER: "1" },
+      timeoutMs: 1e4
+    }).catch(() => void 0);
+  }
+};
+var agentDeviceQuickStart = (device, targetArgs, command) => {
+  const quoteArg = (arg) => /^[a-zA-Z0-9_./:\\-]+$/.test(arg) ? arg : `"${arg.replaceAll('"', '\\"')}"`;
+  const executable = quoteArg(command);
+  const target2 = targetArgs.map(quoteArg).join(" ");
+  const platformNote = device.platform === "ios" ? "First use builds an XCTest runner and can take a couple of minutes; later commands are fast." : "The Android snapshot helper installs itself on first use.";
+  return [
+    `The user can watch ${device.name} (${device.version}) in the Devices panel.`,
+    `Drive it with ${executable}. Use this exact executable path; login shells may reset PATH. Always pass ${target2}.`,
+    "Typical loop:",
+    `  ${executable} open <bundle-or-package-id> ${target2}     # or: open <app> <deep-link-url>`,
+    `  ${executable} snapshot -i ${target2}                     # accessibility tree with @eN refs`,
+    `  ${executable} click @e3 ${target2}`,
+    `  ${executable} fill @e5 "text" ${target2}`,
+    `  ${executable} screenshot <file.png> ${target2}           # or call device_screenshot`,
+    `  ${executable} install <app> <path-to-.app-or-.apk> ${target2}`,
+    `Prefer snapshot refs over coordinates. Run ${executable} help for workflow guides and ${executable} <command> --help for flags.`,
+    "Prefer agent-device for driving this device. simctl, adb, and xcrun remain available for anything it does not cover.",
+    "Keep the returned --config and --session flags on every command.",
+    platformNote
+  ].join("\n");
+};
+
+// src/hubProcess.ts
+import * as NodeFSP2 from "node:fs/promises";
+import * as NodePath2 from "node:path";
+
+// ../../packages/ycodium-fetch-ports/src/fetchPorts.ts
+import * as NodeNet from "node:net";
+var FETCH_BLOCKED_PORTS = /* @__PURE__ */ new Set([
+  1,
+  7,
+  9,
+  11,
+  13,
+  15,
+  17,
+  19,
+  20,
+  21,
+  22,
+  23,
+  25,
+  37,
+  42,
+  43,
+  53,
+  69,
+  77,
+  79,
+  87,
+  95,
+  101,
+  102,
+  103,
+  104,
+  109,
+  110,
+  111,
+  113,
+  115,
+  117,
+  119,
+  123,
+  135,
+  137,
+  139,
+  143,
+  161,
+  179,
+  389,
+  427,
+  465,
+  512,
+  513,
+  514,
+  515,
+  526,
+  530,
+  531,
+  532,
+  540,
+  548,
+  554,
+  556,
+  563,
+  587,
+  601,
+  636,
+  989,
+  990,
+  993,
+  995,
+  1719,
+  1720,
+  1723,
+  2049,
+  3659,
+  4045,
+  4190,
+  5060,
+  5061,
+  6e3,
+  6566,
+  6665,
+  6666,
+  6667,
+  6668,
+  6669,
+  6679,
+  6697,
+  10080
+]);
+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) => {
+  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);
+  });
+});
+var listenOnSafePort = async (server, options = {}) => {
+  const host = options.host ?? "127.0.0.1";
+  const portForAttempt = options.portForAttempt ?? systemAssigned;
+  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()));
+  }
+  throw new Error(`\u8FDE\u7EED ${String(MAX_SAFE_PORT_ATTEMPTS)} \u6B21\u5206\u5230 fetch \u7684\u574F\u7AEF\u53E3`);
+};
+var reserveFetchSafePort = async (options = {}) => {
+  const probe = NodeNet.createServer();
+  try {
+    const port = await listenOnSafePort(probe, options);
+    await new Promise((resolve) => probe.close(() => resolve()));
+    if (port <= 0) throw new Error("\u65E0\u6CD5\u53D6\u5F97\u76D1\u542C\u7AEF\u53E3");
+    return port;
+  } catch (cause) {
+    try {
+      probe.close();
+    } catch {
+    }
+    throw cause;
+  }
+};
+
+// src/hubProcess.ts
+var HUB_READY_TIMEOUT_MS = 3e4;
+var HUB_READY_POLL_MS = 200;
+var HUB_RESTART_STABLE_UPTIME_MS = 6e4;
+var HUB_RESTART_MAX_DELAY_MS = 3e4;
+var OUTPUT_TAIL_LINES = 20;
+var nodeProcessProbe = {
+  isAlive: (pid) => {
+    try {
+      process.kill(pid, 0);
+      return true;
+    } catch (error) {
+      return error.code === "EPERM";
+    }
+  },
+  terminate: (pid) => {
+    try {
+      process.kill(pid, "SIGTERM");
+    } catch {
+    }
+  }
+};
+var defaultSleep2 = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
+var drainOutput = (handle) => {
+  const tail = [];
+  const decoder = new TextDecoder();
+  const drain = async (stream) => {
+    let pending = "";
+    for await (const chunk of stream) {
+      pending += decoder.decode(chunk, { stream: true });
+      const lines = pending.split(/\r?\n/);
+      pending = lines.pop() ?? "";
+      for (const line of lines) {
+        if (line.trim().length === 0) continue;
+        tail.push(line.trim());
+        if (tail.length > OUTPUT_TAIL_LINES) tail.shift();
+      }
+    }
+  };
+  void drain(handle.stdout).catch(() => void 0);
+  void drain(handle.stderr).catch(() => void 0);
+  return () => tail.join("\n");
+};
+var HubProcess = class {
+  current = null;
+  restartDelayMs = 0;
+  stopped = false;
+  probe;
+  now;
+  sleep;
+  options;
+  constructor(options) {
+    this.options = options;
+    this.probe = options.processProbe ?? nodeProcessProbe;
+    this.now = options.now ?? Date.now;
+    this.sleep = options.sleep ?? defaultSleep2;
+  }
+  get statePath() {
+    return NodePath2.join(this.options.stateDir, "hub.json");
+  }
+  get running() {
+    return this.current?.hub ?? null;
+  }
+  async answersReady(origin, timeoutMs = 2e3) {
+    try {
+      const response = await this.options.fetch(`${origin}/readyz`, {
+        signal: AbortSignal.timeout(timeoutMs)
+      });
+      await response.arrayBuffer().catch(() => void 0);
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /** 上次的服务器没收尾留下的 hub：pid 活着且那个端口答 /readyz 才结束它。 */
+  async reapStale() {
+    let previous = null;
+    try {
+      const parsed = JSON.parse(
+        await NodeFSP2.readFile(this.statePath, "utf8")
+      );
+      if (Number.isSafeInteger(parsed.pid) && Number.isSafeInteger(parsed.port) && typeof parsed.entryPath === "string") {
+        previous = parsed;
+      }
+    } catch {
+      previous = null;
+    }
+    if (previous !== null && previous.pid > 0 && this.probe.isAlive(previous.pid)) {
+      if (await this.answersReady(`http://127.0.0.1:${String(previous.port)}`)) {
+        this.options.log.warn("Stopping a device hub left behind by a previous server", {
+          pid: previous.pid,
+          port: previous.port
+        });
+        this.probe.terminate(previous.pid);
+      }
+    }
+    await NodeFSP2.rm(this.statePath, { force: true }).catch(() => void 0);
+  }
+  async spawnOnce(launch) {
+    await this.reapStale();
+    await NodeFSP2.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"];
+    if (launch.sdkRoot !== null) args.push("--sdk", launch.sdkRoot);
+    args.push(
+      "--",
+      launch.entryPath,
+      "--port",
+      String(port),
+      "--host",
+      "127.0.0.1",
+      "--hide-sidebar",
+      "--hide-boot-device"
+    );
+    let handle;
+    try {
+      handle = await this.options.process.spawn({
+        program: "host:node",
+        args,
+        cwd: this.options.stateDir,
+        env: { FORCE_COLOR: "0", NO_COLOR: "1" }
+      });
+    } catch (cause) {
+      throw new DeviceError(
+        "host-unavailable",
+        "Device support failed while starting the device hub.",
+        {
+          cause
+        }
+      );
+    }
+    const output = drainOutput(handle);
+    let exited = false;
+    void handle.exited.then(() => {
+      exited = true;
+    });
+    const deadline = this.now() + (this.options.readyTimeoutMs ?? HUB_READY_TIMEOUT_MS);
+    while (!await this.answersReady(origin)) {
+      if (exited || this.now() > deadline) {
+        await handle.kill().catch(() => void 0);
+        const tail = output();
+        throw new DeviceError(
+          "host-unavailable",
+          `Device support failed while waiting for the device hub to answer.${tail ? `
+${tail}` : ""}`
+        );
+      }
+      await this.sleep(HUB_READY_POLL_MS);
+    }
+    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);
+    this.current = { hub, handle };
+    this.options.log.info("Device hub started", { pid: handle.pid, port });
+    this.options.onStarted?.(hub);
+    void this.supervise(handle, launch);
+    return hub;
+  }
+  /** hub 意外退出时重启；开机就崩的 hub 按 1 秒起、翻倍到 30 秒的间隔重试，不空转。 */
+  async supervise(handle, launch) {
+    await handle.exited;
+    if (this.stopped || this.current?.handle !== handle) return;
+    const uptime = this.now() - this.current.hub.startedAt;
+    this.current = null;
+    const delay = uptime >= HUB_RESTART_STABLE_UPTIME_MS ? 0 : this.restartDelayMs;
+    this.restartDelayMs = uptime >= HUB_RESTART_STABLE_UPTIME_MS ? 0 : this.restartDelayMs === 0 ? 1e3 : Math.min(this.restartDelayMs * 2, HUB_RESTART_MAX_DELAY_MS);
+    this.options.log.warn("Device hub exited; restarting", { pid: handle.pid, delayMs: delay });
+    await this.sleep(delay);
+    if (this.stopped || this.current !== null) return;
+    await this.spawnOnce(launch).catch((error) => {
+      this.options.log.warn("Device hub restart failed", {
+        detail: error instanceof Error ? error.message : String(error)
+      });
+    });
+  }
+  /** 已在跑就直接返回；否则起一个。 */
+  async ensure(launch) {
+    this.stopped = false;
+    if (this.current !== null) return this.current.hub;
+    this.restartDelayMs = 0;
+    return this.spawnOnce(launch);
+  }
+  /** 结束 hub。设备本身不关，那是用户的。 */
+  async stop() {
+    this.stopped = true;
+    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);
+  }
+};
+
+// 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/toolchain.ts
+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 HUB_SPEC = {
+  tool: "hub",
+  packageName: "expo-device-hub",
+  version: DEVICE_HUB_VERSION,
+  entry: ["dist", "server", "cli.mjs"]
+};
+var AGENT_DEVICE_SPEC = {
+  tool: "agent",
+  packageName: "agent-device",
+  version: AGENT_DEVICE_VERSION,
+  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);
+  return {
+    installDir,
+    entryPath: NodePath4.join(installDir, "node_modules", spec.packageName, ...spec.entry),
+    sentinelPath: NodePath4.join(installDir, ".install-complete")
+  };
+};
+var agentDeviceStateDir = (dataDir) => NodePath4.join(dataDir, "agent-device");
+var fileExists2 = async (file) => {
+  try {
+    await NodeFSP4.access(file);
+    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 })
+      : 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) => {
+    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/serveSimHelpers.ts
+import * as NodeFSP5 from "node:fs/promises";
+import * as NodePath5 from "node:path";
+var existing = (file) => NodeFSP5.access(file).then(
+  () => file,
+  () => null
+);
+var serveSimHelpers = async (dataDir) => {
+  const dist = NodePath5.join(
+    toolPaths(dataDir, HUB_SPEC).installDir,
+    "node_modules",
+    HUB_SPEC.packageName,
+    "vendor",
+    "serve-sim",
+    "dist"
+  );
+  const [axSettings2, cli] = await Promise.all([
+    existing(NodePath5.join(dist, "simax", "serve-sim-ax-settings")),
+    existing(NodePath5.join(dist, "serve-sim.js"))
+  ]);
+  return { axSettings: axSettings2, cli };
+};
+
+// src/localHost.ts
+var installPhaseDetail = (tool, version, required) => {
+  const previous = version?.runningVersion ?? [...version?.installedVersions ?? []].sort((a, b) => a.localeCompare(b, "en", { numeric: true })).at(-1);
+  return previous !== void 0 && !(version?.installedVersions ?? []).includes(required) ? { tool, fromVersion: previous, toVersion: required } : { tool, toVersion: required };
+};
+var LocalDeviceHost = class {
+  id = LOCAL_DEVICE_HOST_ID;
+  probeCache = null;
+  hub;
+  agent;
+  agentEndpoint = null;
+  lock = Promise.resolve();
+  options;
+  constructor(options) {
+    this.options = options;
+    const stateDir = agentDeviceStateDir(options.dataDir);
+    this.hub = new HubProcess({
+      stateDir,
+      helperPath: options.helperPath,
+      process: options.process,
+      fetch: options.fetch,
+      log: options.log,
+      ...options.hub,
+      ...options.onHubStarted === void 0 ? {} : { onStarted: (hub) => options.onHubStarted?.(hub.port) }
+    });
+    this.agent = new AgentDaemon({
+      stateDir,
+      helperPath: options.helperPath,
+      process: options.process,
+      fetch: options.fetch
+    });
+  }
+  /** 生命周期操作串行：两个调用者同时要起 hub 时只起一次。 */
+  installInput(spec) {
+    return {
+      dataDir: this.options.dataDir,
+      spec,
+      helperPath: this.options.helperPath,
+      process: this.options.process,
+      fetch: this.options.downloadFetch
+    };
+  }
+  serialized(task) {
+    const next = this.lock.then(task, task);
+    this.lock = next.catch(() => void 0);
+    return next;
+  }
+  async machine(refresh = false) {
+    if (this.probeCache !== null && !refresh) return this.probeCache;
+    this.probeCache = await probeMachine({
+      helperPath: this.options.helperPath,
+      process: this.options.process,
+      cwd: this.options.dataDir,
+      sdkOverride: this.options.sdkOverride
+    });
+    return this.probeCache;
+  }
+  async platformAvailability(platform) {
+    return platformAvailability(await this.machine(), platform);
+  }
+  async platforms(refresh = false) {
+    const probe = await this.machine(refresh);
+    return DEVICE_PLATFORMS.map((platform) => platformAvailability(probe, platform));
+  }
+  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);
+  }
+  /** 不装不起，只读现状。探测失败（比如没有 Node）时平台一律按不可用报。 */
+  async summary(refresh = false) {
+    const [platforms, hubInstalled, agentDeviceInstalled, hub, agent] = await Promise.all([
+      this.platforms(refresh).catch(
+        (error) => DEVICE_PLATFORMS.map((platform) => ({
+          platform,
+          available: false,
+          reason: errorDetail(error)
+        }))
+      ),
+      isToolInstalled(this.options.dataDir, HUB_SPEC),
+      isToolInstalled(this.options.dataDir, AGENT_DEVICE_SPEC),
+      this.toolVersion(HUB_SPEC),
+      this.toolVersion(AGENT_DEVICE_SPEC)
+    ]);
+    return {
+      id: this.id,
+      kind: "local",
+      platforms,
+      tools: { hub, agent },
+      hubInstalled,
+      agentDeviceInstalled
+    };
+  }
+  async installIfNeeded(spec, onPhase) {
+    if (!await isToolInstalled(this.options.dataDir, spec)) {
+      onPhase(
+        "installing",
+        installPhaseDetail(spec.tool, await this.toolVersion(spec), spec.version)
+      );
+    }
+    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) {
+    const probe = await this.machine();
+    const running = this.hub.running;
+    if (running !== null) return { hostId: this.id, hubOrigin: running.origin, probe };
+    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 };
+  }
+  /** 首次使用时装 hub 并起来；幂等，hub 已在跑就直接返回。 */
+  ensureReady(onPhase) {
+    return this.serialized(() => this.startHub(onPhase));
+  }
+  /** hub 之外再装、起 agent-device 守护进程。 */
+  ensureAgentReady(onPhase) {
+    return this.serialized(async () => {
+      const ready = await this.startHub(onPhase);
+      if (this.agentEndpoint !== null) return { ...ready, agentDevice: this.agentEndpoint };
+      const tool = await this.installIfNeeded(AGENT_DEVICE_SPEC, onPhase);
+      onPhase("starting");
+      const endpoint = await this.agent.ensure({
+        entryPath: tool.entryPath,
+        sdkRoot: ready.probe.android.root
+      });
+      this.agentEndpoint = endpoint;
+      await this.prune(AGENT_DEVICE_SPEC);
+      return { ...ready, agentDevice: endpoint };
+    });
+  }
+  /** 已在跑时的 hub 地址，不启动任何东西。 */
+  current() {
+    return this.hub.running?.origin ?? null;
+  }
+  /** 只装不起：设置里的「更新工具」用。 */
+  installTool(tool) {
+    return this.serialized(async () => {
+      await ensureTool(this.installInput(toolSpec(tool)));
+    });
+  }
+  /**
+   * 在宿主上跑一条工具命令。adb、emulator、xcrun 经助手的 run 模式补好 PATH；node 直接用宿主的
+   * Node 起脚本。只传 argv，不过 shell。
+   */
+  async runTool(program, args, options = {}) {
+    const stdin = options.stdin === void 0 ? {} : { stdin: options.stdin };
+    const base = {
+      program: "host:node",
+      cwd: this.options.dataDir,
+      timeoutMs: options.timeoutMs ?? 2e4
+    };
+    let input;
+    if (program === "node") {
+      input = { ...base, args: [...args], ...stdin };
+    } else {
+      const probe = await this.machine();
+      const helperArgs = [this.options.helperPath, "run"];
+      if (probe.android.root !== null) helperArgs.push("--sdk", probe.android.root);
+      helperArgs.push("--", program, ...args);
+      input = { ...base, args: helperArgs, ...stdin };
+    }
+    const result = await this.options.process.run(input).catch((error) => ({
+      exitCode: 127,
+      stdout: "",
+      stderr: error instanceof Error ? error.message : String(error)
+    }));
+    return { stdout: result.stdout, stderr: result.stderr, code: result.exitCode ?? 1 };
+  }
+  /** 在宿主上跑一条 SDK 命令（adb、emulator），经助手补好 PATH。 */
+  runSdkCommand(command, args, timeoutMs = 2e4) {
+    return this.runTool(command, args, { timeoutMs });
+  }
+  /** 设备操作与读详情要的工具：命令执行器加 iOS 的 serve-sim 助手路径。 */
+  async actionTools() {
+    return {
+      run: (program, args, options) => this.runTool(program, args, options),
+      helpers: await serveSimHelpers(this.options.dataDir)
+    };
+  }
+  /** 只停 agent-device；用户自己在面板里看设备不受影响。 */
+  stopAgent() {
+    return this.serialized(async () => {
+      await this.agent.stop();
+      this.agentEndpoint = null;
+    });
+  }
+  /** 停辅助进程。模拟器本身不关，那是用户的。 */
+  stop() {
+    return this.serialized(async () => {
+      await this.hub.stop();
+      await this.agent.stop();
+      this.agentEndpoint = null;
+    });
+  }
+};
+
+// src/deviceActions.ts
+var IOS_TEXT_SIZES = {
+  small: "small",
+  default: "large",
+  large: "extra-extra-large",
+  "extra-large": "accessibility-large"
+};
+var ANDROID_TEXT_SIZES = {
+  small: "0.85",
+  default: "1.0",
+  large: "1.15",
+  "extra-large": "1.3"
+};
+var textSizeFromIos = (category) => {
+  const entry = Object.entries(IOS_TEXT_SIZES).find(
+    ([, value]) => value === category
+  );
+  if (entry !== void 0) return entry[0];
+  if (category.startsWith("accessibility")) return "extra-large";
+  if (category.includes("extra")) return "large";
+  return category === "extra-small" || category === "small" || category === "medium" ? "small" : "default";
+};
+var textSizeFromAndroid = (scale) => {
+  if (scale <= 0.9) return "small";
+  if (scale >= 1.25) return "extra-large";
+  if (scale >= 1.1) return "large";
+  return "default";
+};
+var IOS_TOGGLE_OPTIONS = {
+  reduceMotion: "reduce-motion",
+  reduceTransparency: "reduce-transparency",
+  showBorders: "show-borders",
+  voiceOver: "voiceover"
+};
+var IOS_PRIVACY_SERVICES = {
+  camera: "camera",
+  microphone: "microphone",
+  photos: "photos",
+  contacts: "contacts",
+  calendar: "calendar",
+  reminders: "reminders",
+  motion: "motion",
+  "media-library": "media-library",
+  faceid: "faceid",
+  location: "location"
+};
+var ANDROID_PERMISSIONS = {
+  camera: ["android.permission.CAMERA"],
+  microphone: ["android.permission.RECORD_AUDIO"],
+  photos: ["android.permission.READ_MEDIA_IMAGES", "android.permission.READ_EXTERNAL_STORAGE"],
+  contacts: ["android.permission.READ_CONTACTS", "android.permission.WRITE_CONTACTS"],
+  calendar: ["android.permission.READ_CALENDAR", "android.permission.WRITE_CALENDAR"],
+  location: [
+    "android.permission.ACCESS_FINE_LOCATION",
+    "android.permission.ACCESS_COARSE_LOCATION"
+  ],
+  notifications: ["android.permission.POST_NOTIFICATIONS"],
+  motion: ["android.permission.ACTIVITY_RECOGNITION"]
+};
+var ANDROID_GRAVITY = {
+  portrait: "0:9.81:0",
+  landscape_left: "9.81:0:0",
+  portrait_upside_down: "0:-9.81:0",
+  landscape_right: "-9.81:0:0"
+};
+var ANDROID_ROTATION = {
+  portrait: "0",
+  landscape_left: "1",
+  portrait_upside_down: "2",
+  landscape_right: "3"
+};
+var decimal = (value) => /e/i.test(String(value)) ? value.toFixed(10).replace(/\.?0+$/, "") || "0" : String(value);
+var checked = async (result, operation) => {
+  const done = await result;
+  if (done.code !== 0) {
+    throw new DeviceError(
+      "command-failed",
+      `Device ${operation} failed (exit code ${String(done.code)}).`,
+      {
+        cause: done
+      }
+    );
+  }
+  return done.stdout;
+};
+var simctl = (tools, udid, args, operation, options) => checked(
+  tools.run("xcrun", ["simctl", ...args.slice(0, 1), udid, ...args.slice(1)], options),
+  operation
+);
+var axSettings = (tools, udid, args) => {
+  const helper = tools.helpers.axSettings;
+  if (helper === null) {
+    throw new DeviceError(
+      "helper-missing",
+      "Device accessibility requires a helper missing from this install. Set up device support again."
+    );
+  }
+  return checked(tools.run("xcrun", ["simctl", "spawn", udid, helper, ...args]), "accessibility");
+};
+var runIos = async (tools, udid, action) => {
+  switch (action.type) {
+    case "setAppearance":
+      await simctl(tools, udid, ["ui", "appearance", action.value], "appearance");
+      return;
+    case "setTextSize":
+      await simctl(tools, udid, ["ui", "content_size", IOS_TEXT_SIZES[action.value]], "text size");
+      return;
+    case "setToggle": {
+      if (action.setting === "increaseContrast") {
+        await simctl(
+          tools,
+          udid,
+          ["ui", "increase_contrast", action.value ? "enabled" : "disabled"],
+          "increase contrast"
+        );
+        return;
+      }
+      const option = IOS_TOGGLE_OPTIONS[action.setting];
+      if (option === void 0) throw unsupported(action.type, "ios");
+      await axSettings(tools, udid, ["set", option, action.value ? "on" : "off"]);
+      return;
+    }
+    case "setLiquidGlass":
+      await axSettings(tools, udid, ["set", "liquid-glass", action.value]);
+      return;
+    case "setColorFilter":
+      await axSettings(tools, udid, ["set", "color-filter", action.value]);
+      return;
+    case "setLocation":
+      await simctl(
+        tools,
+        udid,
+        ["location", "set", `${decimal(action.latitude)},${decimal(action.longitude)}`],
+        "location"
+      );
+      return;
+    case "clearLocation":
+      await simctl(tools, udid, ["location", "clear"], "location");
+      return;
+    case "setPermission": {
+      if (action.permission === "notifications") {
+        const cli = tools.helpers.cli;
+        if (cli === null) {
+          throw new DeviceError(
+            "helper-missing",
+            "Device permission requires a helper missing from this install. Set up device support again."
+          );
+        }
+        await checked(
+          tools.run("node", [
+            cli,
+            "permissions",
+            action.decision,
+            action.permission,
+            action.appId,
+            "-d",
+            udid
+          ]),
+          "permission"
+        );
+        return;
+      }
+      const service = IOS_PRIVACY_SERVICES[action.permission];
+      if (service === void 0) throw unsupported("permission", "ios");
+      await simctl(tools, udid, ["privacy", action.decision, service, action.appId], "permission");
+      return;
+    }
+    case "openUrl":
+      await simctl(tools, udid, ["openurl", action.url], "open url");
+      return;
+    case "launchApp":
+      await simctl(tools, udid, ["launch", action.appId], "launch");
+      return;
+    case "terminateApp":
+      await simctl(tools, udid, ["terminate", action.appId], "terminate");
+      return;
+    case "sendPush":
+      await simctl(tools, udid, ["push", action.appId, "-"], "push", {
+        stdin: pushPayload(action.payload)
+      });
+      return;
+    case "shake":
+    case "setOrientation":
+      throw unsupported(action.type, "ios");
+  }
+};
+var adb = (tools, serial, args, operation) => checked(tools.run("adb", ["-s", serial, ...args]), operation);
+var runAndroid = async (tools, serial, action) => {
+  const shell = (args, operation) => adb(tools, serial, ["shell", ...args], operation);
+  switch (action.type) {
+    case "setAppearance":
+      await shell(["cmd", "uimode", "night", action.value === "dark" ? "yes" : "no"], "appearance");
+      return;
+    case "setTextSize":
+      await shell(
+        ["settings", "put", "system", "font_scale", ANDROID_TEXT_SIZES[action.value]],
+        "text size"
+      );
+      return;
+    case "setToggle": {
+      if (action.setting === "networkEnabled") {
+        const state = action.value ? "enable" : "disable";
+        await shell(["svc", "wifi", state], "network");
+        await shell(["svc", "data", state], "network");
+        return;
+      }
+      if (action.setting === "reduceMotion") {
+        const scale = action.value ? "0" : "1";
+        for (const key2 of [
+          "animator_duration_scale",
+          "transition_animation_scale",
+          "window_animation_scale"
+        ]) {
+          await shell(["settings", "put", "global", key2, scale], "reduce motion");
+        }
+        return;
+      }
+      throw unsupported(action.type, "android");
+    }
+    case "setOrientation": {
+      if (serial.startsWith("emulator-")) {
+        await shell(["settings", "put", "system", "accelerometer_rotation", "1"], "orientation");
+        await shell(["cmd", "window", "user-rotation", "free"], "orientation");
+        await adb(
+          tools,
+          serial,
+          ["emu", "sensor", "set", "acceleration", ANDROID_GRAVITY[action.value]],
+          "orientation"
+        );
+        return;
+      }
+      await shell(
+        ["cmd", "window", "user-rotation", "lock", ANDROID_ROTATION[action.value]],
+        "orientation"
+      );
+      return;
+    }
+    case "setLocation":
+      await adb(
+        tools,
+        serial,
+        ["emu", "geo", "fix", decimal(action.longitude), decimal(action.latitude)],
+        "location"
+      );
+      return;
+    case "clearLocation":
+      return;
+    case "setPermission": {
+      const permissions = ANDROID_PERMISSIONS[action.permission];
+      if (permissions === void 0) throw unsupported("permission", "android");
+      const verb = action.decision === "grant" ? "grant" : "revoke";
+      for (const permission of permissions) {
+        await shell(["pm", verb, action.appId, permission], "permission").catch(() => void 0);
+      }
+      return;
+    }
+    case "openUrl":
+      await shell(
+        ["am", "start", "-a", "android.intent.action.VIEW", "-d", `'${action.url}'`],
+        "open url"
+      );
+      return;
+    case "launchApp":
+      await shell(
+        ["monkey", "-p", action.appId, "-c", "android.intent.category.LAUNCHER", "1"],
+        "launch"
+      );
+      return;
+    case "terminateApp":
+      await shell(["am", "force-stop", action.appId], "terminate");
+      return;
+    case "setLiquidGlass":
+    case "setColorFilter":
+    case "shake":
+    case "sendPush":
+      throw unsupported(action.type, "android");
+  }
+};
+var runDeviceAction = async (tools, device, input) => {
+  const id = assertDeviceId(device.id);
+  const action = parseDeviceAction(device.platform, input);
+  if (!supportsAction(device.platform, action)) throw unsupported(action.type, device.platform);
+  if (device.platform === "ios") await runIos(tools, id, action);
+  else await runAndroid(tools, id, action);
+};
+var quiet = async (task) => {
+  try {
+    return await task();
+  } catch {
+    return void 0;
+  }
+};
+var isColorFilter = (value) => COLOR_FILTERS.some((filter) => filter === value);
+var onOff = (value) => value === "on" ? true : value === "off" ? false : void 0;
+var parseAxStatus = (stdout) => {
+  if (stdout === void 0) return void 0;
+  try {
+    const parsed = JSON.parse(stdout);
+    if (!isRecord(parsed)) return void 0;
+    return Object.fromEntries(
+      Object.entries(parsed).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    );
+  } catch {
+    return void 0;
+  }
+};
+var readIos = async (tools, udid) => {
+  const uiValue = (option) => quiet(async () => (await simctl(tools, udid, ["ui", option], option)).trim().toLowerCase());
+  const [appearance, contentSize, contrast, axStdout] = await Promise.all([
+    uiValue("appearance"),
+    uiValue("content_size"),
+    uiValue("increase_contrast"),
+    tools.helpers.axSettings === null ? Promise.resolve(void 0) : quiet(() => axSettings(tools, udid, ["status"]))
+  ]);
+  const ax = parseAxStatus(axStdout);
+  const flag = (key2) => ax === void 0 ? void 0 : onOff(ax[key2]);
+  const glass = ax?.["liquid-glass"];
+  const filter = ax?.["color-filter"];
+  const booleans = {
+    reduceMotion: flag("reduce-motion"),
+    reduceTransparency: flag("reduce-transparency"),
+    showBorders: flag("show-borders"),
+    voiceOver: flag("voiceover")
+  };
+  const settings = {
+    ...appearance === "light" || appearance === "dark" ? { appearance } : {},
+    ...contentSize ? { textSize: textSizeFromIos(contentSize) } : {},
+    ...contrast ? { increaseContrast: contrast === "enabled" } : {},
+    ...Object.fromEntries(Object.entries(booleans).filter(([, value]) => value !== void 0)),
+    ...glass === "clear" || glass === "tinted" ? { liquidGlass: glass } : {},
+    ...isColorFilter(filter) ? { colorFilter: filter } : {}
+  };
+  return { settings, foregroundApp: null };
+};
+var readAndroid = async (tools, serial) => {
+  const shell = (args) => quiet(async () => (await adb(tools, serial, ["shell", ...args], args[0] ?? "shell")).trim());
+  const [night, fontScale, animator, wifi, focus] = await Promise.all([
+    shell(["cmd", "uimode", "night"]),
+    shell(["settings", "get", "system", "font_scale"]),
+    shell(["settings", "get", "global", "animator_duration_scale"]),
+    shell(["settings", "get", "global", "wifi_on"]),
+    // `dumpsys window windows` 在 API 36 起不再打印焦点；不带过滤的整份 dump 还打。
+    shell(["dumpsys", "window"])
+  ]);
+  const scale = fontScale && fontScale !== "null" ? Number(fontScale) : Number.NaN;
+  const focused = focus?.match(/m(?:CurrentFocus|FocusedApp)=\w+\{[^ ]+ u\d+ ([^/ ]+)\//);
+  const settings = {
+    ...night?.includes("yes") ? { appearance: "dark" } : night?.includes("no") ? { appearance: "light" } : {},
+    ...Number.isFinite(scale) ? { textSize: textSizeFromAndroid(scale) } : {},
+    ...animator !== void 0 && animator !== "null" ? { reduceMotion: Number(animator) === 0 } : {},
+    ...wifi === "1" || wifi === "0" ? { networkEnabled: wifi === "1" } : {}
+  };
+  const foregroundApp = focused?.[1] === void 0 ? null : { id: focused[1] };
+  return { settings, foregroundApp };
+};
+var readDeviceDetail = async (tools, device) => {
+  const id = assertDeviceId(device.id);
+  return device.platform === "ios" ? readIos(tools, id) : readAndroid(tools, id);
+};
+
+// src/hubClient.ts
+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 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") {
+    return null;
+  }
+  return { id, name, version, platform, 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 devices = [];
+  for (const entry of [...simulators, ...emulators]) {
+    const device = parseHubDevice(entry);
+    if (device === null) return null;
+    devices.push(device);
+  }
+  const errors = Array.isArray(value["errors"]) ? value["errors"].flatMap(
+    (error) => isRecord3(error) && typeof error["message"] === "string" ? [error["message"]] : []
+  ) : [];
+  return { devices, errors };
+};
+var parseHubActionResult = (value) => {
+  if (!isRecord3(value) || typeof value["ok"] !== "boolean") return null;
+  const text2 = (key2) => typeof value[key2] === "string" ? value[key2] : void 0;
+  return { ok: value["ok"], id: text2("id"), serial: text2("serial"), error: text2("error") };
+};
+var HubClient = class {
+  origin;
+  fetch;
+  constructor(origin, fetch) {
+    this.origin = origin;
+    this.fetch = fetch;
+  }
+  async json(path, operation, init = {}) {
+    let response;
+    try {
+      response = await this.fetch(`${this.origin}${path}`, {
+        method: init.method ?? "GET",
+        ...init.body === void 0 ? {} : { body: JSON.stringify(init.body), headers: { "content-type": "application/json" } },
+        signal: AbortSignal.timeout(init.timeoutMs ?? DEFAULT_TIMEOUT_MS)
+      });
+    } catch (cause) {
+      throw new DeviceError(
+        "hub-request-failed",
+        `Device ${operation} failed: could not reach the device hub.`,
+        { cause }
+      );
+    }
+    if (!response.ok) {
+      throw new DeviceError(
+        "hub-request-failed",
+        `Device ${operation} failed: the device hub answered ${String(response.status)}.`
+      );
+    }
+    try {
+      return await response.json();
+    } catch (cause) {
+      throw new DeviceError("hub-request-failed", `Device ${operation} failed: unreadable reply.`, {
+        cause
+      });
+    }
+  }
+  async listDevices() {
+    const list = parseHubDeviceList(await this.json("/api/devices", "list"));
+    if (list === null) {
+      throw new DeviceError("hub-request-failed", "Device list failed: unexpected reply shape.");
+    }
+    return list;
+  }
+  async action(path, operation, body, timeoutMs) {
+    const result = parseHubActionResult(
+      await this.json(path, operation, {
+        method: "POST",
+        body,
+        ...timeoutMs === void 0 ? {} : { timeoutMs }
+      })
+    );
+    if (result === null) {
+      throw new DeviceError(
+        "hub-request-failed",
+        `Device ${operation} failed: unexpected reply shape.`
+      );
+    }
+    return result;
+  }
+  boot(device) {
+    return this.action(
+      "/api/devices/boot",
+      "boot",
+      { platform: device.platform, id: device.id, name: device.name },
+      BOOT_TIMEOUT_MS
+    );
+  }
+  /** iOS：开机不会挂上出画面的助手；grid start 两样都做，对已开机的模拟器幂等。 */
+  attachIosStream(udid) {
+    return this.action(
+      `${vendorPrefix("ios")}/grid/api/start`,
+      "attach stream",
+      { udid },
+      BOOT_TIMEOUT_MS
+    );
+  }
+  shutdownIos(udid) {
+    return this.action(`${vendorPrefix("ios")}/grid/api/shutdown`, "shutdown", { udid });
+  }
+  shutdownDevice(platform, id) {
+    return this.action("/api/devices/shutdown", "shutdown", { platform, id });
+  }
+  async screenshot(platform, deviceId) {
+    let response;
+    try {
+      response = await this.fetch(
+        `${this.origin}${vendorPrefix(platform)}/api/screenshot?device=${encodeURIComponent(deviceId)}`,
+        { method: "POST", signal: AbortSignal.timeout(SCREENSHOT_TIMEOUT_MS) }
+      );
+    } catch (cause) {
+      throw new DeviceError(
+        "hub-request-failed",
+        "Device screenshot failed: could not reach the device hub.",
+        {
+          cause
+        }
+      );
+    }
+    if (!response.ok) {
+      throw new DeviceError(
+        "hub-request-failed",
+        `Device screenshot failed: the device hub answered ${String(response.status)}.`
+      );
+    }
+    return new Uint8Array(await response.arrayBuffer());
+  }
+};
+var classifyBootFailure = (error) => {
+  const text2 = error ?? "";
+  if (/insufficient.*(?:disk|space)|not enough.*(?:disk|space)|no space left/i.test(text2)) {
+    return "boot-disk-space";
+  }
+  if (/timed? out|timeout/i.test(text2)) return "boot-timeout";
+  return "boot-failed";
+};
+
+// src/service.ts
+var sameDevice = (a, hostId, deviceId) => a.hostId === hostId && a.id === deviceId;
+var DeviceService = class {
+  state = {
+    hosts: [],
+    hostStatuses: {},
+    devices: [],
+    sessions: [],
+    bootingDevices: [],
+    revision: 0
+  };
+  listeners = /* @__PURE__ */ new Set();
+  host;
+  options;
+  now;
+  constructor(options) {
+    this.options = options;
+    this.host = options.host;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+  }
+  get current() {
+    return this.state;
+  }
+  /** 立刻收到当前状态，之后每次变化收一份。 */
+  subscribe(listener) {
+    this.listeners.add(listener);
+    listener(this.state);
+    return () => this.listeners.delete(listener);
+  }
+  publish(update) {
+    const next = { ...update(this.state), revision: this.state.revision + 1 };
+    this.state = next;
+    for (const listener of this.listeners) listener(next);
+    return next;
+  }
+  setHostStatus(detail) {
+    this.publish((state) => ({
+      ...state,
+      hostStatuses: { ...state.hostStatuses, [this.host.id]: detail }
+    }));
+  }
+  onPhase = (phase, detail) => {
+    this.setHostStatus({ status: phase, ...detail });
+  };
+  resolveHost(hostId) {
+    if ((hostId ?? LOCAL_DEVICE_HOST_ID) !== this.host.id) {
+      throw new DeviceError("host-unavailable", `Unknown device host ${String(hostId)}.`);
+    }
+  }
+  async withStatus(task) {
+    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
+      });
+      throw error;
+    }
+  }
+  /** 起 hub 并刷新设备。机器一个平台都跑不了时什么都不装，返回 null。 */
+  async readinessIfSupported() {
+    const platforms = await this.host.platforms();
+    if (!platforms.some((platform) => platform.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") {
+        this.setHostStatus({ status: "ready" });
+      }
+      return ready;
+    });
+  }
+  hub(ready) {
+    return new HubClient(ready.hubOrigin, this.options.fetch);
+  }
+  async fetchDevices(ready) {
+    const list = await this.hub(ready).listDevices();
+    const devices = list.devices.map((device) => ({
+      ...device,
+      hostId: ready.hostId
+    }));
+    if ((await this.host.platformAvailability("android")).available) {
+      const avds = await this.host.runSdkCommand("emulator", ["-list-avds"]);
+      if (avds.code !== 0) {
+        throw new DeviceError(
+          "command-failed",
+          `Listing Android virtual devices failed (exit code ${String(avds.code)}).`
+        );
+      }
+      for (const name of avds.stdout.split(/\r?\n/).map((line) => line.trim()).filter(Boolean)) {
+        if (!devices.some((device) => device.platform === "android" && device.name === name)) {
+          devices.push({
+            hostId: ready.hostId,
+            id: name,
+            name,
+            platform: "android",
+            version: "Android",
+            booted: false,
+            physical: false
+          });
+        }
+      }
+    }
+    return list.errors.length > 0 ? { devices, detail: list.errors.join("\n") } : { devices };
+  }
+  async refresh(ready) {
+    const { devices, detail } = await this.withStatus(() => this.fetchDevices(ready));
+    const summary = await this.host.summary();
+    return this.publish((state) => ({
+      ...state,
+      hosts: [summary],
+      devices: [...state.devices.filter((device) => device.hostId !== ready.hostId), ...devices],
+      hostStatuses: {
+        ...state.hostStatuses,
+        [ready.hostId]: { status: "ready", ...detail === void 0 ? {} : { message: detail } }
+      }
+    }));
+  }
+  /** 宿主现状，不装不起。 */
+  async inspect(refreshProbe = false) {
+    const summary = await this.host.summary(refreshProbe);
+    return this.publish((state) => ({ ...state, hosts: [summary] }));
+  }
+  /** 列设备：能跑的话起 hub 再刷新；跑不了只更新宿主现状。失败记在宿主状态里，不抛。 */
+  async list() {
+    try {
+      const ready = await this.readinessIfSupported();
+      if (ready === null) return await this.inspect();
+      return await this.refresh(ready);
+    } catch {
+      return this.state;
+    }
+  }
+  async open(input) {
+    this.resolveHost(input.hostId);
+    const availability = await this.host.platformAvailability(input.platform);
+    if (!availability.available) {
+      throw new DeviceError(
+        "platform-unavailable",
+        `${input.platform} devices are unavailable on this machine: ${availability.reason ?? "toolchain missing"}`
+      );
+    }
+    const ready = await this.readiness();
+    let device = (await this.refresh(ready)).devices.find(
+      (candidate) => sameDevice(candidate, ready.hostId, input.deviceId)
+    );
+    if (device === void 0) {
+      throw new DeviceError(
+        "device-not-found",
+        `Device ${input.deviceId} was not found on this machine.`
+      );
+    }
+    const hub = this.hub(ready);
+    if (!device.booted && input.boot !== false) {
+      const booting = { ...device, threadId: input.threadId };
+      this.publish((state) => ({
+        ...state,
+        bootingDevices: [
+          ...state.bootingDevices.filter((entry) => !sameDevice(entry, booting.hostId, booting.id)),
+          booting
+        ]
+      }));
+      let bootedId;
+      try {
+        const result = await hub.boot(device);
+        if (!result.ok) {
+          const code = classifyBootFailure(result.error);
+          throw new DeviceError(
+            code,
+            `Device ${device.id} failed to boot: ${result.error ?? code}.`
+          );
+        }
+        if (device.platform === "ios") await hub.attachIosStream(device.id);
+        bootedId = result.serial ?? result.id ?? device.id;
+      } finally {
+        this.publish((state) => ({
+          ...state,
+          bootingDevices: state.bootingDevices.filter(
+            (entry) => !sameDevice(entry, booting.hostId, booting.id)
+          )
+        }));
+      }
+      const after = await this.refresh(ready);
+      const original = device;
+      device = after.devices.find((candidate) => sameDevice(candidate, ready.hostId, bootedId)) ?? after.devices.find((candidate) => sameDevice(candidate, ready.hostId, original.id));
+      if (device === void 0) {
+        throw new DeviceError(
+          "device-not-found",
+          `Device ${bootedId} was not found after booting.`
+        );
+      }
+    } else if (device.platform === "ios" && device.booted) {
+      await hub.attachIosStream(device.id);
+    }
+    const session = {
+      threadId: input.threadId,
+      hostId: ready.hostId,
+      deviceId: device.id,
+      platform: device.platform,
+      openedAt: this.now().toISOString()
+    };
+    this.publish((state) => ({
+      ...state,
+      sessions: [
+        ...state.sessions.filter(
+          (existing2) => !(existing2.threadId === session.threadId && existing2.hostId === session.hostId && existing2.deviceId === session.deviceId)
+        ),
+        session
+      ]
+    }));
+    return session;
+  }
+  async shutdownDevice(deviceId, platform) {
+    const ready = await this.readiness();
+    const hub = this.hub(ready);
+    try {
+      const result = platform === "ios" ? await hub.shutdownIos(deviceId) : await hub.shutdownDevice(platform, deviceId);
+      if (!result.ok) {
+        throw new DeviceError(
+          "hub-rejected",
+          `Device shutdown failed: ${result.error ?? "the hub refused"}.`
+        );
+      }
+    } 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;
+    }
+    this.publish((state) => ({
+      ...state,
+      devices: state.devices.map(
+        (device) => sameDevice(device, ready.hostId, deviceId) ? { ...device, booted: false } : device
+      ),
+      sessions: state.sessions.filter(
+        (session) => !(session.hostId === ready.hostId && session.deviceId === deviceId)
+      )
+    }));
+    await this.refresh(ready).catch((error) => {
+      this.options.log.warn("Device discovery unavailable after shutdown", {
+        detail: error instanceof Error ? error.message : String(error)
+      });
+    });
+  }
+  async close(input) {
+    const closing = this.state.sessions.filter(
+      (session) => session.threadId === input.threadId && (input.hostId === void 0 || session.hostId === input.hostId) && (input.deviceId === void 0 || session.deviceId === input.deviceId)
+    );
+    if (closing.length === 0) return;
+    this.publish((state) => ({
+      ...state,
+      sessions: state.sessions.filter((session) => !closing.includes(session))
+    }));
+    if (input.shutdown === true) {
+      for (const session of closing) await this.shutdownDevice(session.deviceId, session.platform);
+    }
+  }
+  async shutdown(input) {
+    this.resolveHost(input.hostId);
+    await this.shutdownDevice(input.deviceId, input.platform);
+  }
+  async screenshot(input) {
+    this.resolveHost(input.hostId);
+    const ready = await this.readiness();
+    const device = this.state.devices.find((candidate) => sameDevice(candidate, ready.hostId, input.deviceId)) ?? (await this.refresh(ready)).devices.find(
+      (candidate) => sameDevice(candidate, ready.hostId, input.deviceId)
+    );
+    if (device === void 0) {
+      throw new DeviceError(
+        "device-not-found",
+        `Device ${input.deviceId} was not found on this machine.`
+      );
+    }
+    const png = await this.hub(ready).screenshot(device.platform, device.id);
+    return { device, png };
+  }
+  /** 找目标设备：缓存里没有、或缓存说没开机时先刷新一次，免得被外面刚开机的设备骗过。 */
+  async resolveTarget(input) {
+    this.resolveHost(input.hostId);
+    const ready = await this.readiness();
+    const find = (state) => state.devices.find((candidate) => sameDevice(candidate, ready.hostId, input.deviceId));
+    let device = find(this.state);
+    if (device === void 0 || !device.booted) device = find(await this.refresh(ready));
+    if (device === void 0) {
+      throw new DeviceError(
+        "device-not-found",
+        `Device ${input.deviceId} was not found on this machine.`
+      );
+    }
+    return { ready, device };
+  }
+  async readDetail(hostId, device) {
+    const read = device.booted ? await readDeviceDetail(await this.host.actionTools(), device) : { settings: {}, foregroundApp: null };
+    return {
+      hostId,
+      deviceId: device.id,
+      settings: read.settings,
+      foregroundApp: read.foregroundApp,
+      readAt: this.now().toISOString()
+    };
+  }
+  /** 设备当前的设置与前台应用。没开机时设置为空。 */
+  async detail(input) {
+    const { ready, device } = await this.resolveTarget(input);
+    return this.readDetail(ready.hostId, device);
+  }
+  /** 在已开机的设备上跑一次操作，返回操作后的详情。入参整份交给校验，目标之外的键会被丢掉。 */
+  async action(input) {
+    const { ready, device } = await this.resolveTarget(input);
+    if (!device.booted) {
+      throw new DeviceError("device-not-booted", `Device ${device.id} is not booted.`);
+    }
+    await runDeviceAction(await this.host.actionTools(), device, input);
+    return this.readDetail(ready.hostId, device);
+  }
+  sessionsForThread(threadId) {
+    return this.state.sessions.filter((session) => session.threadId === threadId);
+  }
+  /**
+   * agent 用这台设备前的准备：装、起 agent-device 守护进程，写这台宿主的连接配置与启动器，
+   * 返回启动器路径和把命令钉到这条会话、这台设备的参数。
+   */
+  async agentTarget(input) {
+    this.resolveHost(input.hostId);
+    const ready = await this.withStatus(() => this.host.ensureAgentReady(this.onPhase));
+    this.setHostStatus({ status: "ready" });
+    const configPath = agentDeviceConfigPath(this.options.dataDir, input.hostId);
+    await writeAgentDeviceConfig(configPath, ready.agentDevice);
+    const command = await ensureAgentDeviceLauncher({
+      dataDir: this.options.dataDir,
+      entryPath: ready.agentDevice.entryPath,
+      nodePath: ready.probe.execPath,
+      electron: ready.probe.electron !== null,
+      platform: ready.probe.platform
+    });
+    return {
+      command,
+      args: [
+        "--config",
+        configPath,
+        "--session",
+        agentDeviceSession(input.threadId, input.hostId, input.deviceId)
+      ]
+    };
+  }
+  /** 设置里的「更新工具」：只装不起，装完重读版本。 */
+  async updateTool(tool) {
+    await this.host.installTool(tool);
+    return this.inspect();
+  }
+  /** 插件停用时：停辅助进程，模拟器本身不关。 */
+  async stop() {
+    await this.host.stop();
+  }
+};
+
+// src/tools.ts
+var text = (value) => ({ text: JSON.stringify(value, null, 2) });
+var failure = (message, errorCode) => ({
+  text: message,
+  isError: true,
+  ...errorCode === void 0 ? {} : { errorCode }
+});
+var asString = (value) => typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+var asPlatform = (value) => value === "ios" || value === "android" ? value : void 0;
+var pngDimensions = (png) => {
+  if (png.length < 24) return { width: 0, height: 0 };
+  const view = new DataView(png.buffer, png.byteOffset, png.byteLength);
+  const isPng = view.getUint32(0) === 2303741511 && view.getUint32(4) === 218765834 && view.getUint32(12) === 1229472850;
+  return isPng ? { width: view.getUint32(16), height: view.getUint32(20) } : { width: 0, height: 0 };
+};
+var pickDevice = (devices, input) => {
+  const hostId = input.hostId ?? LOCAL_DEVICE_HOST_ID;
+  if (input.deviceId !== void 0) {
+    const match = devices.find(
+      (device) => device.hostId === hostId && device.id === input.deviceId
+    );
+    if (match) return match;
+    throw new DeviceError(
+      "device-not-found",
+      `No device ${input.deviceId} on host ${hostId}. Call devices_device_list for current ids.`
+    );
+  }
+  const candidates = devices.filter(
+    (device) => device.hostId === hostId && (input.platform === void 0 || device.platform === input.platform)
+  );
+  if (candidates.length === 0) {
+    throw new DeviceError(
+      "device-not-found",
+      input.platform === void 0 ? "No simulators or emulators were found. Call devices_device_list to see why." : `No ${input.platform} devices were found on host ${hostId}. Call devices_device_list to see why.`
+    );
+  }
+  if (input.platform === void 0 && new Set(candidates.map((device) => device.platform)).size > 1) {
+    throw new DeviceError(
+      "ambiguous-platform",
+      "Both iOS and Android devices are available; pass platform or deviceId."
+    );
+  }
+  return candidates.find((device) => device.booted) ?? candidates[0];
+};
+var requireThread = (invocation) => {
+  if (invocation.threadId === null) {
+    throw new DeviceError("no-open-device", "Device tools can only be used from a conversation.");
+  }
+  return invocation.threadId;
+};
+var guard = (handle) => async (input, invocation) => {
+  try {
+    return await handle(input, invocation);
+  } catch (error) {
+    if (error instanceof DeviceError) return failure(error.message, error.code);
+    throw error;
+  }
+};
+var HOST_ID_PROPERTY = {
+  type: "string",
+  description: "Device host from devices_device_list. Defaults to this machine."
+};
+var deviceToolkit = (service) => ({
+  name: "devices",
+  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.",
+      inputSchema: { type: "object", properties: { hostId: HOST_ID_PROPERTY } },
+      handle: guard(async (input, invocation) => {
+        const threadId = requireThread(invocation);
+        const state = await service.list();
+        const hostId = asString(input["hostId"]);
+        return text({
+          hostStatuses: state.hostStatuses,
+          hosts: hostId ? state.hosts.filter((host) => host.id === hostId) : state.hosts,
+          devices: hostId ? state.devices.filter((device) => device.hostId === hostId) : state.devices,
+          open: service.sessionsForThread(threadId).map((session) => ({ hostId: session.hostId, deviceId: session.deviceId }))
+        });
+      })
+    },
+    {
+      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.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          deviceId: {
+            type: "string",
+            description: "Simulator udid or emulator serial from devices_device_list. Omit to use the booted device for the platform, or the first one."
+          },
+          platform: {
+            type: "string",
+            enum: ["ios", "android"],
+            description: "Required when deviceId is omitted and both platforms are available."
+          },
+          hostId: HOST_ID_PROPERTY
+        }
+      },
+      handle: guard(async (input, invocation) => {
+        const threadId = requireThread(invocation);
+        const state = await service.list();
+        const target2 = pickDevice(state.devices, {
+          deviceId: asString(input["deviceId"]),
+          platform: asPlatform(input["platform"]),
+          hostId: asString(input["hostId"])
+        });
+        const agent = await service.agentTarget({
+          threadId,
+          hostId: target2.hostId,
+          deviceId: target2.id
+        });
+        const session = await service.open({
+          threadId,
+          hostId: target2.hostId,
+          deviceId: target2.id,
+          platform: target2.platform
+        });
+        const device = service.current.devices.find(
+          (candidate) => candidate.hostId === session.hostId && candidate.id === session.deviceId
+        ) ?? target2;
+        const targetArgs = [...agentDeviceTargetArgs(device), ...agent.args];
+        return text({
+          device,
+          agentDevice: { command: agent.command, targetArgs },
+          quickStart: agentDeviceQuickStart(device, targetArgs, agent.command)
+        });
+      })
+    },
+    {
+      name: "device_screenshot",
+      description: "Capture the current screen of an open device as a PNG image. Use it to see what the user sees; for taps and text use the agent-device command line.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          deviceId: {
+            type: "string",
+            description: "Device from devices_device_list. Omit to use the device most recently opened in this conversation."
+          },
+          hostId: HOST_ID_PROPERTY
+        }
+      },
+      handle: guard(async (input, invocation) => {
+        const threadId = requireThread(invocation);
+        const hostId = asString(input["hostId"]);
+        const deviceId = asString(input["deviceId"]);
+        const target2 = deviceId !== void 0 ? { hostId: hostId ?? LOCAL_DEVICE_HOST_ID, deviceId } : service.sessionsForThread(threadId).findLast((session) => hostId === void 0 || session.hostId === hostId);
+        if (target2 === void 0) {
+          return failure(
+            "No device is open in this conversation. Call devices_device_open first.",
+            "no-open-device"
+          );
+        }
+        const shot = await service.screenshot(target2);
+        return {
+          text: JSON.stringify({ device: shot.device, ...pngDimensions(shot.png) }),
+          images: [{ data: shot.png, mimeType: "image/png" }]
+        };
+      })
+    },
+    {
+      name: "device_close",
+      description: "Remove a device from this conversation's Devices panel. Pass shutdown=true to also power the simulator or emulator off.",
+      inputSchema: {
+        type: "object",
+        properties: {
+          deviceId: {
+            type: "string",
+            description: "Device to close. Omit to close every device in this conversation."
+          },
+          hostId: HOST_ID_PROPERTY,
+          shutdown: {
+            type: "boolean",
+            description: "Also power the device off. Defaults to false."
+          }
+        }
+      },
+      handle: guard(async (input, invocation) => {
+        await service.close({
+          threadId: requireThread(invocation),
+          hostId: asString(input["hostId"]),
+          deviceId: asString(input["deviceId"]),
+          shutdown: input["shutdown"] === true
+        });
+        return text({});
+      })
+    }
+  ]
+});
+
+// src/index.ts
+var HUB_SERVICE = "hub";
+var index_default = definePlugin({
+  id: "devices",
+  apiVersion: 3,
+  activate: async (ctx) => {
+    const direct = (input, init) => ctx.proxies.fetch(PLUGIN_PROXY_DIRECT).then((fetchDirect) => fetchDirect(input, init));
+    const host = new LocalDeviceHost({
+      dataDir: ctx.paths.dataDir,
+      helperPath: NodePath6.join(ctx.paths.pluginDir, "dist", "helper.mjs"),
+      process: ctx.process,
+      fetch: direct,
+      downloadFetch: ctx.http,
+      log: ctx.log,
+      sdkOverride: typeof ctx.config.androidSdk === "string" ? ctx.config.androidSdk : "",
+      onHubStarted: (port) => {
+        ctx.network.serve(HUB_SERVICE, { port, instance: LOCAL_DEVICE_HOST_ID }).catch((error) => {
+          ctx.log.warn("Could not hand the device hub to the plugin network proxy", {
+            detail: error instanceof Error ? error.message : String(error)
+          });
+        });
+      }
+    });
+    const service = new DeviceService({
+      host,
+      dataDir: ctx.paths.dataDir,
+      fetch: direct,
+      log: ctx.log
+    });
+    ctx.toolkit(deviceToolkit(service));
+    registerCommands(ctx, service);
+    ctx.settingsCard(SETTINGS_CARD);
+    ctx.onDispose(() => service.stop());
+  }
+});
+export {
+  index_default as default
+};