obsidian-integration-testing 12.1.2 → 12.3.0

package/dist/lib/cjs/emulator-reaper.d.cts

@@ -0,0 +1,225 @@
+/**
+ * @file
+ *
+ * Stops an emulator this harness started once its run is gone for good — the
+ * case nothing else covers, **L56**'s path B with no later run: the runner is
+ * killed (SIGKILL, Task Manager, an IDE stop button), no teardown runs, and no
+ * other Android run ever comes along to reclaim the leftover from its marker.
+ * On 2026-09-10 an emulator left like that kept `netsimd` spinning for six hours.
+ *
+ * The reaper is a small detached Node process spawned beside every emulator the
+ * harness starts or takes over. It holds no handle to the emulator and needs
+ * none: the marker (`emulator-marker.ts`) says what to stop, and the verified
+ * stop (`emulator-reclaim.ts`) is the one the run's own teardown uses.
+ *
+ * ## It watches the `android` setup lock, not the process that started it
+ *
+ * The process that starts the emulator is not always the run. A project with no
+ * transport global setup boots it from a **test worker** (**L56** path A), and
+ * Vitest ends workers during a perfectly healthy run — so a reaper tied to its
+ * spawner's lifetime (the **L33** liveness socket, the first idea) would stop
+ * the emulator mid-run, or race the next worker taking it over. The `android`
+ * setup lock (**L7**) is held by the run's main process for the whole run, and
+ * its holder being alive is exactly what "an Android run is in flight" means.
+ *
+ * So the reaper polls that lock, and once it can **take** it — no live run
+ * holds it — it stops the harness's leftovers while holding it, which is the
+ * precondition every leftover stop documents: no run can adopt an emulator that
+ * is mid-shutdown. That is precisely what the next run's preflight would do,
+ * done at the first moment that run could have done it.
+ *
+ * A dead same-host holder is abandoned at once. A live-PID holder that has gone
+ * silent is only abandoned after
+ * {@link EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS}, far wider than the
+ * two minutes a waiting run steals on: a reaper is always waiting, so at two
+ * minutes a live run that blocked its event loop would lose its emulator.
+ *
+ * ## Fail-open, like the renderer watchdog
+ *
+ * A reaper is armed only when a live run holds the lock at the moment the
+ * emulator is recorded. A run that takes no lock — a hand-wired
+ * `createTransportFromOptions` — gets none, and says so, rather than a reaper
+ * that would read its missing lock as "the run is over" and stop an emulator
+ * somebody is using. A spawn that fails is logged and never fails the launch.
+ *
+ * ## How it runs
+ *
+ * `process.execPath -e <bootstrap> <this module's URL> <avdName> <startedAt>`:
+ * the bootstrap `import()`s this very module and calls {@link runEmulatorReaper}.
+ * The URL is the built `.mjs` / `.cjs` in a consumer's install, and the `.ts`
+ * source in this repo's own suites, which Node's type stripping runs as-is — so
+ * nothing this module imports may reach a module that reads the build-time
+ * `OBSIDIAN_METADATA` global. Its stdout/stderr go to a per-AVD log file, capped
+ * at {@link EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES}, so the verdict lines the stop
+ * prints are on record even though no terminal is left to show them.
+ *
+ * ## It is started through a relay, so a process-tree kill cannot take it
+ *
+ * `detached` does not reparent on Windows: a child spawned straight from the run
+ * stays in the run's process tree, so the kill shapes that walk that tree take
+ * the safety net along with the thing it was guarding — Task Manager's *End
+ * task*, `taskkill /T`, an IDE stop button, a `ParentProcessId` descendant
+ * sweep. Measured on 2026-09-11: a reaper died with the run it was watching, and
+ * the emulator it would have stopped idled on for ten minutes.
+ *
+ * So the spawn goes through a relay — {@link buildEmulatorReaperRelayBootstrap} —
+ * which starts the reaper and exits at once. By the time any tree-walker takes
+ * its snapshot the relay is gone, so there is no edge from the run to the reaper
+ * left to follow. This is the double-fork idiom, and it holds on POSIX for the
+ * same reason: once the relay exits, the reaper belongs to `init`.
+ */
+import type { EmulatorMarker } from './emulator-marker.cjs';
+/**
+ * How often the reaper looks at the marker and the lock — the lock's own
+ * heartbeat interval, so a killed run is noticed within one beat.
+ */
+export declare const EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS = 5000;
+/**
+ * How long a same-host lock holder whose PID is still alive may stay silent
+ * before the reaper treats its run as gone: 30 minutes, the threshold the lock
+ * already uses across hosts. Only a recycled PID should ever reach it.
+ */
+export declare const EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS = 1800000;
+/**
+ * The size past which the reaper log is started afresh rather than appended to.
+ */
+export declare const EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES = 1048576;
+/**
+ * The export the bootstrap calls. Named here so the bootstrap and the export
+ * cannot drift apart.
+ */
+export declare const EMULATOR_REAPER_ENTRY_NAME = "runEmulatorReaper";
+/**
+ * What the reaper watches for: the emulator a marker recorded when it was armed.
+ */
+export interface EmulatorReaperArguments {
+    /**
+    The AVD whose marker it watches.
+     */
+    readonly avdName: string;
+    /**
+     * When the watched emulator was launched. A takeover keeps it, so it names one
+     * emulator across every run that owns it, and tells a later emulator of the
+     * same AVD apart.
+     */
+    readonly startedAtInMilliseconds: number;
+}
+/**
+ * What the marker says the reaper should do next.
+ *
+ * - `emulator-stopped` — the marker is gone, or none of its PIDs is alive: the
+ *   emulator was stopped, so there is nothing left to watch.
+ * - `superseded` — the marker now records a different emulator of the same AVD,
+ *   which has its own reaper.
+ * - `watch` — the emulator is still up.
+ */
+export type EmulatorReaperWatchVerdict = 'emulator-stopped' | 'superseded' | 'watch';
+/**
+ * Parameters for {@link resolveEmulatorReaperWatch}.
+ */
+export interface ResolveEmulatorReaperWatchParams {
+    /**
+    The launch time of the emulator this reaper was armed for.
+     */
+    readonly armedStartedAtInMilliseconds: number;
+    /**
+    Whether a PID is still running.
+     */
+    readonly checkIsPidAlive: (pid: number) => boolean;
+    /**
+    The AVD's marker as it reads now, if any.
+     */
+    readonly marker: EmulatorMarker | undefined;
+}
+/**
+ * Parameters for {@link spawnEmulatorReaper}.
+ */
+export interface SpawnEmulatorReaperParams {
+    /**
+    The AVD whose emulator was just recorded.
+     */
+    readonly avdName: string;
+    /**
+    Receives the armed / not-armed line.
+     */
+    readonly log: (message: string) => void;
+    /**
+    The recorded emulator's launch time, as written into its marker.
+     */
+    readonly startedAtInMilliseconds: number;
+}
+/**
+ * Encodes the reaper's arguments for its command line.
+ *
+ * @param reaperArguments - What the reaper watches for.
+ * @returns The command-line arguments, in the order {@link parseEmulatorReaperArguments} reads them.
+ */
+export declare function buildEmulatorReaperArguments(reaperArguments: EmulatorReaperArguments): string[];
+/**
+ * Builds the script `node -e` runs to start the reaper.
+ *
+ * It `import()`s the module whose URL is its first argument and hands the rest
+ * to {@link runEmulatorReaper}. `import()` rather than `require`, because it
+ * loads all three forms the module ships as — ESM, CJS, and this repo's own
+ * `.ts` source under Node's type stripping. A CJS module's named exports are
+ * found by Node's static analysis; `default` is the fallback when they are not.
+ *
+ * @returns The script.
+ */
+export declare function buildEmulatorReaperBootstrap(): string;
+/**
+ * Builds the script `node -e` runs as the **relay**: it starts the reaper and
+ * exits at once, so the reaper is left with a dead parent and no tree-walking
+ * kill of the run can reach it. See the relay section in this module's header
+ * for why that indirection exists at all.
+ *
+ * Its own arguments are the reaper's whole command line — the bootstrap script
+ * first, then everything that bootstrap reads — so the relay never has to know
+ * what any of them mean. It hands the reaper its own stdout and stderr, which
+ * are the capped log file the spawner opened, so the log is unaffected by the
+ * extra hop.
+ *
+ * @returns The script.
+ */
+export declare function buildEmulatorReaperRelayBootstrap(): string;
+/**
+ * Decodes the reaper's command-line arguments.
+ *
+ * @param argv - The arguments after the module URL.
+ * @returns The arguments, or `undefined` when they are not the two {@link buildEmulatorReaperArguments} writes.
+ */
+export declare function parseEmulatorReaperArguments(argv: readonly string[]): EmulatorReaperArguments | undefined;
+/**
+ * Decides how the reaper log is opened, so it can never grow without bound.
+ *
+ * @param sizeInBytes - The log's current size, or `undefined` when there is none.
+ * @returns `'a'` to append, or `'w'` to start it afresh once it has passed the cap.
+ */
+export declare function resolveEmulatorReaperLogOpenFlag(sizeInBytes: number | undefined): 'a' | 'w';
+/**
+ * Decides what the marker says the reaper should do next.
+ *
+ * @param params - The marker as it reads now, and the emulator the reaper was armed for.
+ * @returns The verdict.
+ */
+export declare function resolveEmulatorReaperWatch(params: ResolveEmulatorReaperWatchParams): EmulatorReaperWatchVerdict;
+/**
+ * The reaper process's body: watches the marker and the lock until either the
+ * emulator is gone or no run holds the lock, and in the second case stops the
+ * harness's leftovers while holding it.
+ *
+ * Exported for the bootstrap, which is its only caller.
+ *
+ * @param argv - The reaper's arguments, as {@link buildEmulatorReaperArguments} wrote them.
+ */
+export declare function runEmulatorReaper(argv: readonly string[]): Promise<void>;
+/**
+ * Starts the reaper for an emulator the harness just recorded as its own, when
+ * a live run holds the `android` setup lock — and says which it did.
+ *
+ * Never throws: a reaper that cannot be spawned is a lost safety net, not a
+ * reason to fail the launch it would have guarded.
+ *
+ * @param params - The recorded emulator, and where to report.
+ */
+export declare function spawnEmulatorReaper(params: SpawnEmulatorReaperParams): void;

package/dist/lib/cjs/emulator-reclaim.cjs

@@ -0,0 +1,312 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var emulator_reclaim_exports = {};
+__export(emulator_reclaim_exports, {
+  ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS: () => ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS,
+  ADB_DUMPSYS_MAX_BUFFER_IN_BYTES: () => ADB_DUMPSYS_MAX_BUFFER_IN_BYTES,
+  EmulatorReclaimer: () => EmulatorReclaimer,
+  HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS: () => HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS
+});
+module.exports = __toCommonJS(emulator_reclaim_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_process = __toESM(require("node:process"), 1);
+var import_adb_device_list = require("./adb-device-list.cjs");
+var import_emulator_backend = require("./emulator-backend.cjs");
+var import_emulator_marker = require("./emulator-marker.cjs");
+var import_kill_process_tree = require("./kill-process-tree.cjs");
+var import_process_liveness = require("./process-liveness.cjs");
+var import_teardown_verdict = require("./teardown-verdict.cjs");
+const ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5e3;
+const ADB_DUMPSYS_MAX_BUFFER_IN_BYTES = 8388608;
+const HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS = 3e4;
+const EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS = 5e3;
+const EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS = 500;
+const EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS = 2e4;
+const MILLISECONDS_PER_SECOND = 1e3;
+class EmulatorReclaimer {
+  log;
+  /**
+   * Creates a reclaimer that reports under the caller's own log prefix.
+   *
+   * @param log - Receives every progress and verdict line.
+   */
+  constructor(log) {
+    this.log = log;
+  }
+  /**
+   * Runs `adb devices` and returns its raw stdout.
+   *
+   * The raw listing is what teardown needs: `getConnectedDeviceIds` keeps only
+   * the `device` state, and an emulator on its way out answers `offline` while
+   * still holding the AVD — see `adb-device-list.ts`.
+   *
+   * @returns The raw `adb devices` output.
+   * @throws If adb could not be run at all.
+   */
+  getDevicesOutput() {
+    return new Promise((resolve, reject) => {
+      (0, import_node_child_process.execFile)("adb", ["devices"], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {
+        if (error) {
+          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));
+          return;
+        }
+        if (stderr) {
+          this.log(`ADB stderr: ${stderr.trim()}`);
+        }
+        resolve(stdout);
+      });
+    });
+  }
+  /**
+   * Lists every process on the host.
+   *
+   * A host always has processes, so a listing that parses to **zero** rows is a
+   * failed query however it exited, and comes back as `undefined` exactly like
+   * one that did not run — never as an empty list a caller could read as "no
+   * emulator is running".
+   *
+   * @returns The host's processes, or `undefined` when the listing failed.
+   */
+  async queryHostProcesses() {
+    const query = buildHostProcessQuery();
+    const output = await new Promise((resolve) => {
+      (0, import_node_child_process.execFile)(
+        query.command,
+        query.commandArguments,
+        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS },
+        (error, stdout) => {
+          if (error) {
+            this.log(`Warning: could not list host processes (\`${query.command}\`): ${error.message}`);
+          }
+          resolve(error ? "" : stdout);
+        }
+      );
+    });
+    const processes = parseHostProcessList(output);
+    if (processes.length === 0) {
+      this.log(`Warning: \`${query.command}\` listed no processes.`);
+      return void 0;
+    }
+    return processes;
+  }
+  /**
+   * Stops the emulators this harness started that no live run is responsible
+   * for, and drops the markers that no longer describe a running emulator.
+   *
+   * Only ever acts on a **marker-verified** emulator: one whose marker names a
+   * PID that is still a live emulator process. An emulator without a marker —
+   * booted by hand, by CI, or by another tool — is never touched, which keeps
+   * the L46 line: never a `qemu*` sweep.
+   *
+   * Callers must hold the `android` setup lock (L7), which is what makes a
+   * leftover safe to stop: no other Android run can be mid-flight on it.
+   *
+   * @param params - Which AVD to leave alone, and whether this run is ending.
+   */
+  async reclaimLeftoverEmulators(params) {
+    const markers = (0, import_emulator_marker.listEmulatorMarkers)().filter((marker) => marker.avdName !== params.exceptAvdName);
+    if (markers.length === 0) {
+      return;
+    }
+    const processes = await this.queryHostProcesses();
+    if (processes === void 0) {
+      this.log(`Cannot judge ${String(markers.length)} emulator marker(s) without a host process listing; leaving them for a later run.`);
+      return;
+    }
+    const liveEmulatorPids = (0, import_emulator_backend.selectEmulatorBackendPids)({ knownPids: [], processes });
+    for (const marker of markers) {
+      await this.reclaimLeftoverEmulator(marker, liveEmulatorPids, params.scope);
+    }
+  }
+  /**
+   * Stops an emulator this harness owns, and **verifies** it stopped.
+   *
+   * The console shutdown goes first because it is the only path that releases
+   * the AVD's `multiinstance.lock`; a `taskkill` leaves the lock behind, and a
+   * stale lock is what makes the next run fail with `Running multiple emulators
+   * with the same AVD` — a FATAL the emulator writes to its own stdout, where
+   * nobody sees it.
+   *
+   * Works without a launcher handle too: a leftover this run took over has only
+   * its PIDs, which is all the escalation below ever needed. The marker goes
+   * only with a **verified** stop, so an emulator that outlived this attempt
+   * stays convictable by the next one.
+   *
+   * @param params - The emulator process, the device it serves and the PIDs this run owns.
+   */
+  async stopEmulator(params) {
+    if (params.deviceId !== void 0) {
+      await this.killEmulatorConsole(params.deviceId);
+    }
+    if (params.emulatorProcess) {
+      (0, import_kill_process_tree.killProcessTree)(params.emulatorProcess);
+    }
+    const waitParams = {
+      deviceId: params.deviceId,
+      ownedEmulatorPids: params.ownedEmulatorPids,
+      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS
+    };
+    let hasEscalated = false;
+    let isStopped = await this.waitForEmulatorStopped(waitParams);
+    if (!isStopped) {
+      const survivingPids = params.ownedEmulatorPids.filter((pid) => (0, import_process_liveness.checkIsProcessAlive)(pid));
+      if (survivingPids.length > 0) {
+        hasEscalated = true;
+        this.log(
+          `Auto-started emulator outlived its console shutdown and the launcher's process tree; escalating to the emulator PID(s) this run owns: [${survivingPids.join(", ")}].`
+        );
+        for (const pid of survivingPids) {
+          (0, import_kill_process_tree.killProcessTreeByPid)(pid);
+        }
+        isStopped = await this.waitForEmulatorStopped({ ...waitParams, timeoutInMilliseconds: EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS });
+      }
+    }
+    this.log((0, import_teardown_verdict.buildTeardownMessage)({
+      evidence: params.deviceId === void 0 ? `AVD "${params.avdName}"` : `AVD "${params.avdName}" on device ${params.deviceId}`,
+      outcome: (0, import_teardown_verdict.resolveTeardownOutcome)({ hasEscalated, isStopped }),
+      subject: "Auto-started emulator",
+      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS
+    }));
+    if (isStopped) {
+      (0, import_emulator_marker.clearEmulatorMarkerIfStopped)(params.avdName);
+    }
+  }
+  /**
+   * Decides whether the emulator this run started is really gone.
+   *
+   * Two independent proofs, cheapest first: none of the PIDs this run owns is
+   * alive, and the device no longer appears in `adb devices` **in any state** (a
+   * dying emulator answers `offline` while it still holds the AVD).
+   *
+   * @param params - The device and the PIDs this run owns.
+   * @returns `true` when nothing of this run's emulator is left.
+   */
+  async checkIsEmulatorGone(params) {
+    if (params.ownedEmulatorPids.some((pid) => (0, import_process_liveness.checkIsProcessAlive)(pid))) {
+      return false;
+    }
+    if (params.deviceId === void 0) {
+      return true;
+    }
+    try {
+      return !(0, import_adb_device_list.checkIsDeviceListed)({ deviceId: params.deviceId, devicesOutput: await this.getDevicesOutput() });
+    } catch (error) {
+      this.log(`Could not re-check connected devices while stopping the emulator: ${error instanceof Error ? error.message : String(error)}`);
+      return true;
+    }
+  }
+  /**
+   * Asks the emulator to shut itself down over its console.
+   *
+   * Preferred over killing the process outright because it is the path that
+   * releases the AVD's `multiinstance.lock`. Best-effort: a console that does
+   * not answer is reported and the caller falls through to the kill.
+   *
+   * @param deviceId - The emulator's device ID.
+   */
+  killEmulatorConsole(deviceId) {
+    return new Promise((resolve) => {
+      (0, import_node_child_process.execFile)("adb", ["-s", deviceId, "emu", "kill"], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout) => {
+        this.log(
+          error ? `Emulator console shutdown for ${deviceId} did not answer: ${error.message}` : `Emulator console shutdown for ${deviceId}: ${stdout.trim()}`
+        );
+        resolve();
+      });
+    });
+  }
+  /**
+   * Acts on one emulator marker for {@link reclaimLeftoverEmulators}.
+   *
+   * @param marker - The marker to judge.
+   * @param liveEmulatorPids - The emulator processes currently running on the host.
+   * @param scope - Whether an emulator another live harness process owns is spared.
+   */
+  async reclaimLeftoverEmulator(marker, liveEmulatorPids, scope) {
+    const verdict = (0, import_emulator_marker.resolveEmulatorMarkerVerdict)({
+      currentPid: import_node_process.default.pid,
+      isOwnerAlive: (0, import_process_liveness.checkIsProcessAlive)(marker.ownerPid),
+      liveEmulatorPids,
+      marker
+    });
+    if (verdict === "stale-marker") {
+      this.log(`Dropping the emulator marker for AVD "${marker.avdName}": none of its PIDs [${marker.ownedEmulatorPids.join(", ")}] is a running emulator any more.`);
+      (0, import_emulator_marker.clearEmulatorMarker)(marker.avdName);
+      return;
+    }
+    const evidence = describeMarkedEmulator(marker);
+    if (verdict === "in-use-by-live-run" && scope === "preflight") {
+      this.log(`Leaving the emulator for ${evidence} alone: the harness process that owns it (PID ${String(marker.ownerPid)}) is still running.`);
+      return;
+    }
+    const ageInSeconds = Math.round((Date.now() - marker.startedAtInMilliseconds) / MILLISECONDS_PER_SECOND);
+    this.log(
+      `Stopping the emulator for ${evidence}: this harness started it ${String(ageInSeconds)}s ago, and no live run is left to stop it.`
+    );
+    await this.stopEmulator({
+      avdName: marker.avdName,
+      deviceId: marker.deviceId,
+      ownedEmulatorPids: (0, import_emulator_marker.selectLiveMarkedPids)(marker, liveEmulatorPids)
+    });
+  }
+  /**
+   * Polls until this run's emulator is gone, or the budget elapses.
+   *
+   * @param params - The device, the PIDs this run owns, and the budget.
+   * @returns `true` when the emulator disappeared within the budget.
+   */
+  async waitForEmulatorStopped(params) {
+    const deadline = Date.now() + params.timeoutInMilliseconds;
+    while (Date.now() < deadline) {
+      if (await this.checkIsEmulatorGone(params)) {
+        return true;
+      }
+      await new Promise((resolve) => {
+        setTimeout(resolve, EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS);
+      });
+    }
+    return false;
+  }
+}
+function buildHostProcessQuery() {
+  return import_node_process.default.platform === "win32" ? { command: "tasklist", commandArguments: ["/FO", "CSV", "/NH"] } : { command: "ps", commandArguments: ["-eo", "pid=,comm="] };
+}
+function describeMarkedEmulator(marker) {
+  return marker.deviceId === void 0 ? `AVD "${marker.avdName}" (no device: it was still booting when it was recorded)` : `AVD "${marker.avdName}" on device ${marker.deviceId}`;
+}
+function parseHostProcessList(output) {
+  return import_node_process.default.platform === "win32" ? (0, import_emulator_backend.parseWindowsTaskList)(output) : (0, import_emulator_backend.parsePosixProcessList)(output);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS,
+  ADB_DUMPSYS_MAX_BUFFER_IN_BYTES,
+  EmulatorReclaimer,
+  HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/emulator-reclaim.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Stops the emulators this harness started, and **verifies** each stop \u2014 the\n * marker-driven half of emulator ownership (`emulator-marker.ts`, **L56**).\n *\n * It lives apart from `transport-factory.ts` so that a process with no business\n * loading the whole transport stack can still stop an emulator correctly. That\n * process is the emulator reaper (`emulator-reaper.ts`): it runs detached from\n * any test runner, and in this repo's own suites it runs straight from source\n * under Node's type stripping, where a module reading the build-time\n * `OBSIDIAN_METADATA` global \u2014 which the factory's import graph reaches \u2014\n * cannot load at all. So nothing this module imports may reach it either.\n */\n\n/* v8 ignore start -- Integration-time emulator management covered by the Android integration suite, not unit tests. */\n\nimport type { ChildProcess } from 'node:child_process';\n\nimport { execFile } from 'node:child_process';\nimport process from 'node:process';\n\nimport type { ProcessListEntry } from './emulator-backend.cjs';\nimport type { EmulatorMarker } from './emulator-marker.cjs';\n\nimport { checkIsDeviceListed } from './adb-device-list.cjs';\nimport {\n  parsePosixProcessList,\n  parseWindowsTaskList,\n  selectEmulatorBackendPids\n} from './emulator-backend.cjs';\nimport {\n  clearEmulatorMarker,\n  clearEmulatorMarkerIfStopped,\n  listEmulatorMarkers,\n  resolveEmulatorMarkerVerdict,\n  selectLiveMarkedPids\n} from './emulator-marker.cjs';\nimport {\n  killProcessTree,\n  killProcessTreeByPid\n} from './kill-process-tree.cjs';\nimport { checkIsProcessAlive } from './process-liveness.cjs';\nimport {\n  buildTeardownMessage,\n  resolveTeardownOutcome\n} from './teardown-verdict.cjs';\n\n/**\n * Budget for one quick `adb` call \u2014 `adb devices`, a console command.\n */\nexport const ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS = 5000;\n\n/*\n * `dumpsys connectivity` is far larger than the other probes' output, and Node's\n * default 1 MiB `maxBuffer` would fail the call rather than truncate it \u2014 which\n * would read as \"not ready\" forever and burn the whole network budget. A host\n * process listing shares the same ceiling.\n */\nexport const ADB_DUMPSYS_MAX_BUFFER_IN_BYTES = 8_388_608;\n\n/*\n * 30s, not the 10s a `tasklist` costs on an idle host: this query runs in the\n * same post-boot contention window that inflates every `adb` round-trip 25-50x\n * (L45), and the first end-to-end run overran a 10s budget there \u2014 silently\n * disarming the teardown escalation. Sized like `ADB_DUMPSYS_TIMEOUT_IN_MILLISECONDS`,\n * for the same reason.\n */\nexport const HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS = 30_000;\n\nconst EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS = 5000;\nconst EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS = 20_000;\nconst MILLISECONDS_PER_SECOND = 1000;\n\n/**\n * A host command and its arguments.\n */\nexport interface HostCommandQuery {\n  /**\n  The executable to run.\n   */\n  readonly command: string;\n\n  /**\n  The command's arguments.\n   */\n  readonly commandArguments: string[];\n}\n\n/**\n * Parameters for {@link EmulatorReclaimer.reclaimLeftoverEmulators}.\n */\nexport interface ReclaimLeftoverEmulatorsParams {\n  /**\n  An AVD whose leftover is left alone \u2014 the one a preflight is about to adopt instead.\n   */\n  readonly exceptAvdName?: string | undefined;\n\n  /**\n   * `'preflight'` spares an emulator another live harness process still owns.\n   * `'end-of-run'` does not: the caller holds the `android` lock with no run in\n   * flight \u2014 the run's own global teardown, or the emulator reaper after the\n   * run is gone \u2014 so that owner can only be one of the finished run's\n   * processes, which no longer has a turn to stop it.\n   */\n  readonly scope: 'end-of-run' | 'preflight';\n}\n\n/**\n * Parameters for {@link EmulatorReclaimer.stopEmulator}.\n */\nexport interface StopEmulatorParams {\n  /**\n  The AVD name, named in the warning so the leftover is identifiable, and the key of its marker.\n   */\n  readonly avdName: string;\n\n  /**\n   * The device the emulator is serving, shut down over its console and polled\n   * to decide whether it actually stopped. `undefined` when the emulator failed\n   * before any device appeared.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n   * The emulator launcher process this run spawned. `undefined` for a leftover\n   * this run took over, whose launcher belonged to another process.\n   */\n  readonly emulatorProcess?: ChildProcess | undefined;\n\n  /**\n  The emulator PIDs this run owns, escalated to when the console and the launcher's tree kill leave one behind.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\ninterface CheckIsEmulatorGoneParams {\n  /**\n  The device the emulator serves, or `undefined` when none ever appeared \u2014 the PIDs are then the only proof.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n  The emulator PIDs this run owns.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n}\n\ninterface WaitForEmulatorStoppedParams {\n  /**\n  The device the emulator serves, or `undefined` when none ever appeared.\n   */\n  readonly deviceId?: string | undefined;\n\n  /**\n  The emulator PIDs this run owns.\n   */\n  readonly ownedEmulatorPids: readonly number[];\n\n  /**\n  How long to wait for the emulator to disappear, in milliseconds.\n   */\n  readonly timeoutInMilliseconds: number;\n}\n\n/**\n * Finds, stops and verifies the harness's emulators, reporting through the\n * caller's log so each caller keeps its own prefix.\n */\nexport class EmulatorReclaimer {\n  private readonly log: (message: string) => void;\n\n  /**\n   * Creates a reclaimer that reports under the caller's own log prefix.\n   *\n   * @param log - Receives every progress and verdict line.\n   */\n  public constructor(log: (message: string) => void) {\n    this.log = log;\n  }\n\n  /**\n   * Runs `adb devices` and returns its raw stdout.\n   *\n   * The raw listing is what teardown needs: `getConnectedDeviceIds` keeps only\n   * the `device` state, and an emulator on its way out answers `offline` while\n   * still holding the AVD \u2014 see `adb-device-list.ts`.\n   *\n   * @returns The raw `adb devices` output.\n   * @throws If adb could not be run at all.\n   */\n  public getDevicesOutput(): Promise<string> {\n    return new Promise<string>((resolve, reject) => {\n      execFile('adb', ['devices'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout, stderr) => {\n        if (error) {\n          reject(new Error(`Failed to run 'adb devices': ${error.message}. Is ADB installed and in PATH?`));\n          return;\n        }\n        if (stderr) {\n          this.log(`ADB stderr: ${stderr.trim()}`);\n        }\n        resolve(stdout);\n      });\n    });\n  }\n\n  /**\n   * Lists every process on the host.\n   *\n   * A host always has processes, so a listing that parses to **zero** rows is a\n   * failed query however it exited, and comes back as `undefined` exactly like\n   * one that did not run \u2014 never as an empty list a caller could read as \"no\n   * emulator is running\".\n   *\n   * @returns The host's processes, or `undefined` when the listing failed.\n   */\n  public async queryHostProcesses(): Promise<ProcessListEntry[] | undefined> {\n    const query = buildHostProcessQuery();\n    const output = await new Promise<string>((resolve) => {\n      execFile(\n        query.command,\n        query.commandArguments,\n        { maxBuffer: ADB_DUMPSYS_MAX_BUFFER_IN_BYTES, timeout: HOST_PROCESS_QUERY_TIMEOUT_IN_MILLISECONDS },\n        (error, stdout) => {\n          if (error) {\n            this.log(`Warning: could not list host processes (\\`${query.command}\\`): ${error.message}`);\n          }\n          resolve(error ? '' : stdout);\n        }\n      );\n    });\n\n    const processes = parseHostProcessList(output);\n    if (processes.length === 0) {\n      this.log(`Warning: \\`${query.command}\\` listed no processes.`);\n      return undefined;\n    }\n\n    return processes;\n  }\n\n  /**\n   * Stops the emulators this harness started that no live run is responsible\n   * for, and drops the markers that no longer describe a running emulator.\n   *\n   * Only ever acts on a **marker-verified** emulator: one whose marker names a\n   * PID that is still a live emulator process. An emulator without a marker \u2014\n   * booted by hand, by CI, or by another tool \u2014 is never touched, which keeps\n   * the L46 line: never a `qemu*` sweep.\n   *\n   * Callers must hold the `android` setup lock (L7), which is what makes a\n   * leftover safe to stop: no other Android run can be mid-flight on it.\n   *\n   * @param params - Which AVD to leave alone, and whether this run is ending.\n   */\n  public async reclaimLeftoverEmulators(params: ReclaimLeftoverEmulatorsParams): Promise<void> {\n    const markers = listEmulatorMarkers().filter((marker) => marker.avdName !== params.exceptAvdName);\n    if (markers.length === 0) {\n      return;\n    }\n\n    const processes = await this.queryHostProcesses();\n    if (processes === undefined) {\n      // Without a listing every marker would read as stale, and deleting them would leave the leftovers impossible to convict.\n      this.log(`Cannot judge ${String(markers.length)} emulator marker(s) without a host process listing; leaving them for a later run.`);\n      return;\n    }\n\n    const liveEmulatorPids = selectEmulatorBackendPids({ knownPids: [], processes });\n    for (const marker of markers) {\n      await this.reclaimLeftoverEmulator(marker, liveEmulatorPids, params.scope);\n    }\n  }\n\n  /**\n   * Stops an emulator this harness owns, and **verifies** it stopped.\n   *\n   * The console shutdown goes first because it is the only path that releases\n   * the AVD's `multiinstance.lock`; a `taskkill` leaves the lock behind, and a\n   * stale lock is what makes the next run fail with `Running multiple emulators\n   * with the same AVD` \u2014 a FATAL the emulator writes to its own stdout, where\n   * nobody sees it.\n   *\n   * Works without a launcher handle too: a leftover this run took over has only\n   * its PIDs, which is all the escalation below ever needed. The marker goes\n   * only with a **verified** stop, so an emulator that outlived this attempt\n   * stays convictable by the next one.\n   *\n   * @param params - The emulator process, the device it serves and the PIDs this run owns.\n   */\n  public async stopEmulator(params: StopEmulatorParams): Promise<void> {\n    if (params.deviceId !== undefined) {\n      await this.killEmulatorConsole(params.deviceId);\n    }\n    if (params.emulatorProcess) {\n      killProcessTree(params.emulatorProcess);\n    }\n\n    const waitParams: WaitForEmulatorStoppedParams = {\n      deviceId: params.deviceId,\n      ownedEmulatorPids: params.ownedEmulatorPids,\n      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS\n    };\n\n    let hasEscalated = false;\n    let isStopped = await this.waitForEmulatorStopped(waitParams);\n\n    if (!isStopped) {\n      const survivingPids = params.ownedEmulatorPids.filter((pid) => checkIsProcessAlive(pid));\n      if (survivingPids.length > 0) {\n        hasEscalated = true;\n        this.log(\n          `Auto-started emulator outlived its console shutdown and the launcher's process tree; escalating to the emulator PID(s) this run owns: [${survivingPids.join(', ')}].`\n        );\n        for (const pid of survivingPids) {\n          killProcessTreeByPid(pid);\n        }\n        isStopped = await this.waitForEmulatorStopped({ ...waitParams, timeoutInMilliseconds: EMULATOR_ESCALATED_STOP_TIMEOUT_IN_MILLISECONDS });\n      }\n    }\n\n    this.log(buildTeardownMessage({\n      evidence: params.deviceId === undefined ? `AVD \"${params.avdName}\"` : `AVD \"${params.avdName}\" on device ${params.deviceId}`,\n      outcome: resolveTeardownOutcome({ hasEscalated, isStopped }),\n      subject: 'Auto-started emulator',\n      timeoutInMilliseconds: EMULATOR_STOP_TIMEOUT_IN_MILLISECONDS\n    }));\n\n    if (isStopped) {\n      clearEmulatorMarkerIfStopped(params.avdName);\n    }\n  }\n\n  /**\n   * Decides whether the emulator this run started is really gone.\n   *\n   * Two independent proofs, cheapest first: none of the PIDs this run owns is\n   * alive, and the device no longer appears in `adb devices` **in any state** (a\n   * dying emulator answers `offline` while it still holds the AVD).\n   *\n   * @param params - The device and the PIDs this run owns.\n   * @returns `true` when nothing of this run's emulator is left.\n   */\n  private async checkIsEmulatorGone(params: CheckIsEmulatorGoneParams): Promise<boolean> {\n    if (params.ownedEmulatorPids.some((pid) => checkIsProcessAlive(pid))) {\n      return false;\n    }\n\n    if (params.deviceId === undefined) {\n      return true;\n    }\n\n    try {\n      return !checkIsDeviceListed({ deviceId: params.deviceId, devicesOutput: await this.getDevicesOutput() });\n    } catch (error: unknown) {\n      /*\n       * An adb that cannot run is not evidence about the emulator \u2014 and the PID\n       * probe above has already said this run's processes are gone, which is the\n       * stronger of the two proofs.\n       */\n      this.log(`Could not re-check connected devices while stopping the emulator: ${error instanceof Error ? error.message : String(error)}`);\n      return true;\n    }\n  }\n\n  /**\n   * Asks the emulator to shut itself down over its console.\n   *\n   * Preferred over killing the process outright because it is the path that\n   * releases the AVD's `multiinstance.lock`. Best-effort: a console that does\n   * not answer is reported and the caller falls through to the kill.\n   *\n   * @param deviceId - The emulator's device ID.\n   */\n  private killEmulatorConsole(deviceId: string): Promise<void> {\n    return new Promise<void>((resolve) => {\n      execFile('adb', ['-s', deviceId, 'emu', 'kill'], { timeout: ADB_DEVICE_CHECK_TIMEOUT_IN_MILLISECONDS }, (error, stdout) => {\n        this.log(\n          error\n            ? `Emulator console shutdown for ${deviceId} did not answer: ${error.message}`\n            : `Emulator console shutdown for ${deviceId}: ${stdout.trim()}`\n        );\n        resolve();\n      });\n    });\n  }\n\n  /**\n   * Acts on one emulator marker for {@link reclaimLeftoverEmulators}.\n   *\n   * @param marker - The marker to judge.\n   * @param liveEmulatorPids - The emulator processes currently running on the host.\n   * @param scope - Whether an emulator another live harness process owns is spared.\n   */\n  private async reclaimLeftoverEmulator(marker: EmulatorMarker, liveEmulatorPids: readonly number[], scope: ReclaimLeftoverEmulatorsParams['scope']): Promise<void> {\n    const verdict = resolveEmulatorMarkerVerdict({\n      currentPid: process.pid,\n      isOwnerAlive: checkIsProcessAlive(marker.ownerPid),\n      liveEmulatorPids,\n      marker\n    });\n\n    if (verdict === 'stale-marker') {\n      this.log(`Dropping the emulator marker for AVD \"${marker.avdName}\": none of its PIDs [${marker.ownedEmulatorPids.join(', ')}] is a running emulator any more.`);\n      clearEmulatorMarker(marker.avdName);\n      return;\n    }\n\n    /*\n     * A marker written at launch has no device yet: the emulator was still\n     * booting when whatever recorded it stopped looking. The stop below reads\n     * that absence correctly \u2014 no console to shut down, the owned PIDs are the\n     * whole of the evidence \u2014 so it is described rather than papered over.\n     */\n    const evidence = describeMarkedEmulator(marker);\n\n    if (verdict === 'in-use-by-live-run' && scope === 'preflight') {\n      this.log(`Leaving the emulator for ${evidence} alone: the harness process that owns it (PID ${String(marker.ownerPid)}) is still running.`);\n      return;\n    }\n\n    const ageInSeconds = Math.round((Date.now() - marker.startedAtInMilliseconds) / MILLISECONDS_PER_SECOND);\n    this.log(\n      `Stopping the emulator for ${evidence}: this harness started it ${String(ageInSeconds)}s ago, and no live run is left to stop it.`\n    );\n    await this.stopEmulator({\n      avdName: marker.avdName,\n      deviceId: marker.deviceId,\n      ownedEmulatorPids: selectLiveMarkedPids(marker, liveEmulatorPids)\n    });\n  }\n\n  /**\n   * Polls until this run's emulator is gone, or the budget elapses.\n   *\n   * @param params - The device, the PIDs this run owns, and the budget.\n   * @returns `true` when the emulator disappeared within the budget.\n   */\n  private async waitForEmulatorStopped(params: WaitForEmulatorStoppedParams): Promise<boolean> {\n    const deadline = Date.now() + params.timeoutInMilliseconds;\n\n    while (Date.now() < deadline) {\n      if (await this.checkIsEmulatorGone(params)) {\n        return true;\n      }\n\n      await new Promise((resolve) => {\n        setTimeout(resolve, EMULATOR_STOP_POLL_INTERVAL_IN_MILLISECONDS);\n      });\n    }\n\n    return false;\n  }\n}\n\n/**\n * Builds the platform's \"list every process\" query.\n *\n * @returns The command and arguments to run.\n */\nfunction buildHostProcessQuery(): HostCommandQuery {\n  return process.platform === 'win32'\n    ? { command: 'tasklist', commandArguments: ['/FO', 'CSV', '/NH'] }\n    : { command: 'ps', commandArguments: ['-eo', 'pid=,comm='] };\n}\n\n/**\n * Names the emulator a marker describes, for the log.\n *\n * @param marker - The marker.\n * @returns The AVD and its device, or the AVD alone for a launch that had not produced a device yet.\n */\nfunction describeMarkedEmulator(marker: EmulatorMarker): string {\n  return marker.deviceId === undefined\n    ? `AVD \"${marker.avdName}\" (no device: it was still booting when it was recorded)`\n    : `AVD \"${marker.avdName}\" on device ${marker.deviceId}`;\n}\n\n/**\n * Parses a host process listing with the platform's parser.\n *\n * @param output - Raw stdout of {@link buildHostProcessQuery}'s command.\n * @returns The listed processes.\n */\nfunction parseHostProcessList(output: string): ProcessListEntry[] {\n  return process.platform === 'win32' ? parseWindowsTaskList(output) : parsePosixProcessList(output);\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process"]
}
