obsidian-integration-testing 11.0.0 → 12.1.0

package/dist/lib/cjs/appium-server-marker.d.cts

@@ -0,0 +1,103 @@
+/**
+ * @file
+ *
+ * Records which Appium server on a port this harness started, so a later run
+ * that finds a server already listening can tell **provenance**: one of our own
+ * servers left over from an earlier run, or a foreign one the user manages.
+ *
+ * The preflight adopts any server that answers `/status`, and adoption is the
+ * right default — starting a second server on an occupied port cannot work. But
+ * adopting silently means a wedged leftover (see `wedged-appium-server.ts`) is
+ * indistinguishable from a healthy server, and the harness has no basis on which
+ * to decide whether restarting it is its call to make. The marker supplies that
+ * basis: a server we started may be restarted, a foreign one is only ever
+ * reported.
+ *
+ * The marker is a small JSON sentinel next to the setup lock (`setup-lock.ts`),
+ * keyed by port, and is deliberately tolerant — a missing, unreadable, or
+ * mismatched marker simply reads as "not ours".
+ */
+/**
+ * Identifies the Appium server this harness started on a port.
+ */
+export interface AppiumServerMarker {
+    /**
+    PID of the spawned server process (the shell wrapper that owns the server's process tree).
+     */
+    readonly pid: number;
+    /**
+    The port the server was started on.
+     */
+    readonly port: number;
+    /**
+    When the server was started (`Date.now()` epoch milliseconds).
+     */
+    readonly startedAtInMilliseconds: number;
+    /**
+     * When a run tried to stop this server and could not verify it exited
+     * (`Date.now()` epoch milliseconds), or `undefined` when no stop has failed.
+     *
+     * Its presence means the server is a **known-doomed leftover**: it was ours,
+     * we asked it to die, and it did not. See {@link recordAppiumServerStopAttempt}.
+     */
+    readonly stopAttemptedAtInMilliseconds?: number | undefined;
+}
+/**
+ * Parameters for {@link writeAppiumServerMarker}.
+ */
+export interface WriteAppiumServerMarkerParams {
+    /**
+    PID of the spawned server process.
+     */
+    readonly pid: number;
+    /**
+    The port the server was started on.
+     */
+    readonly port: number;
+}
+/**
+ * Checks whether the marked server is still running, which is what makes an
+ * adopted server ours to restart.
+ *
+ * A dead PID means the marker outlived its server, so whatever answers on that
+ * port now is somebody else's — the marker proves nothing about it.
+ *
+ * @param marker - The marker read for the port, or `undefined` when there is none.
+ * @returns `true` when an earlier run of this harness started the server now listening.
+ */
+export declare function checkIsHarnessOwnedAppiumServer(marker: AppiumServerMarker | undefined): boolean;
+/**
+ * Removes the marker for a port. Called once the marked server has been stopped,
+ * so a later run does not mistake a recycled PID for our server.
+ *
+ * @param port - The Appium server port.
+ */
+export declare function clearAppiumServerMarker(port: number): void;
+/**
+ * Reads the marker for a port.
+ *
+ * @param port - The Appium server port.
+ * @returns The marker, or `undefined` when there is none, it is unreadable, or it does not describe this port.
+ */
+export declare function readAppiumServerMarker(port: number): AppiumServerMarker | undefined;
+/**
+ * Records that a run tried to stop the marked server and could not verify it
+ * exited — **instead of** clearing the marker.
+ *
+ * Clearing it would be the worst of both worlds: the leftover keeps serving, and
+ * the next run reads it as a foreign, user-managed server it must never touch
+ * (`checkIsHarnessOwnedAppiumServer` needs the marker to convict it). Keeping
+ * the marker, stamped, says exactly what is true — this is ours, and it outlived
+ * our teardown — which is what lets the next run refuse to adopt it and replace
+ * it instead.
+ *
+ * @param port - The Appium server port.
+ */
+export declare function recordAppiumServerStopAttempt(port: number): void;
+/**
+ * Records the server this run just started, stamping it with the current time so
+ * a later run can report how long it has been up.
+ *
+ * @param params - The started server's PID and port.
+ */
+export declare function writeAppiumServerMarker(params: WriteAppiumServerMarkerParams): void;

package/dist/lib/cjs/avd-probe-verdict.cjs

@@ -0,0 +1,90 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var avd_probe_verdict_exports = {};
+__export(avd_probe_verdict_exports, {
+  buildAvdProbeSummary: () => buildAvdProbeSummary,
+  buildUnreadableDevicesMessage: () => buildUnreadableDevicesMessage,
+  checkIsEmulatorDeviceId: () => checkIsEmulatorDeviceId,
+  classifyAvdProbe: () => classifyAvdProbe,
+  resolveAvdProbeVerdict: () => resolveAvdProbeVerdict
+});
+module.exports = __toCommonJS(avd_probe_verdict_exports);
+var import_type_guards = require("./type-guards.cjs");
+const EMULATOR_DEVICE_ID_PATTERN = /^emulator-\d+$/;
+function buildAvdProbeSummary(results) {
+  if (results.length === 0) {
+    return "no devices";
+  }
+  return results.map((result) => `${result.deviceId}=${result.outcome}`).join(", ");
+}
+function buildUnreadableDevicesMessage(params) {
+  const deviceList = params.unreadableDeviceIds.join(", ");
+  const isSingle = params.unreadableDeviceIds.length === 1;
+  const subject = isSingle ? `device ${deviceList}` : `devices ${deviceList}`;
+  const command = isSingle ? `adb -s ${deviceList} emu avd name` : "adb -s <device> emu avd name";
+  const holder = isSingle ? "it is" : "one of them is";
+  const remedy = isSingle ? "Kill the unresponsive device" : "Kill the unresponsive devices";
+  return `AVD "${params.avdName}": ${subject} did not answer \`${command}\` within ${String(params.probeTimeoutInMilliseconds)}ms (retried once), so this run cannot tell whether ${holder} already serving that AVD. Starting an emulator anyway would collide (\`FATAL | Running multiple emulators with the same AVD is an experimental feature\`), which the emulator reports only to its own stdout. ${remedy}, or run \`adb kill-server\`, then retry.`;
+}
+function checkIsEmulatorDeviceId(deviceId) {
+  return EMULATOR_DEVICE_ID_PATTERN.test(deviceId);
+}
+function classifyAvdProbe(params) {
+  if (!checkIsEmulatorDeviceId(params.deviceId)) {
+    return "not-an-emulator";
+  }
+  if (params.probedAvdName === void 0 || params.probedAvdName.length === 0) {
+    return "no-answer";
+  }
+  return params.probedAvdName === params.avdName ? "match" : "other-avd";
+}
+function resolveAvdProbeVerdict(results) {
+  const unreadableDeviceIds = [];
+  for (const result of results) {
+    switch (result.outcome) {
+      case "match": {
+        return { deviceId: result.deviceId, verdict: "reuse" };
+      }
+      case "no-answer": {
+        unreadableDeviceIds.push(result.deviceId);
+        break;
+      }
+      case "not-an-emulator":
+      case "other-avd": {
+        break;
+      }
+      default: {
+        return (0, import_type_guards.assertNever)(result.outcome);
+      }
+    }
+  }
+  if (unreadableDeviceIds.length > 0) {
+    return { unreadableDeviceIds, verdict: "refuse" };
+  }
+  return { verdict: "start-new" };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildAvdProbeSummary,
+  buildUnreadableDevicesMessage,
+  checkIsEmulatorDeviceId,
+  classifyAvdProbe,
+  resolveAvdProbeVerdict
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/avd-probe-verdict.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure classification of the AVD adoption probe \u2014 deciding, from what each\n * connected device answered, whether this run may reuse one, must start its\n * own emulator, or cannot safely do either.\n *\n * The probe (`adb -s <device> emu avd name`) used to discard its error and\n * resolve `''`, so a call that **never answered** was indistinguishable from one\n * that answered *\"a different AVD\"*. Both fell through to \"start a new\n * emulator\", which collides with the emulator already serving that AVD:\n *\n * ```text\n * 14:27:52.114  Checking existing devices for AVD \"obsidian_test\"... (connected: [emulator-5554])\n * 14:27:57.170  AVD \"obsidian_test\" not found on any existing device, starting a new emulator...\n * ```\n *\n * 5.056s apart \u2014 exactly the probe's own timeout. The launch that followed hit\n * `FATAL | Running multiple emulators with the same AVD is an experimental\n * feature`, which the emulator writes to its own stdout. **A probe that never\n * answered is not evidence that the answer is no** \u2014 the same distinction\n * `adb-device-list.ts` draws between `offline` and absent, and the same one\n * the connectivity probe draws between a failed dump and a missing network.\n *\n * Worse, the probe is asked its question precisely when the guest is least able\n * to answer it \u2014 a wedged emulator times out every `adb` call \u2014 which is the\n * condition under which a colliding launch does the most damage.\n *\n * Kept separate from the integration-only `transport-factory` (excluded from\n * unit tests) so the classification stays unit-testable \u2014 the factory itself\n * shells out to `adb`.\n */\n\nimport { assertNever } from './type-guards.cjs';\n\n/**\n * What one device answered when asked which AVD it is serving.\n *\n * `not-an-emulator` and `other-avd` are both legitimate skips; only\n * `no-answer` is the silence that must never be read as one.\n */\nexport type AvdProbeOutcome = 'match' | 'no-answer' | 'not-an-emulator' | 'other-avd';\n\n/**\n * The run cannot tell whether the AVD is already running, so it must not launch.\n */\nexport interface AvdProbeRefuseVerdict {\n  /**\n  The devices that could not be read, and therefore cannot be ruled out as the AVD's holder.\n   */\n  readonly unreadableDeviceIds: string[];\n\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'refuse';\n}\n\n/**\n * One device's probe outcome.\n */\nexport interface AvdProbeResult {\n  /**\n  The device UDID, e.g. `emulator-5554`.\n   */\n  readonly deviceId: string;\n\n  /**\n  What the device answered.\n   */\n  readonly outcome: AvdProbeOutcome;\n}\n\n/**\n * The AVD is already running, on a device this run may adopt.\n */\nexport interface AvdProbeReuseVerdict {\n  /**\n  The device already serving the requested AVD.\n   */\n  readonly deviceId: string;\n\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'reuse';\n}\n\n/**\n * Every device answered, none is serving the AVD, so launching cannot collide.\n */\nexport interface AvdProbeStartNewVerdict {\n  /**\n  Discriminant.\n   */\n  readonly verdict: 'start-new';\n}\n\n/**\n * What the run may do, given every device's probe outcome.\n */\nexport type AvdProbeVerdict = AvdProbeRefuseVerdict | AvdProbeReuseVerdict | AvdProbeStartNewVerdict;\n\n/**\n * Parameters for {@link buildUnreadableDevicesMessage}.\n */\nexport interface BuildUnreadableDevicesMessageParams {\n  /**\n  The AVD the run wanted.\n   */\n  readonly avdName: string;\n\n  /**\n  The budget each probe attempt was given, in milliseconds.\n   */\n  readonly probeTimeoutInMilliseconds: number;\n\n  /**\n  The devices that did not answer.\n   */\n  readonly unreadableDeviceIds: readonly string[];\n}\n\n/**\n * Parameters for {@link classifyAvdProbe}.\n */\nexport interface ClassifyAvdProbeParams {\n  /**\n  The AVD the run wants.\n   */\n  readonly avdName: string;\n\n  /**\n  The device that was probed.\n   */\n  readonly deviceId: string;\n\n  /**\n  The AVD name the device answered, or `undefined` when it did not answer at all.\n   */\n  readonly probedAvdName?: string | undefined;\n}\n\n/**\n * Matches the device IDs adb gives emulators started the way this harness\n * starts them: `emulator -avd <name>`, whose console lands on a local port.\n *\n * Only such a device can collide with this run's launch, so only such a device's\n * silence is worth refusing over. A physical handset (an arbitrary serial) or a\n * TCP-attached device answers `adb \u2026 emu avd name` with an error however healthy\n * it is; reading that as \"did not answer\" would block every run on a host with a\n * phone plugged in, which is a worse defect than the one this module fixes.\n */\nconst EMULATOR_DEVICE_ID_PATTERN = /^emulator-\\d+$/;\n\n/**\n * Builds the summary line naming what each device answered.\n *\n * The old log printed only the conclusion (`not found on any existing device`),\n * which is exactly the line that was wrong; printing the evidence next to it is\n * what makes a bad conclusion visible without a second run.\n *\n * @param results - Every device's probe outcome.\n * @returns The summary, or `no devices` when nothing was connected.\n */\nexport function buildAvdProbeSummary(results: readonly AvdProbeResult[]): string {\n  if (results.length === 0) {\n    return 'no devices';\n  }\n\n  return results.map((result) => `${result.deviceId}=${result.outcome}`).join(', ');\n}\n\n/**\n * Builds the refusal message for devices that could not be read.\n *\n * Names the device, the AVD, the budget, the consequence and the recovery \u2014 the\n * shape `teardown-verdict.ts` uses for its own warning, because a message that\n * stops a run has to leave the reader able to unblock it.\n *\n * @param params - The AVD, the probe budget, and the devices that did not answer.\n * @returns The refusal message.\n */\nexport function buildUnreadableDevicesMessage(params: BuildUnreadableDevicesMessageParams): string {\n  /*\n   * When there is exactly one device the joined list IS its ID, so the singular\n   * wording needs no index access \u2014 and no unreachable fallback for one.\n   */\n  const deviceList = params.unreadableDeviceIds.join(', ');\n  const isSingle = params.unreadableDeviceIds.length === 1;\n\n  const subject = isSingle ? `device ${deviceList}` : `devices ${deviceList}`;\n  const command = isSingle ? `adb -s ${deviceList} emu avd name` : 'adb -s <device> emu avd name';\n  const holder = isSingle ? 'it is' : 'one of them is';\n  const remedy = isSingle ? 'Kill the unresponsive device' : 'Kill the unresponsive devices';\n\n  return `AVD \"${params.avdName}\": ${subject} did not answer \\`${command}\\` within ${String(params.probeTimeoutInMilliseconds)}ms (retried once), `\n    + `so this run cannot tell whether ${holder} already serving that AVD. Starting an emulator anyway would collide `\n    + '(`FATAL | Running multiple emulators with the same AVD is an experimental feature`), which the emulator reports only to its own stdout. '\n    + `${remedy}, or run \\`adb kill-server\\`, then retry.`;\n}\n\n/**\n * Decides whether a device can hold an AVD this run could collide with.\n *\n * @param deviceId - The device UDID to judge.\n * @returns `true` for a locally started emulator, whose console this run can ask.\n */\nexport function checkIsEmulatorDeviceId(deviceId: string): boolean {\n  return EMULATOR_DEVICE_ID_PATTERN.test(deviceId);\n}\n\n/**\n * Classifies one device's probe.\n *\n * @param params - The AVD wanted, the device probed, and what it answered.\n * @returns The outcome.\n */\nexport function classifyAvdProbe(params: ClassifyAvdProbeParams): AvdProbeOutcome {\n  if (!checkIsEmulatorDeviceId(params.deviceId)) {\n    return 'not-an-emulator';\n  }\n\n  if (params.probedAvdName === undefined || params.probedAvdName.length === 0) {\n    return 'no-answer';\n  }\n\n  return params.probedAvdName === params.avdName ? 'match' : 'other-avd';\n}\n\n/**\n * Decides what the run may do, from every device's probe outcome.\n *\n * **A match wins over an unreadable sibling.** Once the requested AVD is found\n * and reusable, an unrelated wedged device is somebody else's problem and must\n * not block a run that has everything it needs \u2014 the same restraint\n * `emulator-backend.ts` shows in never sweeping a `qemu*` it does not own. Only\n * when nothing matched does silence become decisive, because only then would the\n * run go on to launch.\n *\n * @param results - Every device's probe outcome.\n * @returns The verdict.\n */\nexport function resolveAvdProbeVerdict(results: readonly AvdProbeResult[]): AvdProbeVerdict {\n  const unreadableDeviceIds: string[] = [];\n\n  for (const result of results) {\n    switch (result.outcome) {\n      case 'match': {\n        return { deviceId: result.deviceId, verdict: 'reuse' };\n      }\n      case 'no-answer': {\n        unreadableDeviceIds.push(result.deviceId);\n        break;\n      }\n      case 'not-an-emulator':\n      case 'other-avd': {\n        break;\n      }\n      default: {\n        return assertNever(result.outcome);\n      }\n    }\n  }\n\n  if (unreadableDeviceIds.length > 0) {\n    return { unreadableDeviceIds, verdict: 'refuse' };\n  }\n\n  return { verdict: 'start-new' };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAiCA,yBAA4B;AAwH5B,MAAM,6BAA6B;AAY5B,SAAS,qBAAqB,SAA4C;AAC/E,MAAI,QAAQ,WAAW,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,SAAO,QAAQ,IAAI,CAAC,WAAW,GAAG,OAAO,QAAQ,IAAI,OAAO,OAAO,EAAE,EAAE,KAAK,IAAI;AAClF;AAYO,SAAS,8BAA8B,QAAqD;AAKjG,QAAM,aAAa,OAAO,oBAAoB,KAAK,IAAI;AACvD,QAAM,WAAW,OAAO,oBAAoB,WAAW;AAEvD,QAAM,UAAU,WAAW,UAAU,UAAU,KAAK,WAAW,UAAU;AACzE,QAAM,UAAU,WAAW,UAAU,UAAU,kBAAkB;AACjE,QAAM,SAAS,WAAW,UAAU;AACpC,QAAM,SAAS,WAAW,iCAAiC;AAE3D,SAAO,QAAQ,OAAO,OAAO,MAAM,OAAO,qBAAqB,OAAO,aAAa,OAAO,OAAO,0BAA0B,CAAC,sDACrF,MAAM,kNAEtC,MAAM;AACf;AAQO,SAAS,wBAAwB,UAA2B;AACjE,SAAO,2BAA2B,KAAK,QAAQ;AACjD;AAQO,SAAS,iBAAiB,QAAiD;AAChF,MAAI,CAAC,wBAAwB,OAAO,QAAQ,GAAG;AAC7C,WAAO;AAAA,EACT;AAEA,MAAI,OAAO,kBAAkB,UAAa,OAAO,cAAc,WAAW,GAAG;AAC3E,WAAO;AAAA,EACT;AAEA,SAAO,OAAO,kBAAkB,OAAO,UAAU,UAAU;AAC7D;AAeO,SAAS,uBAAuB,SAAqD;AAC1F,QAAM,sBAAgC,CAAC;AAEvC,aAAW,UAAU,SAAS;AAC5B,YAAQ,OAAO,SAAS;AAAA,MACtB,KAAK,SAAS;AACZ,eAAO,EAAE,UAAU,OAAO,UAAU,SAAS,QAAQ;AAAA,MACvD;AAAA,MACA,KAAK,aAAa;AAChB,4BAAoB,KAAK,OAAO,QAAQ;AACxC;AAAA,MACF;AAAA,MACA,KAAK;AAAA,MACL,KAAK,aAAa;AAChB;AAAA,MACF;AAAA,MACA,SAAS;AACP,mBAAO,gCAAY,OAAO,OAAO;AAAA,MACnC;AAAA,IACF;AAAA,EACF;AAEA,MAAI,oBAAoB,SAAS,GAAG;AAClC,WAAO,EAAE,qBAAqB,SAAS,SAAS;AAAA,EAClD;AAEA,SAAO,EAAE,SAAS,YAAY;AAChC;",
  "names": []
}


package/dist/lib/cjs/avd-probe-verdict.d.cts

@@ -0,0 +1,175 @@
+/**
+ * @file
+ *
+ * Pure classification of the AVD adoption probe — deciding, from what each
+ * connected device answered, whether this run may reuse one, must start its
+ * own emulator, or cannot safely do either.
+ *
+ * The probe (`adb -s <device> emu avd name`) used to discard its error and
+ * resolve `''`, so a call that **never answered** was indistinguishable from one
+ * that answered *"a different AVD"*. Both fell through to "start a new
+ * emulator", which collides with the emulator already serving that AVD:
+ *
+ * ```text
+ * 14:27:52.114  Checking existing devices for AVD "obsidian_test"... (connected: [emulator-5554])
+ * 14:27:57.170  AVD "obsidian_test" not found on any existing device, starting a new emulator...
+ * ```
+ *
+ * 5.056s apart — exactly the probe's own timeout. The launch that followed hit
+ * `FATAL | Running multiple emulators with the same AVD is an experimental
+ * feature`, which the emulator writes to its own stdout. **A probe that never
+ * answered is not evidence that the answer is no** — the same distinction
+ * `adb-device-list.ts` draws between `offline` and absent, and the same one
+ * the connectivity probe draws between a failed dump and a missing network.
+ *
+ * Worse, the probe is asked its question precisely when the guest is least able
+ * to answer it — a wedged emulator times out every `adb` call — which is the
+ * condition under which a colliding launch does the most damage.
+ *
+ * Kept separate from the integration-only `transport-factory` (excluded from
+ * unit tests) so the classification stays unit-testable — the factory itself
+ * shells out to `adb`.
+ */
+/**
+ * What one device answered when asked which AVD it is serving.
+ *
+ * `not-an-emulator` and `other-avd` are both legitimate skips; only
+ * `no-answer` is the silence that must never be read as one.
+ */
+export type AvdProbeOutcome = 'match' | 'no-answer' | 'not-an-emulator' | 'other-avd';
+/**
+ * The run cannot tell whether the AVD is already running, so it must not launch.
+ */
+export interface AvdProbeRefuseVerdict {
+    /**
+    The devices that could not be read, and therefore cannot be ruled out as the AVD's holder.
+     */
+    readonly unreadableDeviceIds: string[];
+    /**
+    Discriminant.
+     */
+    readonly verdict: 'refuse';
+}
+/**
+ * One device's probe outcome.
+ */
+export interface AvdProbeResult {
+    /**
+    The device UDID, e.g. `emulator-5554`.
+     */
+    readonly deviceId: string;
+    /**
+    What the device answered.
+     */
+    readonly outcome: AvdProbeOutcome;
+}
+/**
+ * The AVD is already running, on a device this run may adopt.
+ */
+export interface AvdProbeReuseVerdict {
+    /**
+    The device already serving the requested AVD.
+     */
+    readonly deviceId: string;
+    /**
+    Discriminant.
+     */
+    readonly verdict: 'reuse';
+}
+/**
+ * Every device answered, none is serving the AVD, so launching cannot collide.
+ */
+export interface AvdProbeStartNewVerdict {
+    /**
+    Discriminant.
+     */
+    readonly verdict: 'start-new';
+}
+/**
+ * What the run may do, given every device's probe outcome.
+ */
+export type AvdProbeVerdict = AvdProbeRefuseVerdict | AvdProbeReuseVerdict | AvdProbeStartNewVerdict;
+/**
+ * Parameters for {@link buildUnreadableDevicesMessage}.
+ */
+export interface BuildUnreadableDevicesMessageParams {
+    /**
+    The AVD the run wanted.
+     */
+    readonly avdName: string;
+    /**
+    The budget each probe attempt was given, in milliseconds.
+     */
+    readonly probeTimeoutInMilliseconds: number;
+    /**
+    The devices that did not answer.
+     */
+    readonly unreadableDeviceIds: readonly string[];
+}
+/**
+ * Parameters for {@link classifyAvdProbe}.
+ */
+export interface ClassifyAvdProbeParams {
+    /**
+    The AVD the run wants.
+     */
+    readonly avdName: string;
+    /**
+    The device that was probed.
+     */
+    readonly deviceId: string;
+    /**
+    The AVD name the device answered, or `undefined` when it did not answer at all.
+     */
+    readonly probedAvdName?: string | undefined;
+}
+/**
+ * Builds the summary line naming what each device answered.
+ *
+ * The old log printed only the conclusion (`not found on any existing device`),
+ * which is exactly the line that was wrong; printing the evidence next to it is
+ * what makes a bad conclusion visible without a second run.
+ *
+ * @param results - Every device's probe outcome.
+ * @returns The summary, or `no devices` when nothing was connected.
+ */
+export declare function buildAvdProbeSummary(results: readonly AvdProbeResult[]): string;
+/**
+ * Builds the refusal message for devices that could not be read.
+ *
+ * Names the device, the AVD, the budget, the consequence and the recovery — the
+ * shape `teardown-verdict.ts` uses for its own warning, because a message that
+ * stops a run has to leave the reader able to unblock it.
+ *
+ * @param params - The AVD, the probe budget, and the devices that did not answer.
+ * @returns The refusal message.
+ */
+export declare function buildUnreadableDevicesMessage(params: BuildUnreadableDevicesMessageParams): string;
+/**
+ * Decides whether a device can hold an AVD this run could collide with.
+ *
+ * @param deviceId - The device UDID to judge.
+ * @returns `true` for a locally started emulator, whose console this run can ask.
+ */
+export declare function checkIsEmulatorDeviceId(deviceId: string): boolean;
+/**
+ * Classifies one device's probe.
+ *
+ * @param params - The AVD wanted, the device probed, and what it answered.
+ * @returns The outcome.
+ */
+export declare function classifyAvdProbe(params: ClassifyAvdProbeParams): AvdProbeOutcome;
+/**
+ * Decides what the run may do, from every device's probe outcome.
+ *
+ * **A match wins over an unreadable sibling.** Once the requested AVD is found
+ * and reusable, an unrelated wedged device is somebody else's problem and must
+ * not block a run that has everything it needs — the same restraint
+ * `emulator-backend.ts` shows in never sweeping a `qemu*` it does not own. Only
+ * when nothing matched does silence become decisive, because only then would the
+ * run go on to launch.
+ *
+ * @param results - Every device's probe outcome.
+ * @returns The verdict.
+ */
+export declare function resolveAvdProbeVerdict(results: readonly AvdProbeResult[]): AvdProbeVerdict;

package/dist/lib/cjs/cli.cjs

@@ -31,10 +31,113 @@ __export(cli_exports, {
   main: () => main
 });
 module.exports = __toCommonJS(cli_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
 var import_node_process = __toESM(require("node:process"), 1);
 var import_node_util = require("node:util");
 var import_connect_to_cdp = require("./connect-to-cdp.cjs");
+var import_demo_vault_bootstrap = require("./demo-vault-bootstrap.cjs");
+const BOOTSTRAP_DEMO_VAULT_COMMAND = "bootstrap-demo-vault";
+const HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
+const SUBCOMMAND_ARGUMENTS_START_INDEX = 3;
+const USAGE = `Usage:
+  obsidian-integration-testing [options]
+      Launch (or attach to) a CDP-enabled Obsidian instance and print its endpoint.
+      Options: --vault, --port, --host, --obsidian-version, --obsidian-installer-version,
+               --command-timeout, --no-remove-vault
+
+  obsidian-integration-testing ${BOOTSTRAP_DEMO_VAULT_COMMAND} [options]
+      Install a demo vault's injected community plugins from their published GitHub
+      releases, so integration tests run without opening Obsidian by hand.
+      Options: --demo-vault <path>   demo vault directory (default: ./demo-vault)
+               --plugin <id>         plugin id to install (repeatable; default: every
+                                     id already present under .obsidian/plugins/)
+               --repo <owner/name>   override the registry lookup (single --plugin only)
+               --version <tag>       pin a release tag (single --plugin only)
+               --force               re-download plugins that are already installed
+`;
 async function main() {
+  const [, , firstArgument] = import_node_process.default.argv;
+  if (firstArgument !== void 0 && HELP_FLAGS.has(firstArgument)) {
+    import_node_process.default.stdout.write(USAGE);
+    return;
+  }
+  if (firstArgument === BOOTSTRAP_DEMO_VAULT_COMMAND) {
+    await runBootstrapDemoVaultCommand(import_node_process.default.argv.slice(SUBCOMMAND_ARGUMENTS_START_INDEX));
+    return;
+  }
+  await runConnectCommand();
+}
+function buildOptions(values) {
+  return {
+    ...values["command-timeout"] !== void 0 && { commandTimeoutInMilliseconds: parseNumber("command-timeout", values["command-timeout"]) },
+    ...values.host !== void 0 && { host: values.host },
+    ...values["no-remove-vault"] === true && { shouldRemoveVaultOnDispose: false },
+    ...values["obsidian-installer-version"] !== void 0 && { obsidianInstallerVersion: values["obsidian-installer-version"] },
+    ...values["obsidian-version"] !== void 0 && { obsidianVersion: values["obsidian-version"] },
+    ...values.port !== void 0 && { port: parseNumber("port", values.port) },
+    ...values.vault !== void 0 && { vault: values.vault }
+  };
+}
+function discoverDemoVaultPluginIds(demoVaultPath) {
+  const pluginsDirectory = (0, import_node_path.join)(demoVaultPath, ".obsidian", "plugins");
+  if (!(0, import_node_fs.existsSync)(pluginsDirectory)) {
+    return [];
+  }
+  return (0, import_node_fs.readdirSync)(pluginsDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+function parseNumber(flag, raw) {
+  const value = Number(raw);
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`--${flag} must be a number, got: ${raw}`);
+  }
+  return value;
+}
+async function runBootstrapDemoVaultCommand(commandArguments) {
+  const { values } = (0, import_node_util.parseArgs)({
+    // eslint-disable-next-line unicorn/name-replacements -- `args` is Node's own `parseArgs` option name.
+    args: commandArguments,
+    options: {
+      "demo-vault": { type: "string" },
+      "force": { type: "boolean" },
+      "plugin": { multiple: true, type: "string" },
+      "repo": { type: "string" },
+      "version": { type: "string" }
+    }
+  });
+  const demoVaultPath = (0, import_node_path.resolve)(values["demo-vault"] ?? (0, import_node_path.join)(import_node_process.default.cwd(), "demo-vault"));
+  const pluginIds = values.plugin ?? discoverDemoVaultPluginIds(demoVaultPath);
+  if (pluginIds.length === 0) {
+    throw new Error(
+      `No community plugins to install: ${demoVaultPath} has no .obsidian/plugins/ entries. Name them explicitly, e.g. --plugin fix-require-modules.`
+    );
+  }
+  if (pluginIds.length > 1 && (values.repo !== void 0 || values.version !== void 0)) {
+    throw new Error("--repo and --version apply to a single plugin; pass exactly one --plugin, or run the command once per plugin.");
+  }
+  const injectPlugins = pluginIds.map((pluginId) => ({
+    pluginId,
+    ...values.repo !== void 0 && { repo: values.repo },
+    ...values.version !== void 0 && { version: values.version }
+  }));
+  const result = await (0, import_demo_vault_bootstrap.bootstrapDemoVaultPlugins)({
+    demoVaultPath,
+    injectPlugins,
+    shouldForce: values.force === true
+  });
+  for (const info of result.installed) {
+    import_node_process.default.stdout.write(`Installed ${info.pluginId} from ${info.repo}@${info.version ?? "latest"}: ${info.assetNames.join(", ")}
+`);
+  }
+  if (result.skippedPluginIds.length > 0) {
+    import_node_process.default.stdout.write(`Already installed (use --force to re-download): ${result.skippedPluginIds.join(", ")}
+`);
+  }
+  if (result.installed.length === 0) {
+    import_node_process.default.stdout.write("Nothing to install.\n");
+  }
+}
+async function runConnectCommand() {
   const { values } = (0, import_node_util.parseArgs)({
     options: {
       "command-timeout": { type: "string" },
@@ -60,24 +163,6 @@ Press Ctrl+C to stop.
   import_node_process.default.stdout.write("\nShutting down\u2026\n");
   await connection.dispose();
 }
-function buildOptions(values) {
-  return {
-    ...values["command-timeout"] !== void 0 && { commandTimeoutInMilliseconds: parseNumber("command-timeout", values["command-timeout"]) },
-    ...values.host !== void 0 && { host: values.host },
-    ...values["no-remove-vault"] === true && { shouldRemoveVaultOnDispose: false },
-    ...values["obsidian-installer-version"] !== void 0 && { obsidianInstallerVersion: values["obsidian-installer-version"] },
-    ...values["obsidian-version"] !== void 0 && { obsidianVersion: values["obsidian-version"] },
-    ...values.port !== void 0 && { port: parseNumber("port", values.port) },
-    ...values.vault !== void 0 && { vault: values.vault }
-  };
-}
-function parseNumber(flag, raw) {
-  const value = Number(raw);
-  if (!Number.isFinite(value)) {
-    throw new TypeError(`--${flag} must be a number, got: ${raw}`);
-  }
-  return value;
-}
 function waitForShutdownOrInstanceClose(cdpUrl) {
   const POLL_INTERVAL_IN_MILLISECONDS = 1e3;
   return new Promise((resolve) => {
@@ -113,4 +198,4 @@ function waitForShutdownOrInstanceClose(cdpUrl) {
 0 && (module.exports = {
   main
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/cli.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Thin CLI over {@link connectToCdp}: launches (or attaches to) a CDP-enabled\n * Obsidian instance with the runtime helper namespace bootstrapped, prints the\n * chosen CDP port/URL, and stays alive until interrupted so an external tool\n * (raw CDP `ws`, DevTools, \u2026) can attach.\n */\n\n/* v8 ignore start -- Integration-time CLI (launches Obsidian / CDP) covered manually, not by unit tests. */\n\nimport process from 'node:process';\nimport { parseArgs } from 'node:util';\n\nimport type { ConnectToCdpOptions } from './connect-to-cdp.cjs';\n\nimport { connectToCdp } from './connect-to-cdp.cjs';\n\n/**\n * The shape of the parsed CLI flag values.\n */\ninterface ParsedCliValues {\n  'command-timeout'?: string | undefined;\n  'host'?: string | undefined;\n  'no-remove-vault'?: boolean | undefined;\n  'obsidian-installer-version'?: string | undefined;\n  'obsidian-version'?: string | undefined;\n  'port'?: string | undefined;\n  'vault'?: string | undefined;\n}\n\n/**\n * Parses CLI arguments, opens the connection, prints its endpoint, and blocks\n * until `SIGINT`/`SIGTERM` or the owned Obsidian window is closed, disposing the\n * connection on shutdown.\n *\n * @returns A {@link Promise} that resolves once the connection has been disposed.\n */\nexport async function main(): Promise<void> {\n  const { values } = parseArgs({\n    options: {\n      'command-timeout': { type: 'string' },\n      'host': { type: 'string' },\n      'no-remove-vault': { type: 'boolean' },\n      'obsidian-installer-version': { type: 'string' },\n      'obsidian-version': { type: 'string' },\n      'port': { type: 'string' },\n      'vault': { type: 'string' }\n    }\n  });\n\n  const connection = await connectToCdp(buildOptions(values));\n\n  process.stdout.write(\n    'Obsidian CDP ready.\\n'\n      + `  port:   ${String(connection.port)}\\n`\n      + `  cdpUrl: ${connection.cdpUrl}\\n`\n      + `  vault:  ${connection.vault.path}\\n`\n      + 'Runtime helpers bootstrapped as window.__obsidianIntegrationTesting.\\n'\n      + 'Press Ctrl+C to stop.\\n'\n  );\n\n  await waitForShutdownOrInstanceClose(connection.cdpUrl);\n\n  process.stdout.write('\\nShutting down\u2026\\n');\n  await connection.dispose();\n}\n\n/**\n * Builds {@link ConnectToCdpOptions} from parsed CLI flag values.\n *\n * @param values - The parsed `parseArgs` values.\n * @returns The connection options.\n */\nfunction buildOptions(values: ParsedCliValues): ConnectToCdpOptions {\n  return {\n    ...(values['command-timeout'] !== undefined && { commandTimeoutInMilliseconds: parseNumber('command-timeout', values['command-timeout']) }),\n    ...(values.host !== undefined && { host: values.host }),\n    ...(values['no-remove-vault'] === true && { shouldRemoveVaultOnDispose: false }),\n    ...(values['obsidian-installer-version'] !== undefined && { obsidianInstallerVersion: values['obsidian-installer-version'] }),\n    ...(values['obsidian-version'] !== undefined && { obsidianVersion: values['obsidian-version'] }),\n    ...(values.port !== undefined && { port: parseNumber('port', values.port) }),\n    ...(values.vault !== undefined && { vault: values.vault })\n  };\n}\n\n/**\n * Parses a numeric CLI flag value, throwing on a non-finite result.\n *\n * @param flag - The flag name (for the error message).\n * @param raw - The raw string value.\n * @returns The parsed number.\n * @throws Error if `raw` is not a finite number.\n */\nfunction parseNumber(flag: string, raw: string): number {\n  const value = Number(raw);\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`--${flag} must be a number, got: ${raw}`);\n  }\n  return value;\n}\n\n/**\n * Resolves once the process receives `SIGINT`/`SIGTERM`, or the CDP endpoint\n * stops answering (the owned Obsidian window was closed).\n *\n * @param cdpUrl - The connection's CDP base URL to poll.\n * @returns A {@link Promise} that resolves on the first shutdown trigger.\n */\nfunction waitForShutdownOrInstanceClose(cdpUrl: string): Promise<void> {\n  const POLL_INTERVAL_IN_MILLISECONDS = 1000;\n  return new Promise<void>((resolve) => {\n    const versionUrl = `${cdpUrl}/json/version`;\n    let isSettled = false;\n\n    const timer = setInterval(() => {\n      probeAlive().catch(() => {\n        // Ignore poll errors.\n      });\n    }, POLL_INTERVAL_IN_MILLISECONDS);\n\n    process.once('SIGINT', settle);\n    process.once('SIGTERM', settle);\n\n    async function probeAlive(): Promise<void> {\n      try {\n        const response = await fetch(versionUrl);\n        if (!response.ok) {\n          settle();\n        }\n      } catch {\n        // The CDP port stopped answering: the Obsidian window was closed.\n        settle();\n      }\n    }\n\n    function settle(): void {\n      if (isSettled) {\n        return;\n      }\n      isSettled = true;\n      clearInterval(timer);\n      resolve();\n    }\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,0BAAoB;AACpB,uBAA0B;AAI1B,4BAA6B;AAsB7B,eAAsB,OAAsB;AAC1C,QAAM,EAAE,OAAO,QAAI,4BAAU;AAAA,IAC3B,SAAS;AAAA,MACP,mBAAmB,EAAE,MAAM,SAAS;AAAA,MACpC,QAAQ,EAAE,MAAM,SAAS;AAAA,MACzB,mBAAmB,EAAE,MAAM,UAAU;AAAA,MACrC,8BAA8B,EAAE,MAAM,SAAS;AAAA,MAC/C,oBAAoB,EAAE,MAAM,SAAS;AAAA,MACrC,QAAQ,EAAE,MAAM,SAAS;AAAA,MACzB,SAAS,EAAE,MAAM,SAAS;AAAA,IAC5B;AAAA,EACF,CAAC;AAED,QAAM,aAAa,UAAM,oCAAa,aAAa,MAAM,CAAC;AAE1D,sBAAAA,QAAQ,OAAO;AAAA,IACb;AAAA,YACiB,OAAO,WAAW,IAAI,CAAC;AAAA,YACvB,WAAW,MAAM;AAAA,YACjB,WAAW,MAAM,IAAI;AAAA;AAAA;AAAA;AAAA,EAGxC;AAEA,QAAM,+BAA+B,WAAW,MAAM;AAEtD,sBAAAA,QAAQ,OAAO,MAAM,yBAAoB;AACzC,QAAM,WAAW,QAAQ;AAC3B;AAQA,SAAS,aAAa,QAA8C;AAClE,SAAO;AAAA,IACL,GAAI,OAAO,iBAAiB,MAAM,UAAa,EAAE,8BAA8B,YAAY,mBAAmB,OAAO,iBAAiB,CAAC,EAAE;AAAA,IACzI,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,OAAO,KAAK;AAAA,IACrD,GAAI,OAAO,iBAAiB,MAAM,QAAQ,EAAE,4BAA4B,MAAM;AAAA,IAC9E,GAAI,OAAO,4BAA4B,MAAM,UAAa,EAAE,0BAA0B,OAAO,4BAA4B,EAAE;AAAA,IAC3H,GAAI,OAAO,kBAAkB,MAAM,UAAa,EAAE,iBAAiB,OAAO,kBAAkB,EAAE;AAAA,IAC9F,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,YAAY,QAAQ,OAAO,IAAI,EAAE;AAAA,IAC1E,GAAI,OAAO,UAAU,UAAa,EAAE,OAAO,OAAO,MAAM;AAAA,EAC1D;AACF;AAUA,SAAS,YAAY,MAAc,KAAqB;AACtD,QAAM,QAAQ,OAAO,GAAG;AACxB,MAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AAC3B,UAAM,IAAI,UAAU,KAAK,IAAI,2BAA2B,GAAG,EAAE;AAAA,EAC/D;AACA,SAAO;AACT;AASA,SAAS,+BAA+B,QAA+B;AACrE,QAAM,gCAAgC;AACtC,SAAO,IAAI,QAAc,CAAC,YAAY;AACpC,UAAM,aAAa,GAAG,MAAM;AAC5B,QAAI,YAAY;AAEhB,UAAM,QAAQ,YAAY,MAAM;AAC9B,iBAAW,EAAE,MAAM,MAAM;AAAA,MAEzB,CAAC;AAAA,IACH,GAAG,6BAA6B;AAEhC,wBAAAA,QAAQ,KAAK,UAAU,MAAM;AAC7B,wBAAAA,QAAQ,KAAK,WAAW,MAAM;AAE9B,mBAAe,aAA4B;AACzC,UAAI;AACF,cAAM,WAAW,MAAM,MAAM,UAAU;AACvC,YAAI,CAAC,SAAS,IAAI;AAChB,iBAAO;AAAA,QACT;AAAA,MACF,QAAQ;AAEN,eAAO;AAAA,MACT;AAAA,IACF;AAEA,aAAS,SAAe;AACtB,UAAI,WAAW;AACb;AAAA,MACF;AACA,kBAAY;AACZ,oBAAc,KAAK;AACnB,cAAQ;AAAA,IACV;AAAA,EACF,CAAC;AACH;",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/cli.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The package's CLI. Two commands:\n *\n * - The **default** (no subcommand) \u2014 a thin CLI over {@link connectToCdp}: launches\n *   (or attaches to) a CDP-enabled Obsidian instance with the runtime helper\n *   namespace bootstrapped, prints the chosen CDP port/URL, and stays alive until\n *   interrupted so an external tool (raw CDP `ws`, DevTools, \u2026) can attach.\n * - **`bootstrap-demo-vault`** \u2014 installs a demo vault's injected community plugins\n *   headlessly (see `demo-vault-bootstrap.ts`). This is the copy-pasteable remedy\n *   `buildDemoVaultPopulate`'s throw names, replacing the GUI-only \"open\n *   `demo-vault/` in Obsidian once\" step that a fresh clone or CI cannot perform.\n *\n * Anything that is not a recognized subcommand falls through to the default\n * command, so `obsidian-integration-testing --vault \u2026` keeps working unchanged.\n */\n\n/* v8 ignore start -- Integration-time CLI (launches Obsidian / CDP, downloads releases) covered manually, not by unit tests. */\n\nimport {\n  existsSync,\n  readdirSync\n} from 'node:fs';\nimport {\n  join,\n  resolve as resolvePath\n} from 'node:path';\nimport process from 'node:process';\nimport { parseArgs } from 'node:util';\n\nimport type { ConnectToCdpOptions } from './connect-to-cdp.cjs';\nimport type { InjectPluginParams } from './demo-vault-populate.cjs';\n\nimport { connectToCdp } from './connect-to-cdp.cjs';\nimport { bootstrapDemoVaultPlugins } from './demo-vault-bootstrap.cjs';\n\nconst BOOTSTRAP_DEMO_VAULT_COMMAND = 'bootstrap-demo-vault';\nconst HELP_FLAGS = new Set(['--help', '-h']);\n\n/**\nIndex of a subcommand's first argument in `process.argv` (`[node, script, subcommand, \u2026]`).\n */\nconst SUBCOMMAND_ARGUMENTS_START_INDEX = 3;\n\nconst USAGE = `Usage:\n  obsidian-integration-testing [options]\n      Launch (or attach to) a CDP-enabled Obsidian instance and print its endpoint.\n      Options: --vault, --port, --host, --obsidian-version, --obsidian-installer-version,\n               --command-timeout, --no-remove-vault\n\n  obsidian-integration-testing ${BOOTSTRAP_DEMO_VAULT_COMMAND} [options]\n      Install a demo vault's injected community plugins from their published GitHub\n      releases, so integration tests run without opening Obsidian by hand.\n      Options: --demo-vault <path>   demo vault directory (default: ./demo-vault)\n               --plugin <id>         plugin id to install (repeatable; default: every\n                                     id already present under .obsidian/plugins/)\n               --repo <owner/name>   override the registry lookup (single --plugin only)\n               --version <tag>       pin a release tag (single --plugin only)\n               --force               re-download plugins that are already installed\n`;\n\n/**\n * The shape of the parsed CLI flag values.\n */\ninterface ParsedCliValues {\n  'command-timeout'?: string | undefined;\n  'host'?: string | undefined;\n  'no-remove-vault'?: boolean | undefined;\n  'obsidian-installer-version'?: string | undefined;\n  'obsidian-version'?: string | undefined;\n  'port'?: string | undefined;\n  'vault'?: string | undefined;\n}\n\n/**\n * Dispatches to the requested subcommand, falling through to the default CDP\n * command for anything that is not one.\n *\n * @returns A {@link Promise} that resolves once the chosen command has finished.\n */\nexport async function main(): Promise<void> {\n  const [, , firstArgument] = process.argv;\n\n  if (firstArgument !== undefined && HELP_FLAGS.has(firstArgument)) {\n    process.stdout.write(USAGE);\n    return;\n  }\n\n  if (firstArgument === BOOTSTRAP_DEMO_VAULT_COMMAND) {\n    await runBootstrapDemoVaultCommand(process.argv.slice(SUBCOMMAND_ARGUMENTS_START_INDEX));\n    return;\n  }\n\n  await runConnectCommand();\n}\n\n/**\n * Builds {@link ConnectToCdpOptions} from parsed CLI flag values.\n *\n * @param values - The parsed `parseArgs` values.\n * @returns The connection options.\n */\nfunction buildOptions(values: ParsedCliValues): ConnectToCdpOptions {\n  return {\n    ...(values['command-timeout'] !== undefined && { commandTimeoutInMilliseconds: parseNumber('command-timeout', values['command-timeout']) }),\n    ...(values.host !== undefined && { host: values.host }),\n    ...(values['no-remove-vault'] === true && { shouldRemoveVaultOnDispose: false }),\n    ...(values['obsidian-installer-version'] !== undefined && { obsidianInstallerVersion: values['obsidian-installer-version'] }),\n    ...(values['obsidian-version'] !== undefined && { obsidianVersion: values['obsidian-version'] }),\n    ...(values.port !== undefined && { port: parseNumber('port', values.port) }),\n    ...(values.vault !== undefined && { vault: values.vault })\n  };\n}\n\n/**\n * Lists the plugin ids already present under a demo vault's `.obsidian/plugins/`, used as the default\n * install set when `--plugin` is omitted. A folder that exists but lacks `main.js` is exactly the state\n * this command repairs, so presence \u2014 not completeness \u2014 is the criterion.\n *\n * @param demoVaultPath - The demo vault root.\n * @returns The plugin ids, or an empty array when the vault has no plugins folder.\n */\nfunction discoverDemoVaultPluginIds(demoVaultPath: string): string[] {\n  const pluginsDirectory = join(demoVaultPath, '.obsidian', 'plugins');\n  if (!existsSync(pluginsDirectory)) {\n    return [];\n  }\n  return readdirSync(pluginsDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);\n}\n\n/**\n * Parses a numeric CLI flag value, throwing on a non-finite result.\n *\n * @param flag - The flag name (for the error message).\n * @param raw - The raw string value.\n * @returns The parsed number.\n * @throws Error if `raw` is not a finite number.\n */\nfunction parseNumber(flag: string, raw: string): number {\n  const value = Number(raw);\n  if (!Number.isFinite(value)) {\n    throw new TypeError(`--${flag} must be a number, got: ${raw}`);\n  }\n  return value;\n}\n\n/**\n * Runs the `bootstrap-demo-vault` subcommand.\n *\n * @param commandArguments - The subcommand's arguments (everything after the subcommand name).\n * @returns A {@link Promise} that resolves once the install has finished.\n * @throws Error if no plugin ids can be determined, or `--repo` / `--version` are used with several plugins.\n */\nasync function runBootstrapDemoVaultCommand(commandArguments: string[]): Promise<void> {\n  const { values } = parseArgs({\n    // eslint-disable-next-line unicorn/name-replacements -- `args` is Node's own `parseArgs` option name.\n    args: commandArguments,\n    options: {\n      'demo-vault': { type: 'string' },\n      'force': { type: 'boolean' },\n      'plugin': { multiple: true, type: 'string' },\n      'repo': { type: 'string' },\n      'version': { type: 'string' }\n    }\n  });\n\n  const demoVaultPath = resolvePath(values['demo-vault'] ?? join(process.cwd(), 'demo-vault'));\n  const pluginIds = values.plugin ?? discoverDemoVaultPluginIds(demoVaultPath);\n\n  if (pluginIds.length === 0) {\n    throw new Error(\n      `No community plugins to install: ${demoVaultPath} has no .obsidian/plugins/ entries. `\n        + 'Name them explicitly, e.g. --plugin fix-require-modules.'\n    );\n  }\n\n  if (pluginIds.length > 1 && (values.repo !== undefined || values.version !== undefined)) {\n    throw new Error('--repo and --version apply to a single plugin; pass exactly one --plugin, or run the command once per plugin.');\n  }\n\n  const injectPlugins: InjectPluginParams[] = pluginIds.map((pluginId) => ({\n    pluginId,\n    ...(values.repo !== undefined && { repo: values.repo }),\n    ...(values.version !== undefined && { version: values.version })\n  }));\n\n  const result = await bootstrapDemoVaultPlugins({\n    demoVaultPath,\n    injectPlugins,\n    shouldForce: values.force === true\n  });\n\n  for (const info of result.installed) {\n    process.stdout.write(`Installed ${info.pluginId} from ${info.repo}@${info.version ?? 'latest'}: ${info.assetNames.join(', ')}\\n`);\n  }\n\n  if (result.skippedPluginIds.length > 0) {\n    process.stdout.write(`Already installed (use --force to re-download): ${result.skippedPluginIds.join(', ')}\\n`);\n  }\n\n  if (result.installed.length === 0) {\n    process.stdout.write('Nothing to install.\\n');\n  }\n}\n\n/**\n * Runs the default command: parses CLI arguments, opens the connection, prints its\n * endpoint, and blocks until `SIGINT`/`SIGTERM` or the owned Obsidian window is\n * closed, disposing the connection on shutdown.\n *\n * @returns A {@link Promise} that resolves once the connection has been disposed.\n */\nasync function runConnectCommand(): Promise<void> {\n  const { values } = parseArgs({\n    options: {\n      'command-timeout': { type: 'string' },\n      'host': { type: 'string' },\n      'no-remove-vault': { type: 'boolean' },\n      'obsidian-installer-version': { type: 'string' },\n      'obsidian-version': { type: 'string' },\n      'port': { type: 'string' },\n      'vault': { type: 'string' }\n    }\n  });\n\n  const connection = await connectToCdp(buildOptions(values));\n\n  process.stdout.write(\n    'Obsidian CDP ready.\\n'\n      + `  port:   ${String(connection.port)}\\n`\n      + `  cdpUrl: ${connection.cdpUrl}\\n`\n      + `  vault:  ${connection.vault.path}\\n`\n      + 'Runtime helpers bootstrapped as window.__obsidianIntegrationTesting.\\n'\n      + 'Press Ctrl+C to stop.\\n'\n  );\n\n  await waitForShutdownOrInstanceClose(connection.cdpUrl);\n\n  process.stdout.write('\\nShutting down\u2026\\n');\n  await connection.dispose();\n}\n\n/**\n * Resolves once the process receives `SIGINT`/`SIGTERM`, or the CDP endpoint\n * stops answering (the owned Obsidian window was closed).\n *\n * @param cdpUrl - The connection's CDP base URL to poll.\n * @returns A {@link Promise} that resolves on the first shutdown trigger.\n */\nfunction waitForShutdownOrInstanceClose(cdpUrl: string): Promise<void> {\n  const POLL_INTERVAL_IN_MILLISECONDS = 1000;\n  return new Promise<void>((resolve) => {\n    const versionUrl = `${cdpUrl}/json/version`;\n    let isSettled = false;\n\n    const timer = setInterval(() => {\n      probeAlive().catch(() => {\n        // Ignore poll errors.\n      });\n    }, POLL_INTERVAL_IN_MILLISECONDS);\n\n    process.once('SIGINT', settle);\n    process.once('SIGTERM', settle);\n\n    async function probeAlive(): Promise<void> {\n      try {\n        const response = await fetch(versionUrl);\n        if (!response.ok) {\n          settle();\n        }\n      } catch {\n        // The CDP port stopped answering: the Obsidian window was closed.\n        settle();\n      }\n    }\n\n    function settle(): void {\n      if (isSettled) {\n        return;\n      }\n      isSettled = true;\n      clearInterval(timer);\n      resolve();\n    }\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,qBAGO;AACP,uBAGO;AACP,0BAAoB;AACpB,uBAA0B;AAK1B,4BAA6B;AAC7B,kCAA0C;AAE1C,MAAM,+BAA+B;AACrC,MAAM,aAAa,oBAAI,IAAI,CAAC,UAAU,IAAI,CAAC;AAK3C,MAAM,mCAAmC;AAEzC,MAAM,QAAQ;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,iCAMmB,4BAA4B;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AA8B7D,eAAsB,OAAsB;AAC1C,QAAM,CAAC,EAAE,EAAE,aAAa,IAAI,oBAAAA,QAAQ;AAEpC,MAAI,kBAAkB,UAAa,WAAW,IAAI,aAAa,GAAG;AAChE,wBAAAA,QAAQ,OAAO,MAAM,KAAK;AAC1B;AAAA,EACF;AAEA,MAAI,kBAAkB,8BAA8B;AAClD,UAAM,6BAA6B,oBAAAA,QAAQ,KAAK,MAAM,gCAAgC,CAAC;AACvF;AAAA,EACF;AAEA,QAAM,kBAAkB;AAC1B;AAQA,SAAS,aAAa,QAA8C;AAClE,SAAO;AAAA,IACL,GAAI,OAAO,iBAAiB,MAAM,UAAa,EAAE,8BAA8B,YAAY,mBAAmB,OAAO,iBAAiB,CAAC,EAAE;AAAA,IACzI,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,OAAO,KAAK;AAAA,IACrD,GAAI,OAAO,iBAAiB,MAAM,QAAQ,EAAE,4BAA4B,MAAM;AAAA,IAC9E,GAAI,OAAO,4BAA4B,MAAM,UAAa,EAAE,0BAA0B,OAAO,4BAA4B,EAAE;AAAA,IAC3H,GAAI,OAAO,kBAAkB,MAAM,UAAa,EAAE,iBAAiB,OAAO,kBAAkB,EAAE;AAAA,IAC9F,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,YAAY,QAAQ,OAAO,IAAI,EAAE;AAAA,IAC1E,GAAI,OAAO,UAAU,UAAa,EAAE,OAAO,OAAO,MAAM;AAAA,EAC1D;AACF;AAUA,SAAS,2BAA2B,eAAiC;AACnE,QAAM,uBAAmB,uBAAK,eAAe,aAAa,SAAS;AACnE,MAAI,KAAC,2BAAW,gBAAgB,GAAG;AACjC,WAAO,CAAC;AAAA,EACV;AACA,aAAO,4BAAY,kBAAkB,EAAE,eAAe,KAAK,CAAC,EAAE,OAAO,CAAC,UAAU,MAAM,YAAY,CAAC,EAAE,IAAI,CAAC,UAAU,MAAM,IAAI;AAChI;AAUA,SAAS,YAAY,MAAc,KAAqB;AACtD,QAAM,QAAQ,OAAO,GAAG;AACxB,MAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AAC3B,UAAM,IAAI,UAAU,KAAK,IAAI,2BAA2B,GAAG,EAAE;AAAA,EAC/D;AACA,SAAO;AACT;AASA,eAAe,6BAA6B,kBAA2C;AACrF,QAAM,EAAE,OAAO,QAAI,4BAAU;AAAA;AAAA,IAE3B,MAAM;AAAA,IACN,SAAS;AAAA,MACP,cAAc,EAAE,MAAM,SAAS;AAAA,MAC/B,SAAS,EAAE,MAAM,UAAU;AAAA,MAC3B,UAAU,EAAE,UAAU,MAAM,MAAM,SAAS;AAAA,MAC3C,QAAQ,EAAE,MAAM,SAAS;AAAA,MACzB,WAAW,EAAE,MAAM,SAAS;AAAA,IAC9B;AAAA,EACF,CAAC;AAED,QAAM,oBAAgB,iBAAAC,SAAY,OAAO,YAAY,SAAK,uBAAK,oBAAAD,QAAQ,IAAI,GAAG,YAAY,CAAC;AAC3F,QAAM,YAAY,OAAO,UAAU,2BAA2B,aAAa;AAE3E,MAAI,UAAU,WAAW,GAAG;AAC1B,UAAM,IAAI;AAAA,MACR,oCAAoC,aAAa;AAAA,IAEnD;AAAA,EACF;AAEA,MAAI,UAAU,SAAS,MAAM,OAAO,SAAS,UAAa,OAAO,YAAY,SAAY;AACvF,UAAM,IAAI,MAAM,+GAA+G;AAAA,EACjI;AAEA,QAAM,gBAAsC,UAAU,IAAI,CAAC,cAAc;AAAA,IACvE;AAAA,IACA,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,OAAO,KAAK;AAAA,IACrD,GAAI,OAAO,YAAY,UAAa,EAAE,SAAS,OAAO,QAAQ;AAAA,EAChE,EAAE;AAEF,QAAM,SAAS,UAAM,uDAA0B;AAAA,IAC7C;AAAA,IACA;AAAA,IACA,aAAa,OAAO,UAAU;AAAA,EAChC,CAAC;AAED,aAAW,QAAQ,OAAO,WAAW;AACnC,wBAAAA,QAAQ,OAAO,MAAM,aAAa,KAAK,QAAQ,SAAS,KAAK,IAAI,IAAI,KAAK,WAAW,QAAQ,KAAK,KAAK,WAAW,KAAK,IAAI,CAAC;AAAA,CAAI;AAAA,EAClI;AAEA,MAAI,OAAO,iBAAiB,SAAS,GAAG;AACtC,wBAAAA,QAAQ,OAAO,MAAM,mDAAmD,OAAO,iBAAiB,KAAK,IAAI,CAAC;AAAA,CAAI;AAAA,EAChH;AAEA,MAAI,OAAO,UAAU,WAAW,GAAG;AACjC,wBAAAA,QAAQ,OAAO,MAAM,uBAAuB;AAAA,EAC9C;AACF;AASA,eAAe,oBAAmC;AAChD,QAAM,EAAE,OAAO,QAAI,4BAAU;AAAA,IAC3B,SAAS;AAAA,MACP,mBAAmB,EAAE,MAAM,SAAS;AAAA,MACpC,QAAQ,EAAE,MAAM,SAAS;AAAA,MACzB,mBAAmB,EAAE,MAAM,UAAU;AAAA,MACrC,8BAA8B,EAAE,MAAM,SAAS;AAAA,MAC/C,oBAAoB,EAAE,MAAM,SAAS;AAAA,MACrC,QAAQ,EAAE,MAAM,SAAS;AAAA,MACzB,SAAS,EAAE,MAAM,SAAS;AAAA,IAC5B;AAAA,EACF,CAAC;AAED,QAAM,aAAa,UAAM,oCAAa,aAAa,MAAM,CAAC;AAE1D,sBAAAA,QAAQ,OAAO;AAAA,IACb;AAAA,YACiB,OAAO,WAAW,IAAI,CAAC;AAAA,YACvB,WAAW,MAAM;AAAA,YACjB,WAAW,MAAM,IAAI;AAAA;AAAA;AAAA;AAAA,EAGxC;AAEA,QAAM,+BAA+B,WAAW,MAAM;AAEtD,sBAAAA,QAAQ,OAAO,MAAM,yBAAoB;AACzC,QAAM,WAAW,QAAQ;AAC3B;AASA,SAAS,+BAA+B,QAA+B;AACrE,QAAM,gCAAgC;AACtC,SAAO,IAAI,QAAc,CAAC,YAAY;AACpC,UAAM,aAAa,GAAG,MAAM;AAC5B,QAAI,YAAY;AAEhB,UAAM,QAAQ,YAAY,MAAM;AAC9B,iBAAW,EAAE,MAAM,MAAM;AAAA,MAEzB,CAAC;AAAA,IACH,GAAG,6BAA6B;AAEhC,wBAAAA,QAAQ,KAAK,UAAU,MAAM;AAC7B,wBAAAA,QAAQ,KAAK,WAAW,MAAM;AAE9B,mBAAe,aAA4B;AACzC,UAAI;AACF,cAAM,WAAW,MAAM,MAAM,UAAU;AACvC,YAAI,CAAC,SAAS,IAAI;AAChB,iBAAO;AAAA,QACT;AAAA,MACF,QAAQ;AAEN,eAAO;AAAA,MACT;AAAA,IACF;AAEA,aAAS,SAAe;AACtB,UAAI,WAAW;AACb;AAAA,MACF;AACA,kBAAY;AACZ,oBAAc,KAAK;AACnB,cAAQ;AAAA,IACV;AAAA,EACF,CAAC;AACH;",
  "names": ["process", "resolvePath"]
}


package/dist/lib/cjs/cli.d.cts

@@ -1,16 +1,24 @@
 /**
  * @file
  *
- * Thin CLI over {@link connectToCdp}: launches (or attaches to) a CDP-enabled
- * Obsidian instance with the runtime helper namespace bootstrapped, prints the
- * chosen CDP port/URL, and stays alive until interrupted so an external tool
- * (raw CDP `ws`, DevTools, …) can attach.
+ * The package's CLI. Two commands:
+ *
+ * - The **default** (no subcommand) — a thin CLI over {@link connectToCdp}: launches
+ *   (or attaches to) a CDP-enabled Obsidian instance with the runtime helper
+ *   namespace bootstrapped, prints the chosen CDP port/URL, and stays alive until
+ *   interrupted so an external tool (raw CDP `ws`, DevTools, …) can attach.
+ * - **`bootstrap-demo-vault`** — installs a demo vault's injected community plugins
+ *   headlessly (see `demo-vault-bootstrap.ts`). This is the copy-pasteable remedy
+ *   `buildDemoVaultPopulate`'s throw names, replacing the GUI-only "open
+ *   `demo-vault/` in Obsidian once" step that a fresh clone or CI cannot perform.
+ *
+ * Anything that is not a recognized subcommand falls through to the default
+ * command, so `obsidian-integration-testing --vault …` keeps working unchanged.
  */
 /**
- * Parses CLI arguments, opens the connection, prints its endpoint, and blocks
- * until `SIGINT`/`SIGTERM` or the owned Obsidian window is closed, disposing the
- * connection on shutdown.
+ * Dispatches to the requested subcommand, falling through to the default CDP
+ * command for anything that is not one.
  *
- * @returns A {@link Promise} that resolves once the connection has been disposed.
+ * @returns A {@link Promise} that resolves once the chosen command has finished.
  */
 export declare function main(): Promise<void>;