obsidian-integration-testing 12.1.2 → 12.2.0

package/dist/lib/esm/emulator-reaper.d.mts

@@ -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.mjs';
+/**
+ * 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/esm/emulator-reaper.mjs

@@ -0,0 +1,211 @@
+import { spawn } from "node:child_process";
+import {
+  closeSync,
+  mkdirSync,
+  openSync,
+  statSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+import { readEmulatorMarker } from "./emulator-marker.mjs";
+import { EmulatorReclaimer } from "./emulator-reclaim.mjs";
+import { HARNESS_TEMP_DIR_NAME } from "./leftover-cleanup.mjs";
+import { log } from "./log.mjs";
+import { checkIsProcessAlive } from "./process-liveness.mjs";
+import {
+  ANDROID_SETUP_LOCK_SCOPE,
+  checkIsSetupLockHeld,
+  tryAcquireSetupLock
+} from "./setup-lock.mjs";
+const EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS = 5e3;
+const EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS = 18e5;
+const EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES = 1048576;
+const EMULATOR_REAPER_ENTRY_NAME = "runEmulatorReaper";
+const LOCK_LABEL = "emulator-reaper";
+const REAPER_LOG_FILE_SUFFIX = ".emulator-reaper.log";
+function buildEmulatorReaperArguments(reaperArguments) {
+  return [reaperArguments.avdName, String(reaperArguments.startedAtInMilliseconds)];
+}
+function buildEmulatorReaperBootstrap() {
+  return [
+    "import(process.argv[1]).then((reaperModule) => {",
+    `  const run = reaperModule.${EMULATOR_REAPER_ENTRY_NAME} ?? reaperModule.default.${EMULATOR_REAPER_ENTRY_NAME};`,
+    "  return run(process.argv.slice(2));",
+    "}).catch((error) => {",
+    "  console.error(error);",
+    "  process.exitCode = 1;",
+    "});"
+  ].join("\n");
+}
+function buildEmulatorReaperRelayBootstrap() {
+  return [
+    'const { spawn } = require("node:child_process");',
+    "try {",
+    '  const child = spawn(process.execPath, ["-e", process.argv[1], ...process.argv.slice(2)], {',
+    "    detached: true,",
+    '    stdio: ["ignore", 1, 2],',
+    "    windowsHide: true",
+    "  });",
+    '  child.once("error", (error) => { console.error(error); });',
+    "  child.unref();",
+    "} catch (error) {",
+    "  console.error(error);",
+    "  process.exitCode = 1;",
+    "}"
+  ].join("\n");
+}
+function parseEmulatorReaperArguments(argv) {
+  const [avdName, startedAtText, ...rest] = argv;
+  if (!avdName || startedAtText === void 0 || rest.length > 0) {
+    return void 0;
+  }
+  const startedAtInMilliseconds = Number(startedAtText);
+  if (!Number.isSafeInteger(startedAtInMilliseconds) || startedAtInMilliseconds <= 0) {
+    return void 0;
+  }
+  return { avdName, startedAtInMilliseconds };
+}
+function resolveEmulatorReaperLogOpenFlag(sizeInBytes) {
+  return sizeInBytes !== void 0 && sizeInBytes > EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES ? "w" : "a";
+}
+function resolveEmulatorReaperWatch(params) {
+  const { marker } = params;
+  if (marker === void 0) {
+    return "emulator-stopped";
+  }
+  if (marker.startedAtInMilliseconds !== params.armedStartedAtInMilliseconds) {
+    return "superseded";
+  }
+  if (marker.preLaunchEmulatorPids !== void 0) {
+    return "watch";
+  }
+  return marker.ownedEmulatorPids.some((pid) => params.checkIsPidAlive(pid)) ? "watch" : "emulator-stopped";
+}
+async function runEmulatorReaper(argv) {
+  const reaperArguments = parseEmulatorReaperArguments(argv);
+  if (!reaperArguments) {
+    log(`[emulator-reaper] Refusing to run: expected <avdName> <startedAtInMilliseconds>, got ${JSON.stringify(argv)}.`);
+    process.exitCode = 1;
+    return;
+  }
+  const { avdName, startedAtInMilliseconds } = reaperArguments;
+  reaperLog(
+    `Watching the emulator started at ${new Date(startedAtInMilliseconds).toISOString()} (reaper PID ${String(process.pid)}); it is stopped once no Android run holds the '${ANDROID_SETUP_LOCK_SCOPE}' setup lock.`
+  );
+  for (; ; ) {
+    const verdict = readWatchVerdict(reaperArguments);
+    if (verdict !== "watch") {
+      reaperLog(describeExit(verdict));
+      return;
+    }
+    let lock;
+    try {
+      lock = tryAcquireSetupLock({
+        label: LOCK_LABEL,
+        scope: ANDROID_SETUP_LOCK_SCOPE,
+        staleAfterSilenceInMilliseconds: EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS
+      });
+    } catch (error) {
+      reaperLog(`Giving up: the setup lock could not be read (${error instanceof Error ? error.message : String(error)}). The next Android run reclaims the emulator instead.`);
+      return;
+    }
+    if (lock) {
+      try {
+        const lockedVerdict = readWatchVerdict(reaperArguments);
+        if (lockedVerdict !== "watch") {
+          reaperLog(describeExit(lockedVerdict));
+          return;
+        }
+        reaperLog("No Android run holds the setup lock any more, so nothing is left to stop the emulator. Stopping the leftovers this harness started...");
+        await new EmulatorReclaimer(reaperLog).reclaimLeftoverEmulators({ scope: "end-of-run" });
+      } finally {
+        lock.release();
+      }
+      return;
+    }
+    await new Promise((resolve) => {
+      setTimeout(resolve, EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS);
+    });
+  }
+  function reaperLog(message) {
+    log(`[emulator-reaper:${avdName}] ${message}`);
+  }
+}
+function spawnEmulatorReaper(params) {
+  const { avdName } = params;
+  if (!checkIsSetupLockHeld(ANDROID_SETUP_LOCK_SCOPE)) {
+    params.log(
+      `No emulator reaper armed for AVD "${avdName}": no run holds the '${ANDROID_SETUP_LOCK_SCOPE}' setup lock, so a reaper could not tell this run ending from it being killed. If this process is killed, only the next Android run on this host stops the emulator.`
+    );
+    return;
+  }
+  const logFilePath = join(getReaperLogDirectory(), `${avdName}${REAPER_LOG_FILE_SUFFIX}`);
+  try {
+    mkdirSync(getReaperLogDirectory(), { recursive: true });
+    const logFileDescriptor = openSync(logFilePath, resolveEmulatorReaperLogOpenFlag(readFileSize(logFilePath)));
+    try {
+      const relay = spawn(
+        process.execPath,
+        [
+          "-e",
+          buildEmulatorReaperRelayBootstrap(),
+          buildEmulatorReaperBootstrap(),
+          resolveOwnModuleUrl(),
+          ...buildEmulatorReaperArguments({ avdName, startedAtInMilliseconds: params.startedAtInMilliseconds })
+        ],
+        { detached: true, stdio: ["ignore", logFileDescriptor, logFileDescriptor], windowsHide: true }
+      );
+      relay.once("error", (error) => {
+        params.log(`The emulator reaper relay for AVD "${avdName}" failed to start: ${error.message}`);
+      });
+      relay.unref();
+      params.log(
+        `Emulator reaper armed for AVD "${avdName}": if this run is killed \u2014 a process-tree kill included, since the reaper is started through a relay that exits at once \u2014 it stops the emulator once no Android run holds the '${ANDROID_SETUP_LOCK_SCOPE}' setup lock. Its PID is the first line of its log: ${logFilePath}`
+      );
+    } finally {
+      closeSync(logFileDescriptor);
+    }
+  } catch (error) {
+    params.log(`Could not arm the emulator reaper for AVD "${avdName}": ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+function describeExit(verdict) {
+  return verdict === "superseded" ? "The marker now records a later emulator of this AVD, which has its own reaper; nothing left to watch." : "The emulator was stopped; nothing left to watch.";
+}
+function getReaperLogDirectory() {
+  return join(tmpdir(), HARNESS_TEMP_DIR_NAME);
+}
+function readFileSize(path) {
+  try {
+    return statSync(path).size;
+  } catch {
+    return void 0;
+  }
+}
+function readWatchVerdict(reaperArguments) {
+  return resolveEmulatorReaperWatch({
+    armedStartedAtInMilliseconds: reaperArguments.startedAtInMilliseconds,
+    checkIsPidAlive: checkIsProcessAlive,
+    marker: readEmulatorMarker(reaperArguments.avdName)
+  });
+}
+function resolveOwnModuleUrl() {
+  return typeof __filename === "string" ? pathToFileURL(__filename).href : import.meta.url;
+}
+export {
+  EMULATOR_REAPER_ENTRY_NAME,
+  EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS,
+  EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES,
+  EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS,
+  buildEmulatorReaperArguments,
+  buildEmulatorReaperBootstrap,
+  buildEmulatorReaperRelayBootstrap,
+  parseEmulatorReaperArguments,
+  resolveEmulatorReaperLogOpenFlag,
+  resolveEmulatorReaperWatch,
+  runEmulatorReaper,
+  spawnEmulatorReaper
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/emulator-reaper.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Stops an emulator this harness started once its run is gone for good \u2014 the\n * case nothing else covers, **L56**'s path B with no later run: the runner is\n * killed (SIGKILL, Task Manager, an IDE stop button), no teardown runs, and no\n * other Android run ever comes along to reclaim the leftover from its marker.\n * On 2026-09-10 an emulator left like that kept `netsimd` spinning for six hours.\n *\n * The reaper is a small detached Node process spawned beside every emulator the\n * harness starts or takes over. It holds no handle to the emulator and needs\n * none: the marker (`emulator-marker.ts`) says what to stop, and the verified\n * stop (`emulator-reclaim.ts`) is the one the run's own teardown uses.\n *\n * ## It watches the `android` setup lock, not the process that started it\n *\n * The process that starts the emulator is not always the run. A project with no\n * transport global setup boots it from a **test worker** (**L56** path A), and\n * Vitest ends workers during a perfectly healthy run \u2014 so a reaper tied to its\n * spawner's lifetime (the **L33** liveness socket, the first idea) would stop\n * the emulator mid-run, or race the next worker taking it over. The `android`\n * setup lock (**L7**) is held by the run's main process for the whole run, and\n * its holder being alive is exactly what \"an Android run is in flight\" means.\n *\n * So the reaper polls that lock, and once it can **take** it \u2014 no live run\n * holds it \u2014 it stops the harness's leftovers while holding it, which is the\n * precondition every leftover stop documents: no run can adopt an emulator that\n * is mid-shutdown. That is precisely what the next run's preflight would do,\n * done at the first moment that run could have done it.\n *\n * A dead same-host holder is abandoned at once. A live-PID holder that has gone\n * silent is only abandoned after\n * {@link EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS}, far wider than the\n * two minutes a waiting run steals on: a reaper is always waiting, so at two\n * minutes a live run that blocked its event loop would lose its emulator.\n *\n * ## Fail-open, like the renderer watchdog\n *\n * A reaper is armed only when a live run holds the lock at the moment the\n * emulator is recorded. A run that takes no lock \u2014 a hand-wired\n * `createTransportFromOptions` \u2014 gets none, and says so, rather than a reaper\n * that would read its missing lock as \"the run is over\" and stop an emulator\n * somebody is using. A spawn that fails is logged and never fails the launch.\n *\n * ## How it runs\n *\n * `process.execPath -e <bootstrap> <this module's URL> <avdName> <startedAt>`:\n * the bootstrap `import()`s this very module and calls {@link runEmulatorReaper}.\n * The URL is the built `.mjs` / `.cjs` in a consumer's install, and the `.ts`\n * source in this repo's own suites, which Node's type stripping runs as-is \u2014 so\n * nothing this module imports may reach a module that reads the build-time\n * `OBSIDIAN_METADATA` global. Its stdout/stderr go to a per-AVD log file, capped\n * at {@link EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES}, so the verdict lines the stop\n * prints are on record even though no terminal is left to show them.\n *\n * ## It is started through a relay, so a process-tree kill cannot take it\n *\n * `detached` does not reparent on Windows: a child spawned straight from the run\n * stays in the run's process tree, so the kill shapes that walk that tree take\n * the safety net along with the thing it was guarding \u2014 Task Manager's *End\n * task*, `taskkill /T`, an IDE stop button, a `ParentProcessId` descendant\n * sweep. Measured on 2026-09-11: a reaper died with the run it was watching, and\n * the emulator it would have stopped idled on for ten minutes.\n *\n * So the spawn goes through a relay \u2014 {@link buildEmulatorReaperRelayBootstrap} \u2014\n * which starts the reaper and exits at once. By the time any tree-walker takes\n * its snapshot the relay is gone, so there is no edge from the run to the reaper\n * left to follow. This is the double-fork idiom, and it holds on POSIX for the\n * same reason: once the relay exits, the reaper belongs to `init`.\n */\n\nimport { spawn } from 'node:child_process';\nimport {\n  closeSync,\n  mkdirSync,\n  openSync,\n  statSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\nimport { pathToFileURL } from 'node:url';\n\nimport type { EmulatorMarker } from './emulator-marker.mjs';\nimport type { SetupLock } from './setup-lock.mjs';\n\nimport { readEmulatorMarker } from './emulator-marker.mjs';\nimport { EmulatorReclaimer } from './emulator-reclaim.mjs';\nimport { HARNESS_TEMP_DIR_NAME } from './leftover-cleanup.mjs';\nimport { log } from './log.mjs';\nimport { checkIsProcessAlive } from './process-liveness.mjs';\nimport {\n  ANDROID_SETUP_LOCK_SCOPE,\n  checkIsSetupLockHeld,\n  tryAcquireSetupLock\n} from './setup-lock.mjs';\n\n/**\n * How often the reaper looks at the marker and the lock \u2014 the lock's own\n * heartbeat interval, so a killed run is noticed within one beat.\n */\nexport const EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS = 5000;\n\n/**\n * How long a same-host lock holder whose PID is still alive may stay silent\n * before the reaper treats its run as gone: 30 minutes, the threshold the lock\n * already uses across hosts. Only a recycled PID should ever reach it.\n */\nexport const EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS = 1_800_000;\n\n/**\n * The size past which the reaper log is started afresh rather than appended to.\n */\nexport const EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES = 1_048_576;\n\n/**\n * The export the bootstrap calls. Named here so the bootstrap and the export\n * cannot drift apart.\n */\nexport const EMULATOR_REAPER_ENTRY_NAME = 'runEmulatorReaper';\n\nconst LOCK_LABEL = 'emulator-reaper';\nconst REAPER_LOG_FILE_SUFFIX = '.emulator-reaper.log';\n\n/**\n * What the reaper watches for: the emulator a marker recorded when it was armed.\n */\nexport interface EmulatorReaperArguments {\n  /**\n  The AVD whose marker it watches.\n   */\n  readonly avdName: string;\n\n  /**\n   * When the watched emulator was launched. A takeover keeps it, so it names one\n   * emulator across every run that owns it, and tells a later emulator of the\n   * same AVD apart.\n   */\n  readonly startedAtInMilliseconds: number;\n}\n\n/**\n * What the marker says the reaper should do next.\n *\n * - `emulator-stopped` \u2014 the marker is gone, or none of its PIDs is alive: the\n *   emulator was stopped, so there is nothing left to watch.\n * - `superseded` \u2014 the marker now records a different emulator of the same AVD,\n *   which has its own reaper.\n * - `watch` \u2014 the emulator is still up.\n */\nexport type EmulatorReaperWatchVerdict = 'emulator-stopped' | 'superseded' | 'watch';\n\n/**\n * Parameters for {@link resolveEmulatorReaperWatch}.\n */\nexport interface ResolveEmulatorReaperWatchParams {\n  /**\n  The launch time of the emulator this reaper was armed for.\n   */\n  readonly armedStartedAtInMilliseconds: number;\n\n  /**\n  Whether a PID is still running.\n   */\n  readonly checkIsPidAlive: (pid: number) => boolean;\n\n  /**\n  The AVD's marker as it reads now, if any.\n   */\n  readonly marker: EmulatorMarker | undefined;\n}\n\n/**\n * Parameters for {@link spawnEmulatorReaper}.\n */\nexport interface SpawnEmulatorReaperParams {\n  /**\n  The AVD whose emulator was just recorded.\n   */\n  readonly avdName: string;\n\n  /**\n  Receives the armed / not-armed line.\n   */\n  readonly log: (message: string) => void;\n\n  /**\n  The recorded emulator's launch time, as written into its marker.\n   */\n  readonly startedAtInMilliseconds: number;\n}\n\n/**\n * Encodes the reaper's arguments for its command line.\n *\n * @param reaperArguments - What the reaper watches for.\n * @returns The command-line arguments, in the order {@link parseEmulatorReaperArguments} reads them.\n */\nexport function buildEmulatorReaperArguments(reaperArguments: EmulatorReaperArguments): string[] {\n  return [reaperArguments.avdName, String(reaperArguments.startedAtInMilliseconds)];\n}\n\n/**\n * Builds the script `node -e` runs to start the reaper.\n *\n * It `import()`s the module whose URL is its first argument and hands the rest\n * to {@link runEmulatorReaper}. `import()` rather than `require`, because it\n * loads all three forms the module ships as \u2014 ESM, CJS, and this repo's own\n * `.ts` source under Node's type stripping. A CJS module's named exports are\n * found by Node's static analysis; `default` is the fallback when they are not.\n *\n * @returns The script.\n */\nexport function buildEmulatorReaperBootstrap(): string {\n  return [\n    'import(process.argv[1]).then((reaperModule) => {',\n    `  const run = reaperModule.${EMULATOR_REAPER_ENTRY_NAME} ?? reaperModule.default.${EMULATOR_REAPER_ENTRY_NAME};`,\n    '  return run(process.argv.slice(2));',\n    '}).catch((error) => {',\n    '  console.error(error);',\n    '  process.exitCode = 1;',\n    '});'\n  ].join('\\n');\n}\n\n/**\n * Builds the script `node -e` runs as the **relay**: it starts the reaper and\n * exits at once, so the reaper is left with a dead parent and no tree-walking\n * kill of the run can reach it. See the relay section in this module's header\n * for why that indirection exists at all.\n *\n * Its own arguments are the reaper's whole command line \u2014 the bootstrap script\n * first, then everything that bootstrap reads \u2014 so the relay never has to know\n * what any of them mean. It hands the reaper its own stdout and stderr, which\n * are the capped log file the spawner opened, so the log is unaffected by the\n * extra hop.\n *\n * @returns The script.\n */\nexport function buildEmulatorReaperRelayBootstrap(): string {\n  return [\n    'const { spawn } = require(\"node:child_process\");',\n    'try {',\n    '  const child = spawn(process.execPath, [\"-e\", process.argv[1], ...process.argv.slice(2)], {',\n    '    detached: true,',\n    '    stdio: [\"ignore\", 1, 2],',\n    '    windowsHide: true',\n    '  });',\n    '  child.once(\"error\", (error) => { console.error(error); });',\n    '  child.unref();',\n    '} catch (error) {',\n    '  console.error(error);',\n    '  process.exitCode = 1;',\n    '}'\n  ].join('\\n');\n}\n\n/**\n * Decodes the reaper's command-line arguments.\n *\n * @param argv - The arguments after the module URL.\n * @returns The arguments, or `undefined` when they are not the two {@link buildEmulatorReaperArguments} writes.\n */\nexport function parseEmulatorReaperArguments(argv: readonly string[]): EmulatorReaperArguments | undefined {\n  const [avdName, startedAtText, ...rest] = argv;\n  if (!avdName || startedAtText === undefined || rest.length > 0) {\n    return undefined;\n  }\n\n  const startedAtInMilliseconds = Number(startedAtText);\n  if (!Number.isSafeInteger(startedAtInMilliseconds) || startedAtInMilliseconds <= 0) {\n    return undefined;\n  }\n\n  return { avdName, startedAtInMilliseconds };\n}\n\n/**\n * Decides how the reaper log is opened, so it can never grow without bound.\n *\n * @param sizeInBytes - The log's current size, or `undefined` when there is none.\n * @returns `'a'` to append, or `'w'` to start it afresh once it has passed the cap.\n */\nexport function resolveEmulatorReaperLogOpenFlag(sizeInBytes: number | undefined): 'a' | 'w' {\n  return sizeInBytes !== undefined && sizeInBytes > EMULATOR_REAPER_LOG_MAX_SIZE_IN_BYTES ? 'w' : 'a';\n}\n\n/**\n * Decides what the marker says the reaper should do next.\n *\n * @param params - The marker as it reads now, and the emulator the reaper was armed for.\n * @returns The verdict.\n */\nexport function resolveEmulatorReaperWatch(params: ResolveEmulatorReaperWatchParams): EmulatorReaperWatchVerdict {\n  const { marker } = params;\n  if (marker === undefined) {\n    return 'emulator-stopped';\n  }\n\n  if (marker.startedAtInMilliseconds !== params.armedStartedAtInMilliseconds) {\n    return 'superseded';\n  }\n\n  /*\n   * A launch-time marker's PID list is deliberately incomplete \u2014 it names the\n   * launcher, and the backend it forks is identified by the pre-launch diff,\n   * which costs a host process listing this poll deliberately does not make.\n   * So it is never read as stopped from PIDs alone: the reclaim, which does\n   * make that listing, is what judges it.\n   */\n  if (marker.preLaunchEmulatorPids !== undefined) {\n    return 'watch';\n  }\n\n  return marker.ownedEmulatorPids.some((pid) => params.checkIsPidAlive(pid)) ? 'watch' : 'emulator-stopped';\n}\n\n/* v8 ignore start -- Detached-process glue covered by the Android integration suite, not unit tests. */\n\n/**\n * The reaper process's body: watches the marker and the lock until either the\n * emulator is gone or no run holds the lock, and in the second case stops the\n * harness's leftovers while holding it.\n *\n * Exported for the bootstrap, which is its only caller.\n *\n * @param argv - The reaper's arguments, as {@link buildEmulatorReaperArguments} wrote them.\n */\nexport async function runEmulatorReaper(argv: readonly string[]): Promise<void> {\n  const reaperArguments = parseEmulatorReaperArguments(argv);\n  if (!reaperArguments) {\n    log(`[emulator-reaper] Refusing to run: expected <avdName> <startedAtInMilliseconds>, got ${JSON.stringify(argv)}.`);\n    process.exitCode = 1;\n    return;\n  }\n\n  const { avdName, startedAtInMilliseconds } = reaperArguments;\n  reaperLog(\n    `Watching the emulator started at ${new Date(startedAtInMilliseconds).toISOString()} (reaper PID ${String(process.pid)}); it is stopped once no Android run holds the '${ANDROID_SETUP_LOCK_SCOPE}' setup lock.`\n  );\n\n  for (;;) {\n    const verdict = readWatchVerdict(reaperArguments);\n    if (verdict !== 'watch') {\n      reaperLog(describeExit(verdict));\n      return;\n    }\n\n    let lock: SetupLock | undefined;\n    try {\n      lock = tryAcquireSetupLock({\n        label: LOCK_LABEL,\n        scope: ANDROID_SETUP_LOCK_SCOPE,\n        staleAfterSilenceInMilliseconds: EMULATOR_REAPER_LOCK_SILENCE_IN_MILLISECONDS\n      });\n    } catch (error: unknown) {\n      // Fail open: a lock this process cannot even look at is no evidence the run is over.\n      reaperLog(`Giving up: the setup lock could not be read (${error instanceof Error ? error.message : String(error)}). The next Android run reclaims the emulator instead.`);\n      return;\n    }\n\n    if (lock) {\n      try {\n        // The run may have ended normally between the look above and the lock: its teardown then stopped the emulator.\n        const lockedVerdict = readWatchVerdict(reaperArguments);\n        if (lockedVerdict !== 'watch') {\n          reaperLog(describeExit(lockedVerdict));\n          return;\n        }\n\n        reaperLog('No Android run holds the setup lock any more, so nothing is left to stop the emulator. Stopping the leftovers this harness started...');\n        await new EmulatorReclaimer(reaperLog).reclaimLeftoverEmulators({ scope: 'end-of-run' });\n      } finally {\n        lock.release();\n      }\n      return;\n    }\n\n    await new Promise((resolve) => {\n      setTimeout(resolve, EMULATOR_REAPER_POLL_INTERVAL_IN_MILLISECONDS);\n    });\n  }\n\n  function reaperLog(message: string): void {\n    log(`[emulator-reaper:${avdName}] ${message}`);\n  }\n}\n\n/**\n * Starts the reaper for an emulator the harness just recorded as its own, when\n * a live run holds the `android` setup lock \u2014 and says which it did.\n *\n * Never throws: a reaper that cannot be spawned is a lost safety net, not a\n * reason to fail the launch it would have guarded.\n *\n * @param params - The recorded emulator, and where to report.\n */\nexport function spawnEmulatorReaper(params: SpawnEmulatorReaperParams): void {\n  const { avdName } = params;\n  if (!checkIsSetupLockHeld(ANDROID_SETUP_LOCK_SCOPE)) {\n    params.log(\n      `No emulator reaper armed for AVD \"${avdName}\": no run holds the '${ANDROID_SETUP_LOCK_SCOPE}' setup lock, so a reaper could not tell this run ending from it being killed. If this process is killed, only the next Android run on this host stops the emulator.`\n    );\n    return;\n  }\n\n  const logFilePath = join(getReaperLogDirectory(), `${avdName}${REAPER_LOG_FILE_SUFFIX}`);\n  try {\n    mkdirSync(getReaperLogDirectory(), { recursive: true });\n    const logFileDescriptor = openSync(logFilePath, resolveEmulatorReaperLogOpenFlag(readFileSize(logFilePath)));\n    try {\n      /*\n       * Through the relay, never straight at the reaper: a reaper spawned here\n       * would be a child of this run and would die with it under any kill that\n       * walks the process tree. The relay exits at once, leaving the reaper with\n       * a dead parent and no edge back to this run.\n       */\n      const relay = spawn(\n        process.execPath,\n        [\n          '-e',\n          buildEmulatorReaperRelayBootstrap(),\n          buildEmulatorReaperBootstrap(),\n          resolveOwnModuleUrl(),\n          ...buildEmulatorReaperArguments({ avdName, startedAtInMilliseconds: params.startedAtInMilliseconds })\n        ],\n        { detached: true, stdio: ['ignore', logFileDescriptor, logFileDescriptor], windowsHide: true }\n      );\n      relay.once('error', (error) => {\n        params.log(`The emulator reaper relay for AVD \"${avdName}\" failed to start: ${error.message}`);\n      });\n      relay.unref();\n      params.log(\n        `Emulator reaper armed for AVD \"${avdName}\": if this run is killed \u2014 a process-tree kill included, since the reaper is started through a relay that exits at once \u2014 it stops the emulator once no Android run holds the '${ANDROID_SETUP_LOCK_SCOPE}' setup lock. Its PID is the first line of its log: ${logFilePath}`\n      );\n    } finally {\n      closeSync(logFileDescriptor);\n    }\n  } catch (error: unknown) {\n    params.log(`Could not arm the emulator reaper for AVD \"${avdName}\": ${error instanceof Error ? error.message : String(error)}`);\n  }\n}\n\nfunction describeExit(verdict: Exclude<EmulatorReaperWatchVerdict, 'watch'>): string {\n  return verdict === 'superseded'\n    ? 'The marker now records a later emulator of this AVD, which has its own reaper; nothing left to watch.'\n    : 'The emulator was stopped; nothing left to watch.';\n}\n\nfunction getReaperLogDirectory(): string {\n  return join(tmpdir(), HARNESS_TEMP_DIR_NAME);\n}\n\nfunction readFileSize(path: string): number | undefined {\n  try {\n    return statSync(path).size;\n  } catch {\n    return undefined;\n  }\n}\n\nfunction readWatchVerdict(reaperArguments: EmulatorReaperArguments): EmulatorReaperWatchVerdict {\n  return resolveEmulatorReaperWatch({\n    armedStartedAtInMilliseconds: reaperArguments.startedAtInMilliseconds,\n    checkIsPidAlive: checkIsProcessAlive,\n    marker: readEmulatorMarker(reaperArguments.avdName)\n  });\n}\n\n/**\n * Finds this module's own URL \u2014 the one the bootstrap imports.\n *\n * The CJS build has no `import.meta` (esbuild empties it), but it has\n * `__filename`; the ESM build and the `.ts` source have `import.meta.url`.\n *\n * @returns The URL of this module as it is running.\n */\nfunction resolveOwnModuleUrl(): string {\n  return typeof __filename === 'string' ? pathToFileURL(__filename).href : import.meta.url;\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}
