obsidian-integration-testing 10.4.0 → 12.0.0

package/dist/lib/cjs/wedged-appium-server.cjs

@@ -0,0 +1,113 @@
+"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 wedged_appium_server_exports = {};
+__export(wedged_appium_server_exports, {
+  buildWedgedAppiumServerMessage: () => buildWedgedAppiumServerMessage,
+  checkIsAppiumDeviceNotFoundError: () => checkIsAppiumDeviceNotFoundError,
+  checkIsAppiumStatusReady: () => checkIsAppiumStatusReady,
+  resolveWedgedAppiumServerRemedy: () => resolveWedgedAppiumServerRemedy
+});
+module.exports = __toCommonJS(wedged_appium_server_exports);
+var import_error_to_string = require("./error-to-string.cjs");
+const DEVICE_NOT_FOUND_MESSAGE_FRAGMENT = "Could not find a connected Android device";
+const MILLISECONDS_PER_SECOND = 1e3;
+const SECONDS_PER_MINUTE = 60;
+const MILLISECONDS_PER_MINUTE = MILLISECONDS_PER_SECOND * SECONDS_PER_MINUTE;
+function buildWedgedAppiumServerMessage(params) {
+  const lines = [
+    `The Appium server at ${params.appiumOrigin} cannot see Android device ${params.deviceId}, although this host's adb can.`,
+    "The server is stale \u2014 its adb connection is wedged \u2014 not the device, so `adb devices` will list the device and mislead you.",
+    resolveRemedyAdvice(params)
+  ];
+  const provenance = describeServer(params);
+  if (provenance) {
+    lines.push(provenance);
+  }
+  return lines.join("\n");
+}
+function checkIsAppiumDeviceNotFoundError(error) {
+  return (0, import_error_to_string.errorToString)(error).includes(DEVICE_NOT_FOUND_MESSAGE_FRAGMENT);
+}
+function checkIsAppiumStatusReady(statusBody) {
+  let parsed;
+  try {
+    parsed = JSON.parse(statusBody);
+  } catch {
+    return true;
+  }
+  return readReadyFlag(parsed) !== false;
+}
+function resolveWedgedAppiumServerRemedy(params) {
+  if (!checkIsAppiumDeviceNotFoundError(params.error)) {
+    return { reason: "other-error", remedy: "not-wedged" };
+  }
+  if (!params.connectedDeviceIds.includes(params.deviceId)) {
+    return { reason: "device-absent", remedy: "not-wedged" };
+  }
+  if (!params.isAdoptedServer) {
+    return { reason: "freshly-started", remedy: "report" };
+  }
+  if (!params.isAutoStartAllowed) {
+    return { reason: "auto-start-disabled", remedy: "report" };
+  }
+  if (!params.isHarnessOwnedServer) {
+    return { reason: "foreign-server", remedy: "report" };
+  }
+  return { reason: "harness-owned", remedy: "restart" };
+}
+function describeServer(params) {
+  if (params.serverPid === void 0) {
+    return "";
+  }
+  const age = params.serverAgeInMilliseconds === void 0 ? "" : `, running for ${formatAge(params.serverAgeInMilliseconds)}`;
+  return `The server was started by an earlier obsidian-integration-testing run (pid ${String(params.serverPid)}${age}).`;
+}
+function formatAge(ageInMilliseconds) {
+  if (ageInMilliseconds < MILLISECONDS_PER_MINUTE) {
+    return `${String(Math.round(ageInMilliseconds / MILLISECONDS_PER_SECOND))}s`;
+  }
+  return `${String(Math.round(ageInMilliseconds / MILLISECONDS_PER_MINUTE))}min`;
+}
+function readReadyFlag(parsed) {
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const record = parsed;
+  const value = record["value"];
+  const nested = typeof value === "object" && value !== null ? value["ready"] : void 0;
+  const ready = nested ?? record["ready"];
+  return typeof ready === "boolean" ? ready : void 0;
+}
+function resolveRemedyAdvice(params) {
+  const advice = {
+    "auto-start-disabled": `Appium auto-start is disabled (\`shouldAutoStartAppium: false\`), so this server is yours to manage: kill it and start a fresh one on ${params.appiumOrigin}, then re-run.`,
+    "foreign-server": `This server was not started by obsidian-integration-testing, so it was left running: kill it and start a fresh one on ${params.appiumOrigin}, then re-run.`,
+    "freshly-started": "This server was started by this run, so restarting it would change nothing: check that adb and the emulator agree (`adb kill-server && adb devices`), then re-run.",
+    "restart-did-not-help": `Restarting the server on ${params.appiumOrigin} did not help \u2014 a fresh one still could not serve this run, so the wedge is not the server alone: check adb itself (\`adb kill-server && adb devices\`) and that nothing else holds the port, then re-run.`
+  };
+  return advice[params.reason];
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  buildWedgedAppiumServerMessage,
+  checkIsAppiumDeviceNotFoundError,
+  checkIsAppiumStatusReady,
+  resolveWedgedAppiumServerRemedy
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/wedged-appium-server.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure helpers for recognizing a **wedged** Appium server and deciding what to\n * do about it. Kept separate from the integration-only `transport-factory` so\n * the classification, the remedy decision and the message stay unit-testable\n * (the factory itself needs a real device and is excluded from unit tests).\n *\n * A wedged server is one that is still **live** \u2014 it listens on its port and\n * answers `/status` with `ready: true` \u2014 but is no longer **usable**: its\n * `appium-adb` can no longer enumerate devices, so every session creation dies\n * with `Could not find a connected Android device in <n>ms` while the host's own\n * `adb devices` lists the device instantly. Liveness is not readiness, and the\n * error names the wrong subject: it blames a device that is demonstrably\n * present, which sends whoever reads it to `adb devices` \u2014 the one diagnostic\n * that actively misleads here.\n *\n * The wedge develops over time in a long-lived server (one auto-started by an\n * earlier run and left listening), so the preflight cannot see it coming: it can\n * only be recognized from the failed session, cross-checked against the host's\n * adb.\n */\n\nimport { errorToString } from './error-to-string.cjs';\n\n/**\n * The fragment `appium-adb` throws when it cannot enumerate devices \u2014\n * `` `Could not find a connected Android device in ${timeoutMs}ms` `` from its\n * `getDevicesWithRetry` (`lib/tools/system-calls.ts`). Matched as a substring so\n * the timeout value and any wrapping by WebdriverIO do not affect it.\n */\nconst DEVICE_NOT_FOUND_MESSAGE_FRAGMENT = 'Could not find a connected Android device';\n\nconst MILLISECONDS_PER_SECOND = 1000;\nconst SECONDS_PER_MINUTE = 60;\nconst MILLISECONDS_PER_MINUTE = MILLISECONDS_PER_SECOND * SECONDS_PER_MINUTE;\n\n/**\n * Parameters for {@link buildWedgedAppiumServerMessage}.\n */\nexport interface BuildWedgedAppiumServerMessageParams {\n  /**\n  Origin of the Appium server that could not see the device (e.g. `http://localhost:4723`).\n   */\n  readonly appiumOrigin: string;\n\n  /**\n  The device the host's adb can see but Appium cannot.\n   */\n  readonly deviceId: string;\n\n  /**\n  Why this run is reporting rather than restarting.\n   */\n  readonly reason: WedgedAppiumServerReportReason;\n\n  /**\n  How long the server has been running, when known from its marker.\n   */\n  readonly serverAgeInMilliseconds?: number | undefined;\n\n  /**\n  PID of the server, when known from its marker.\n   */\n  readonly serverPid?: number | undefined;\n}\n\n/**\n * The server is not to blame: either the failure was a different error, or the\n * host's adb cannot see the device either. The original error is rethrown.\n */\nexport interface NotWedgedVerdict {\n  /**\n  Which of the two honest-failure cases this is.\n   */\n  readonly reason: 'device-absent' | 'other-error';\n\n  /**\n  Discriminant.\n   */\n  readonly remedy: 'not-wedged';\n}\n\n/**\n * The server is wedged but must not be touched by this run.\n */\nexport interface ReportServerVerdict {\n  /**\n  Why this run is reporting rather than restarting.\n   */\n  readonly reason: WedgedAppiumServerReportReason;\n\n  /**\n  Discriminant.\n   */\n  readonly remedy: 'report';\n}\n\n/**\n * Parameters for {@link resolveWedgedAppiumServerRemedy}.\n */\nexport interface ResolveWedgedAppiumServerRemedyParams {\n  /**\n  Device IDs the **host's** adb currently lists (the cross-check that convicts the server).\n   */\n  readonly connectedDeviceIds: readonly string[];\n\n  /**\n  The device the session was requested against.\n   */\n  readonly deviceId: string;\n\n  /**\n  The error the session attempt failed with.\n   */\n  readonly error: unknown;\n\n  /**\n  Whether the server was already listening and was adopted, rather than started by this run.\n   */\n  readonly isAdoptedServer: boolean;\n\n  /**\n  Whether this run may start an Appium server (`shouldAutoStartAppium` is not `false`).\n   */\n  readonly isAutoStartAllowed: boolean;\n\n  /**\n  Whether the adopted server's marker proves an earlier run of this harness started it.\n   */\n  readonly isHarnessOwnedServer: boolean;\n}\n\n/**\n * The server is wedged and an earlier run of this harness started it, so this\n * run may replace it.\n */\nexport interface RestartServerVerdict {\n  /**\n  Always the harness-owned case.\n   */\n  readonly reason: 'harness-owned';\n\n  /**\n  Discriminant.\n   */\n  readonly remedy: 'restart';\n}\n\n/**\n * The classification of a failed session attempt.\n *\n * `'device-absent'` and `'other-error'` are the not-wedged verdicts: the\n * original error was honest and is rethrown untouched.\n */\nexport type WedgedAppiumServerReason = 'device-absent' | 'harness-owned' | 'other-error' | WedgedAppiumServerReportReason;\n\n/**\n * What the factory should do with a failed session attempt.\n */\nexport type WedgedAppiumServerRemedy = 'not-wedged' | 'report' | 'restart';\n\n/**\n * Why a wedged server is only reported rather than restarted. Each maps to its\n * own remedy sentence \u2014 the whole point of the rewrite is that the message says\n * what *this* run can and cannot do about the server it found.\n */\nexport type WedgedAppiumServerReportReason =\n  | 'auto-start-disabled'\n  | 'foreign-server'\n  | 'freshly-started'\n  | 'restart-did-not-help';\n\n/**\n * The verdict on a failed session attempt, discriminated by `remedy` so a\n * `'report'` verdict carries a reason {@link buildWedgedAppiumServerMessage} can\n * turn into advice.\n */\nexport type WedgedAppiumServerVerdict = NotWedgedVerdict | ReportServerVerdict | RestartServerVerdict;\n\n/**\n * Builds the error message that replaces `Could not find a connected Android\n * device`, naming the **server** and stating the evidence \u2014 the host's adb can\n * see the device, so the server is the thing that is stale.\n *\n * @param params - The server, the device, and why this run is not restarting it.\n * @returns The message.\n */\nexport function buildWedgedAppiumServerMessage(params: BuildWedgedAppiumServerMessageParams): string {\n  const lines = [\n    `The Appium server at ${params.appiumOrigin} cannot see Android device ${params.deviceId}, although this host's adb can.`,\n    'The server is stale \u2014 its adb connection is wedged \u2014 not the device, so `adb devices` will list the device and mislead you.',\n    resolveRemedyAdvice(params)\n  ];\n\n  const provenance = describeServer(params);\n  if (provenance) {\n    lines.push(provenance);\n  }\n\n  return lines.join('\\n');\n}\n\n/**\n * Checks whether a failed session attempt is `appium-adb`'s device-enumeration\n * failure. The whole `cause` chain is searched, so WebdriverIO's wrapping of the\n * server's error does not hide it.\n *\n * @param error - The error the session attempt failed with.\n * @returns `true` when it is the device-not-found failure.\n */\nexport function checkIsAppiumDeviceNotFoundError(error: unknown): boolean {\n  return errorToString(error).includes(DEVICE_NOT_FOUND_MESSAGE_FRAGMENT);\n}\n\n/**\n * Checks whether an Appium `/status` body reports a server that is accepting new\n * sessions.\n *\n * Deliberately **tolerant**: only an explicit `ready: false` (Appium sets it\n * while shutting down) is treated as not-ready. A body that cannot be parsed, or\n * that omits the flag, reads as ready \u2014 an unrecognized shape must not make a\n * healthy server look unreachable.\n *\n * This does not catch the wedge (a wedged server still answers `ready: true`);\n * it closes the adjacent hole of adopting a server that is on its way down.\n *\n * @param statusBody - The raw `/status` response body.\n * @returns `false` only when the server explicitly reports itself not ready.\n */\nexport function checkIsAppiumStatusReady(statusBody: string): boolean {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(statusBody);\n  } catch {\n    return true;\n  }\n\n  return readReadyFlag(parsed) !== false;\n}\n\n/**\n * Decides what to do with a failed session attempt.\n *\n * The device-not-found error is only evidence against the server when the host's\n * adb *can* still see the device; otherwise the error was honest and is left\n * alone. A server this harness started in an earlier run is restarted (the\n * confirmed remedy); every other wedged server is reported rather than killed,\n * because terminating a process this run does not own is not its call to make.\n *\n * @param params - The failed attempt and what is known about the server.\n * @returns The verdict.\n */\nexport function resolveWedgedAppiumServerRemedy(params: ResolveWedgedAppiumServerRemedyParams): WedgedAppiumServerVerdict {\n  if (!checkIsAppiumDeviceNotFoundError(params.error)) {\n    return { reason: 'other-error', remedy: 'not-wedged' };\n  }\n\n  if (!params.connectedDeviceIds.includes(params.deviceId)) {\n    return { reason: 'device-absent', remedy: 'not-wedged' };\n  }\n\n  if (!params.isAdoptedServer) {\n    return { reason: 'freshly-started', remedy: 'report' };\n  }\n\n  if (!params.isAutoStartAllowed) {\n    return { reason: 'auto-start-disabled', remedy: 'report' };\n  }\n\n  if (!params.isHarnessOwnedServer) {\n    return { reason: 'foreign-server', remedy: 'report' };\n  }\n\n  return { reason: 'harness-owned', remedy: 'restart' };\n}\n\nfunction describeServer(params: BuildWedgedAppiumServerMessageParams): string {\n  if (params.serverPid === undefined) {\n    return '';\n  }\n\n  const age = params.serverAgeInMilliseconds === undefined ? '' : `, running for ${formatAge(params.serverAgeInMilliseconds)}`;\n  return `The server was started by an earlier obsidian-integration-testing run (pid ${String(params.serverPid)}${age}).`;\n}\n\nfunction formatAge(ageInMilliseconds: number): string {\n  if (ageInMilliseconds < MILLISECONDS_PER_MINUTE) {\n    return `${String(Math.round(ageInMilliseconds / MILLISECONDS_PER_SECOND))}s`;\n  }\n\n  return `${String(Math.round(ageInMilliseconds / MILLISECONDS_PER_MINUTE))}min`;\n}\n\nfunction readReadyFlag(parsed: unknown): boolean | undefined {\n  if (typeof parsed !== 'object' || parsed === null) {\n    return undefined;\n  }\n\n  const record = parsed as Record<string, unknown>;\n  const value = record['value'];\n  const nested = typeof value === 'object' && value !== null ? (value as Record<string, unknown>)['ready'] : undefined;\n  const ready = nested ?? record['ready'];\n  return typeof ready === 'boolean' ? ready : undefined;\n}\n\nfunction resolveRemedyAdvice(params: BuildWedgedAppiumServerMessageParams): string {\n  const advice: Record<WedgedAppiumServerReportReason, string> = {\n    'auto-start-disabled': `Appium auto-start is disabled (\\`shouldAutoStartAppium: false\\`), so this server is yours to manage: kill it and start a fresh one on ${params.appiumOrigin}, then re-run.`,\n    'foreign-server': `This server was not started by obsidian-integration-testing, so it was left running: kill it and start a fresh one on ${params.appiumOrigin}, then re-run.`,\n    'freshly-started': 'This server was started by this run, so restarting it would change nothing: check that adb and the emulator agree (`adb kill-server && adb devices`), then re-run.',\n    'restart-did-not-help': `Restarting the server on ${params.appiumOrigin} did not help \u2014 a fresh one still could not serve this run, so the wedge is not the server alone: check adb itself (\\`adb kill-server && adb devices\\`) and that nothing else holds the port, then re-run.`\n  };\n\n  return advice[params.reason];\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAuBA,6BAA8B;AAQ9B,MAAM,oCAAoC;AAE1C,MAAM,0BAA0B;AAChC,MAAM,qBAAqB;AAC3B,MAAM,0BAA0B,0BAA0B;AAyJnD,SAAS,+BAA+B,QAAsD;AACnG,QAAM,QAAQ;AAAA,IACZ,wBAAwB,OAAO,YAAY,8BAA8B,OAAO,QAAQ;AAAA,IACxF;AAAA,IACA,oBAAoB,MAAM;AAAA,EAC5B;AAEA,QAAM,aAAa,eAAe,MAAM;AACxC,MAAI,YAAY;AACd,UAAM,KAAK,UAAU;AAAA,EACvB;AAEA,SAAO,MAAM,KAAK,IAAI;AACxB;AAUO,SAAS,iCAAiC,OAAyB;AACxE,aAAO,sCAAc,KAAK,EAAE,SAAS,iCAAiC;AACxE;AAiBO,SAAS,yBAAyB,YAA6B;AACpE,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,MAAM,UAAU;AAAA,EAChC,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,SAAO,cAAc,MAAM,MAAM;AACnC;AAcO,SAAS,gCAAgC,QAA0E;AACxH,MAAI,CAAC,iCAAiC,OAAO,KAAK,GAAG;AACnD,WAAO,EAAE,QAAQ,eAAe,QAAQ,aAAa;AAAA,EACvD;AAEA,MAAI,CAAC,OAAO,mBAAmB,SAAS,OAAO,QAAQ,GAAG;AACxD,WAAO,EAAE,QAAQ,iBAAiB,QAAQ,aAAa;AAAA,EACzD;AAEA,MAAI,CAAC,OAAO,iBAAiB;AAC3B,WAAO,EAAE,QAAQ,mBAAmB,QAAQ,SAAS;AAAA,EACvD;AAEA,MAAI,CAAC,OAAO,oBAAoB;AAC9B,WAAO,EAAE,QAAQ,uBAAuB,QAAQ,SAAS;AAAA,EAC3D;AAEA,MAAI,CAAC,OAAO,sBAAsB;AAChC,WAAO,EAAE,QAAQ,kBAAkB,QAAQ,SAAS;AAAA,EACtD;AAEA,SAAO,EAAE,QAAQ,iBAAiB,QAAQ,UAAU;AACtD;AAEA,SAAS,eAAe,QAAsD;AAC5E,MAAI,OAAO,cAAc,QAAW;AAClC,WAAO;AAAA,EACT;AAEA,QAAM,MAAM,OAAO,4BAA4B,SAAY,KAAK,iBAAiB,UAAU,OAAO,uBAAuB,CAAC;AAC1H,SAAO,8EAA8E,OAAO,OAAO,SAAS,CAAC,GAAG,GAAG;AACrH;AAEA,SAAS,UAAU,mBAAmC;AACpD,MAAI,oBAAoB,yBAAyB;AAC/C,WAAO,GAAG,OAAO,KAAK,MAAM,oBAAoB,uBAAuB,CAAC,CAAC;AAAA,EAC3E;AAEA,SAAO,GAAG,OAAO,KAAK,MAAM,oBAAoB,uBAAuB,CAAC,CAAC;AAC3E;AAEA,SAAS,cAAc,QAAsC;AAC3D,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AACjD,WAAO;AAAA,EACT;AAEA,QAAM,SAAS;AACf,QAAM,QAAQ,OAAO,OAAO;AAC5B,QAAM,SAAS,OAAO,UAAU,YAAY,UAAU,OAAQ,MAAkC,OAAO,IAAI;AAC3G,QAAM,QAAQ,UAAU,OAAO,OAAO;AACtC,SAAO,OAAO,UAAU,YAAY,QAAQ;AAC9C;AAEA,SAAS,oBAAoB,QAAsD;AACjF,QAAM,SAAyD;AAAA,IAC7D,uBAAuB,yIAAyI,OAAO,YAAY;AAAA,IACnL,kBAAkB,yHAAyH,OAAO,YAAY;AAAA,IAC9J,mBAAmB;AAAA,IACnB,wBAAwB,4BAA4B,OAAO,YAAY;AAAA,EACzE;AAEA,SAAO,OAAO,OAAO,MAAM;AAC7B;",
  "names": []
}


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

@@ -0,0 +1,187 @@
+/**
+ * @file
+ *
+ * Pure helpers for recognizing a **wedged** Appium server and deciding what to
+ * do about it. Kept separate from the integration-only `transport-factory` so
+ * the classification, the remedy decision and the message stay unit-testable
+ * (the factory itself needs a real device and is excluded from unit tests).
+ *
+ * A wedged server is one that is still **live** — it listens on its port and
+ * answers `/status` with `ready: true` — but is no longer **usable**: its
+ * `appium-adb` can no longer enumerate devices, so every session creation dies
+ * with `Could not find a connected Android device in <n>ms` while the host's own
+ * `adb devices` lists the device instantly. Liveness is not readiness, and the
+ * error names the wrong subject: it blames a device that is demonstrably
+ * present, which sends whoever reads it to `adb devices` — the one diagnostic
+ * that actively misleads here.
+ *
+ * The wedge develops over time in a long-lived server (one auto-started by an
+ * earlier run and left listening), so the preflight cannot see it coming: it can
+ * only be recognized from the failed session, cross-checked against the host's
+ * adb.
+ */
+/**
+ * Parameters for {@link buildWedgedAppiumServerMessage}.
+ */
+export interface BuildWedgedAppiumServerMessageParams {
+    /**
+    Origin of the Appium server that could not see the device (e.g. `http://localhost:4723`).
+     */
+    readonly appiumOrigin: string;
+    /**
+    The device the host's adb can see but Appium cannot.
+     */
+    readonly deviceId: string;
+    /**
+    Why this run is reporting rather than restarting.
+     */
+    readonly reason: WedgedAppiumServerReportReason;
+    /**
+    How long the server has been running, when known from its marker.
+     */
+    readonly serverAgeInMilliseconds?: number | undefined;
+    /**
+    PID of the server, when known from its marker.
+     */
+    readonly serverPid?: number | undefined;
+}
+/**
+ * The server is not to blame: either the failure was a different error, or the
+ * host's adb cannot see the device either. The original error is rethrown.
+ */
+export interface NotWedgedVerdict {
+    /**
+    Which of the two honest-failure cases this is.
+     */
+    readonly reason: 'device-absent' | 'other-error';
+    /**
+    Discriminant.
+     */
+    readonly remedy: 'not-wedged';
+}
+/**
+ * The server is wedged but must not be touched by this run.
+ */
+export interface ReportServerVerdict {
+    /**
+    Why this run is reporting rather than restarting.
+     */
+    readonly reason: WedgedAppiumServerReportReason;
+    /**
+    Discriminant.
+     */
+    readonly remedy: 'report';
+}
+/**
+ * Parameters for {@link resolveWedgedAppiumServerRemedy}.
+ */
+export interface ResolveWedgedAppiumServerRemedyParams {
+    /**
+    Device IDs the **host's** adb currently lists (the cross-check that convicts the server).
+     */
+    readonly connectedDeviceIds: readonly string[];
+    /**
+    The device the session was requested against.
+     */
+    readonly deviceId: string;
+    /**
+    The error the session attempt failed with.
+     */
+    readonly error: unknown;
+    /**
+    Whether the server was already listening and was adopted, rather than started by this run.
+     */
+    readonly isAdoptedServer: boolean;
+    /**
+    Whether this run may start an Appium server (`shouldAutoStartAppium` is not `false`).
+     */
+    readonly isAutoStartAllowed: boolean;
+    /**
+    Whether the adopted server's marker proves an earlier run of this harness started it.
+     */
+    readonly isHarnessOwnedServer: boolean;
+}
+/**
+ * The server is wedged and an earlier run of this harness started it, so this
+ * run may replace it.
+ */
+export interface RestartServerVerdict {
+    /**
+    Always the harness-owned case.
+     */
+    readonly reason: 'harness-owned';
+    /**
+    Discriminant.
+     */
+    readonly remedy: 'restart';
+}
+/**
+ * The classification of a failed session attempt.
+ *
+ * `'device-absent'` and `'other-error'` are the not-wedged verdicts: the
+ * original error was honest and is rethrown untouched.
+ */
+export type WedgedAppiumServerReason = 'device-absent' | 'harness-owned' | 'other-error' | WedgedAppiumServerReportReason;
+/**
+ * What the factory should do with a failed session attempt.
+ */
+export type WedgedAppiumServerRemedy = 'not-wedged' | 'report' | 'restart';
+/**
+ * Why a wedged server is only reported rather than restarted. Each maps to its
+ * own remedy sentence — the whole point of the rewrite is that the message says
+ * what *this* run can and cannot do about the server it found.
+ */
+export type WedgedAppiumServerReportReason = 'auto-start-disabled' | 'foreign-server' | 'freshly-started' | 'restart-did-not-help';
+/**
+ * The verdict on a failed session attempt, discriminated by `remedy` so a
+ * `'report'` verdict carries a reason {@link buildWedgedAppiumServerMessage} can
+ * turn into advice.
+ */
+export type WedgedAppiumServerVerdict = NotWedgedVerdict | ReportServerVerdict | RestartServerVerdict;
+/**
+ * Builds the error message that replaces `Could not find a connected Android
+ * device`, naming the **server** and stating the evidence — the host's adb can
+ * see the device, so the server is the thing that is stale.
+ *
+ * @param params - The server, the device, and why this run is not restarting it.
+ * @returns The message.
+ */
+export declare function buildWedgedAppiumServerMessage(params: BuildWedgedAppiumServerMessageParams): string;
+/**
+ * Checks whether a failed session attempt is `appium-adb`'s device-enumeration
+ * failure. The whole `cause` chain is searched, so WebdriverIO's wrapping of the
+ * server's error does not hide it.
+ *
+ * @param error - The error the session attempt failed with.
+ * @returns `true` when it is the device-not-found failure.
+ */
+export declare function checkIsAppiumDeviceNotFoundError(error: unknown): boolean;
+/**
+ * Checks whether an Appium `/status` body reports a server that is accepting new
+ * sessions.
+ *
+ * Deliberately **tolerant**: only an explicit `ready: false` (Appium sets it
+ * while shutting down) is treated as not-ready. A body that cannot be parsed, or
+ * that omits the flag, reads as ready — an unrecognized shape must not make a
+ * healthy server look unreachable.
+ *
+ * This does not catch the wedge (a wedged server still answers `ready: true`);
+ * it closes the adjacent hole of adopting a server that is on its way down.
+ *
+ * @param statusBody - The raw `/status` response body.
+ * @returns `false` only when the server explicitly reports itself not ready.
+ */
+export declare function checkIsAppiumStatusReady(statusBody: string): boolean;
+/**
+ * Decides what to do with a failed session attempt.
+ *
+ * The device-not-found error is only evidence against the server when the host's
+ * adb *can* still see the device; otherwise the error was honest and is left
+ * alone. A server this harness started in an earlier run is restarted (the
+ * confirmed remedy); every other wedged server is reported rather than killed,
+ * because terminating a process this run does not own is not its call to make.
+ *
+ * @param params - The failed attempt and what is known about the server.
+ * @returns The verdict.
+ */
+export declare function resolveWedgedAppiumServerRemedy(params: ResolveWedgedAppiumServerRemedyParams): WedgedAppiumServerVerdict;

package/dist/lib/esm/appium-server-marker.d.mts

@@ -0,0 +1,81 @@
+/**
+ * @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;
+}
+/**
+ * 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 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/esm/appium-server-marker.mjs

@@ -0,0 +1,83 @@
+import {
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { log } from "./log.mjs";
+const MARKER_DIR_NAME = "obsidian-integration-testing";
+const MARKER_FILE_SUFFIX = ".appium-server.json";
+const PROCESS_EXISTENCE_PROBE_SIGNAL = 0;
+function checkIsHarnessOwnedAppiumServer(marker) {
+  if (!marker) {
+    return false;
+  }
+  try {
+    process.kill(marker.pid, PROCESS_EXISTENCE_PROBE_SIGNAL);
+    return true;
+  } catch (error) {
+    return getErrorCode(error) === "EPERM";
+  }
+}
+function clearAppiumServerMarker(port) {
+  try {
+    rmSync(getMarkerFilePath(port), { force: true });
+  } catch (error) {
+    log(`[appium-server-marker] Could not remove the marker for port ${String(port)}: ${getErrorMessage(error)}`);
+  }
+}
+function readAppiumServerMarker(port) {
+  let parsed;
+  try {
+    parsed = JSON.parse(readFileSync(getMarkerFilePath(port), "utf-8"));
+  } catch {
+    return void 0;
+  }
+  return parseMarker(parsed, port);
+}
+function writeAppiumServerMarker(params) {
+  const marker = {
+    pid: params.pid,
+    port: params.port,
+    startedAtInMilliseconds: Date.now()
+  };
+  try {
+    mkdirSync(getMarkerDirectory(), { recursive: true });
+    writeFileSync(getMarkerFilePath(params.port), JSON.stringify(marker));
+  } catch (error) {
+    log(`[appium-server-marker] Could not record the server on port ${String(params.port)}: ${getErrorMessage(error)}`);
+  }
+}
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function getMarkerDirectory() {
+  return join(tmpdir(), MARKER_DIR_NAME);
+}
+function getMarkerFilePath(port) {
+  return join(getMarkerDirectory(), `${String(port)}${MARKER_FILE_SUFFIX}`);
+}
+function parseMarker(parsed, port) {
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const record = parsed;
+  const { pid, port: markedPort, startedAtInMilliseconds } = record;
+  if (typeof pid !== "number" || typeof startedAtInMilliseconds !== "number" || markedPort !== port) {
+    return void 0;
+  }
+  return { pid, port, startedAtInMilliseconds };
+}
+export {
+  checkIsHarnessOwnedAppiumServer,
+  clearAppiumServerMarker,
+  readAppiumServerMarker,
+  writeAppiumServerMarker
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/appium-server-marker.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Records which Appium server on a port this harness started, so a later run\n * that finds a server already listening can tell **provenance**: one of our own\n * servers left over from an earlier run, or a foreign one the user manages.\n *\n * The preflight adopts any server that answers `/status`, and adoption is the\n * right default \u2014 starting a second server on an occupied port cannot work. But\n * adopting silently means a wedged leftover (see `wedged-appium-server.ts`) is\n * indistinguishable from a healthy server, and the harness has no basis on which\n * to decide whether restarting it is its call to make. The marker supplies that\n * basis: a server we started may be restarted, a foreign one is only ever\n * reported.\n *\n * The marker is a small JSON sentinel next to the setup lock (`setup-lock.ts`),\n * keyed by port, and is deliberately tolerant \u2014 a missing, unreadable, or\n * mismatched marker simply reads as \"not ours\".\n */\n\nimport {\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport { log } from './log.mjs';\n\nconst MARKER_DIR_NAME = 'obsidian-integration-testing';\nconst MARKER_FILE_SUFFIX = '.appium-server.json';\nconst PROCESS_EXISTENCE_PROBE_SIGNAL = 0;\n\n/**\n * Identifies the Appium server this harness started on a port.\n */\nexport interface AppiumServerMarker {\n  /**\n  PID of the spawned server process (the shell wrapper that owns the server's process tree).\n   */\n  readonly pid: number;\n\n  /**\n  The port the server was started on.\n   */\n  readonly port: number;\n\n  /**\n  When the server was started (`Date.now()` epoch milliseconds).\n   */\n  readonly startedAtInMilliseconds: number;\n}\n\n/**\n * Parameters for {@link writeAppiumServerMarker}.\n */\nexport interface WriteAppiumServerMarkerParams {\n  /**\n  PID of the spawned server process.\n   */\n  readonly pid: number;\n\n  /**\n  The port the server was started on.\n   */\n  readonly port: number;\n}\n\n/**\n * Checks whether the marked server is still running, which is what makes an\n * adopted server ours to restart.\n *\n * A dead PID means the marker outlived its server, so whatever answers on that\n * port now is somebody else's \u2014 the marker proves nothing about it.\n *\n * @param marker - The marker read for the port, or `undefined` when there is none.\n * @returns `true` when an earlier run of this harness started the server now listening.\n */\nexport function checkIsHarnessOwnedAppiumServer(marker: AppiumServerMarker | undefined): boolean {\n  if (!marker) {\n    return false;\n  }\n\n  try {\n    process.kill(marker.pid, PROCESS_EXISTENCE_PROBE_SIGNAL);\n    return true;\n  } catch (error: unknown) {\n    // `EPERM` means the process exists but is owned by another user \u2014 still alive.\n    return getErrorCode(error) === 'EPERM';\n  }\n}\n\n/**\n * Removes the marker for a port. Called once the marked server has been stopped,\n * so a later run does not mistake a recycled PID for our server.\n *\n * @param port - The Appium server port.\n */\nexport function clearAppiumServerMarker(port: number): void {\n  try {\n    rmSync(getMarkerFilePath(port), { force: true });\n  } catch (error: unknown) {\n    log(`[appium-server-marker] Could not remove the marker for port ${String(port)}: ${getErrorMessage(error)}`);\n  }\n}\n\n/**\n * Reads the marker for a port.\n *\n * @param port - The Appium server port.\n * @returns The marker, or `undefined` when there is none, it is unreadable, or it does not describe this port.\n */\nexport function readAppiumServerMarker(port: number): AppiumServerMarker | undefined {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(readFileSync(getMarkerFilePath(port), 'utf-8'));\n  } catch {\n    return undefined;\n  }\n\n  return parseMarker(parsed, port);\n}\n\n/**\n * Records the server this run just started, stamping it with the current time so\n * a later run can report how long it has been up.\n *\n * @param params - The started server's PID and port.\n */\nexport function writeAppiumServerMarker(params: WriteAppiumServerMarkerParams): void {\n  const marker: AppiumServerMarker = {\n    pid: params.pid,\n    port: params.port,\n    startedAtInMilliseconds: Date.now()\n  };\n\n  try {\n    mkdirSync(getMarkerDirectory(), { recursive: true });\n    writeFileSync(getMarkerFilePath(params.port), JSON.stringify(marker));\n  } catch (error: unknown) {\n    log(`[appium-server-marker] Could not record the server on port ${String(params.port)}: ${getErrorMessage(error)}`);\n  }\n}\n\nfunction getErrorCode(error: unknown): string | undefined {\n  return typeof error === 'object' && error !== null && 'code' in error ? String(error.code) : undefined;\n}\n\nfunction getErrorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction getMarkerDirectory(): string {\n  return join(tmpdir(), MARKER_DIR_NAME);\n}\n\nfunction getMarkerFilePath(port: number): string {\n  return join(getMarkerDirectory(), `${String(port)}${MARKER_FILE_SUFFIX}`);\n}\n\nfunction parseMarker(parsed: unknown, port: number): AppiumServerMarker | undefined {\n  if (typeof parsed !== 'object' || parsed === null) {\n    return undefined;\n  }\n\n  const record = parsed as Record<string, unknown>;\n  const { pid, port: markedPort, startedAtInMilliseconds } = record;\n\n  if (typeof pid !== 'number' || typeof startedAtInMilliseconds !== 'number' || markedPort !== port) {\n    return undefined;\n  }\n\n  return { pid, port, startedAtInMilliseconds };\n}\n"],
  "mappings": "AAoBA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OACK;AACP,SAAS,cAAc;AACvB,SAAS,YAAY;AACrB,OAAO,aAAa;AAEpB,SAAS,WAAW;AAEpB,MAAM,kBAAkB;AACxB,MAAM,qBAAqB;AAC3B,MAAM,iCAAiC;AA+ChC,SAAS,gCAAgC,QAAiD;AAC/F,MAAI,CAAC,QAAQ;AACX,WAAO;AAAA,EACT;AAEA,MAAI;AACF,YAAQ,KAAK,OAAO,KAAK,8BAA8B;AACvD,WAAO;AAAA,EACT,SAAS,OAAgB;AAEvB,WAAO,aAAa,KAAK,MAAM;AAAA,EACjC;AACF;AAQO,SAAS,wBAAwB,MAAoB;AAC1D,MAAI;AACF,WAAO,kBAAkB,IAAI,GAAG,EAAE,OAAO,KAAK,CAAC;AAAA,EACjD,SAAS,OAAgB;AACvB,QAAI,+DAA+D,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EAC9G;AACF;AAQO,SAAS,uBAAuB,MAA8C;AACnF,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,MAAM,aAAa,kBAAkB,IAAI,GAAG,OAAO,CAAC;AAAA,EACpE,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,QAAQ,IAAI;AACjC;AAQO,SAAS,wBAAwB,QAA6C;AACnF,QAAM,SAA6B;AAAA,IACjC,KAAK,OAAO;AAAA,IACZ,MAAM,OAAO;AAAA,IACb,yBAAyB,KAAK,IAAI;AAAA,EACpC;AAEA,MAAI;AACF,cAAU,mBAAmB,GAAG,EAAE,WAAW,KAAK,CAAC;AACnD,kBAAc,kBAAkB,OAAO,IAAI,GAAG,KAAK,UAAU,MAAM,CAAC;AAAA,EACtE,SAAS,OAAgB;AACvB,QAAI,8DAA8D,OAAO,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EACpH;AACF;AAEA,SAAS,aAAa,OAAoC;AACxD,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU,QAAQ,OAAO,MAAM,IAAI,IAAI;AAC/F;AAEA,SAAS,gBAAgB,OAAwB;AAC/C,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAEA,SAAS,qBAA6B;AACpC,SAAO,KAAK,OAAO,GAAG,eAAe;AACvC;AAEA,SAAS,kBAAkB,MAAsB;AAC/C,SAAO,KAAK,mBAAmB,GAAG,GAAG,OAAO,IAAI,CAAC,GAAG,kBAAkB,EAAE;AAC1E;AAEA,SAAS,YAAY,QAAiB,MAA8C;AAClF,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AACjD,WAAO;AAAA,EACT;AAEA,QAAM,SAAS;AACf,QAAM,EAAE,KAAK,MAAM,YAAY,wBAAwB,IAAI;AAE3D,MAAI,OAAO,QAAQ,YAAY,OAAO,4BAA4B,YAAY,eAAe,MAAM;AACjG,WAAO;AAAA,EACT;AAEA,SAAO,EAAE,KAAK,MAAM,wBAAwB;AAC9C;",
  "names": []
}


package/dist/lib/esm/cli.d.mts

@@ -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>;