obsidian-integration-testing 8.2.0 → 8.3.0

package/dist/lib/esm/installer-compatibility.mjs

@@ -37,4 +37,4 @@ function checkInstallerCompatibility(params) {
 export {
   checkInstallerCompatibility
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-compatibility.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure verdict on whether a resolved (Obsidian app, installer) version pair is\n * compatible, computed offline from the `metadata.json` thresholds. Kept separate\n * from the integration-only `transport-factory` (which drives real\n * downloads/launches and is excluded from unit tests) so the tier logic stays\n * unit-testable \u2014 mirroring the `renderer-boot-detection` split.\n *\n * Two thresholds drive the verdict, both installer versions directly comparable\n * to the resolved installer/shell version:\n *\n * - `minRunnableInstallerVersion` \u2014 the run floor. Below it the app cannot boot\n *   (`'unrunnable'`); the caller turns this into a proactive\n *   `IncompatibleInstallerVersionError` before any download/launch.\n * - `minRecommendedInstallerVersion` \u2014 the recommended floor (older versions\n *   only). At/above the run floor but below this, the app runs but is below\n *   Obsidian's recommendation (`'nagged'`), surfaced as a warning.\n *\n * When the installer version is unknown (e.g. an undetectable Linux shell) or the\n * app version is absent from the table, the verdict is `'unknown'` and nothing is\n * thrown or warned \u2014 the reactive dead-boot fast-fail remains the safety net.\n */\n\nimport type { ObsidianVersionMetadata } from './obsidian-metadata.mjs';\n\nimport { compareVersions } from './obsidian-version.mjs';\n\n/**\n * Parameters for {@link checkInstallerCompatibility}.\n */\nexport interface CheckInstallerCompatibilityParams {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `undefined` when unknown. */\n  readonly installerVersion: string | undefined;\n\n  /** The `metadata.json` entry for {@link appVersion}, or `undefined` when absent. */\n  readonly metadata: ObsidianVersionMetadata | undefined;\n}\n\n/**\n * The compatibility verdict for a resolved (app, installer) version pair, carried\n * as data on the transport / connection result so consumers can assert on it.\n */\nexport interface InstallerCompatibility {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `null` when unknown. */\n  readonly installerVersion: null | string;\n\n  /** A human-readable explanation, present for the `'nagged'` tier. */\n  readonly message?: string;\n\n  /** The recommended installer floor, when the table carries one. */\n  readonly minRecommendedInstallerVersion?: string;\n\n  /** The run floor, when the table carries one. */\n  readonly minRunnableInstallerVersion?: string;\n\n  /** The resolved compatibility tier. */\n  readonly tier: InstallerCompatibilityTier;\n}\n\n/**\n * The compatibility tier of a resolved (app, installer) version pair.\n *\n * - `'ok'` \u2014 the installer is at or above the recommended floor (or no\n *   recommended floor is known); runs with full compatibility.\n * - `'nagged'` \u2014 at/above the run floor but below the recommended floor; runs but\n *   Obsidian would show its \"installer too old\" recommendation.\n * - `'unrunnable'` \u2014 below the run floor; the app cannot boot on this installer.\n * - `'unknown'` \u2014 cannot be determined (installer version unknown, or the app\n *   version is absent from the table).\n */\nexport type InstallerCompatibilityTier = 'nagged' | 'ok' | 'unknown' | 'unrunnable';\n\n/**\n * Computes the compatibility verdict for a resolved (app, installer) version pair.\n *\n * Only `'unrunnable'` warrants an error; `'nagged'` warrants a warning; `'ok'` and\n * `'unknown'` are silent. Comparisons are pure `x.y.z` version compares \u2014 no I/O.\n *\n * @param params - The resolved versions and the app version's metadata entry.\n * @returns The compatibility verdict.\n */\nexport function checkInstallerCompatibility(params: CheckInstallerCompatibilityParams): InstallerCompatibility {\n  const { appVersion, installerVersion, metadata } = params;\n  const minRunnableInstallerVersion = metadata?.minRunnableInstallerVersion;\n  const minRecommendedInstallerVersion = metadata?.minRecommendedInstallerVersion;\n\n  if (installerVersion === undefined || minRunnableInstallerVersion === undefined) {\n    return { appVersion, installerVersion: installerVersion ?? null, tier: 'unknown' };\n  }\n\n  const recommendedFloor = minRecommendedInstallerVersion !== undefined && { minRecommendedInstallerVersion };\n\n  if (compareVersions(installerVersion, minRunnableInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      minRunnableInstallerVersion,\n      tier: 'unrunnable',\n      ...recommendedFloor\n    };\n  }\n\n  if (minRecommendedInstallerVersion !== undefined && compareVersions(installerVersion, minRecommendedInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      message: `Obsidian installer ${installerVersion} runs Obsidian ${appVersion} but is older than the `\n        + `recommended installer ${minRecommendedInstallerVersion}; update the installer for full compatibility.`,\n      minRecommendedInstallerVersion,\n      minRunnableInstallerVersion,\n      tier: 'nagged'\n    };\n  }\n\n  return {\n    appVersion,\n    installerVersion,\n    minRunnableInstallerVersion,\n    tier: 'ok',\n    ...recommendedFloor\n  };\n}\n"],
  "mappings": "AA0BA,SAAS,uBAAuB;AA8DzB,SAAS,4BAA4B,QAAmE;AAC7G,QAAM,EAAE,YAAY,kBAAkB,SAAS,IAAI;AACnD,QAAM,8BAA8B,UAAU;AAC9C,QAAM,iCAAiC,UAAU;AAEjD,MAAI,qBAAqB,UAAa,gCAAgC,QAAW;AAC/E,WAAO,EAAE,YAAY,kBAAkB,oBAAoB,MAAM,MAAM,UAAU;AAAA,EACnF;AAEA,QAAM,mBAAmB,mCAAmC,UAAa,EAAE,+BAA+B;AAE1G,MAAI,gBAAgB,kBAAkB,2BAA2B,IAAI,GAAG;AACtE,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA,MAAM;AAAA,MACN,GAAG;AAAA,IACL;AAAA,EACF;AAEA,MAAI,mCAAmC,UAAa,gBAAgB,kBAAkB,8BAA8B,IAAI,GAAG;AACzH,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,SAAS,sBAAsB,gBAAgB,kBAAkB,UAAU,gDAC9C,8BAA8B;AAAA,MAC3D;AAAA,MACA;AAAA,MACA,MAAM;AAAA,IACR;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN,GAAG;AAAA,EACL;AACF;",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/installer-compatibility.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Pure verdict on whether a resolved (Obsidian app, installer) version pair is\n * compatible, computed offline from the `metadata.json` thresholds. Kept separate\n * from the integration-only `transport-factory` (which drives real\n * downloads/launches and is excluded from unit tests) so the tier logic stays\n * unit-testable \u2014 mirroring the `renderer-boot-detection` split.\n *\n * Two thresholds drive the verdict, both installer versions directly comparable\n * to the resolved installer/shell version:\n *\n * - `minRunnableInstallerVersion` \u2014 the run floor. Below it the app cannot boot\n *   (`'unrunnable'`); the caller turns this into a proactive\n *   `IncompatibleInstallerVersionError` before any download/launch \u2014 unless the\n *   caller has disabled the proactive throw (`shouldThrowOnIncompatibleInstaller`\n *   `false`), in which case the boot proceeds and the reactive dead-boot fast-fail\n *   catches it.\n * - `minRecommendedInstallerVersion` \u2014 the recommended floor (older versions\n *   only). At/above the run floor but below this, the app runs but is below\n *   Obsidian's recommendation (`'nagged'`), surfaced as a warning.\n *\n * When the installer version is unknown (e.g. an undetectable Linux shell) or the\n * app version is absent from the table, the verdict is `'unknown'` and nothing is\n * thrown or warned \u2014 the reactive dead-boot fast-fail remains the safety net.\n */\n\nimport type { ObsidianVersionMetadata } from './obsidian-metadata.mjs';\n\nimport { compareVersions } from './obsidian-version.mjs';\n\n/**\n * Parameters for {@link checkInstallerCompatibility}.\n */\nexport interface CheckInstallerCompatibilityParams {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `undefined` when unknown. */\n  readonly installerVersion: string | undefined;\n\n  /** The `metadata.json` entry for {@link appVersion}, or `undefined` when absent. */\n  readonly metadata: ObsidianVersionMetadata | undefined;\n}\n\n/**\n * The compatibility verdict for a resolved (app, installer) version pair, carried\n * as data on the transport / connection result so consumers can assert on it.\n */\nexport interface InstallerCompatibility {\n  /** The resolved Obsidian app (asar) version. */\n  readonly appVersion: string;\n\n  /** The resolved installer/Electron shell version, or `null` when unknown. */\n  readonly installerVersion: null | string;\n\n  /** A human-readable explanation, present for the `'nagged'` tier. */\n  readonly message?: string;\n\n  /** The recommended installer floor, when the table carries one. */\n  readonly minRecommendedInstallerVersion?: string;\n\n  /** The run floor, when the table carries one. */\n  readonly minRunnableInstallerVersion?: string;\n\n  /** The resolved compatibility tier. */\n  readonly tier: InstallerCompatibilityTier;\n}\n\n/**\n * The compatibility tier of a resolved (app, installer) version pair.\n *\n * - `'ok'` \u2014 the installer is at or above the recommended floor (or no\n *   recommended floor is known); runs with full compatibility.\n * - `'nagged'` \u2014 at/above the run floor but below the recommended floor; runs but\n *   Obsidian would show its \"installer too old\" recommendation.\n * - `'unrunnable'` \u2014 below the run floor; the app cannot boot on this installer.\n * - `'unknown'` \u2014 cannot be determined (installer version unknown, or the app\n *   version is absent from the table).\n */\nexport type InstallerCompatibilityTier = 'nagged' | 'ok' | 'unknown' | 'unrunnable';\n\n/**\n * Computes the compatibility verdict for a resolved (app, installer) version pair.\n *\n * Only `'unrunnable'` warrants an error; `'nagged'` warrants a warning; `'ok'` and\n * `'unknown'` are silent. Comparisons are pure `x.y.z` version compares \u2014 no I/O.\n *\n * @param params - The resolved versions and the app version's metadata entry.\n * @returns The compatibility verdict.\n */\nexport function checkInstallerCompatibility(params: CheckInstallerCompatibilityParams): InstallerCompatibility {\n  const { appVersion, installerVersion, metadata } = params;\n  const minRunnableInstallerVersion = metadata?.minRunnableInstallerVersion;\n  const minRecommendedInstallerVersion = metadata?.minRecommendedInstallerVersion;\n\n  if (installerVersion === undefined || minRunnableInstallerVersion === undefined) {\n    return { appVersion, installerVersion: installerVersion ?? null, tier: 'unknown' };\n  }\n\n  const recommendedFloor = minRecommendedInstallerVersion !== undefined && { minRecommendedInstallerVersion };\n\n  if (compareVersions(installerVersion, minRunnableInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      minRunnableInstallerVersion,\n      tier: 'unrunnable',\n      ...recommendedFloor\n    };\n  }\n\n  if (minRecommendedInstallerVersion !== undefined && compareVersions(installerVersion, minRecommendedInstallerVersion) < 0) {\n    return {\n      appVersion,\n      installerVersion,\n      message: `Obsidian installer ${installerVersion} runs Obsidian ${appVersion} but is older than the `\n        + `recommended installer ${minRecommendedInstallerVersion}; update the installer for full compatibility.`,\n      minRecommendedInstallerVersion,\n      minRunnableInstallerVersion,\n      tier: 'nagged'\n    };\n  }\n\n  return {\n    appVersion,\n    installerVersion,\n    minRunnableInstallerVersion,\n    tier: 'ok',\n    ...recommendedFloor\n  };\n}\n"],
  "mappings": "AA6BA,SAAS,uBAAuB;AA8DzB,SAAS,4BAA4B,QAAmE;AAC7G,QAAM,EAAE,YAAY,kBAAkB,SAAS,IAAI;AACnD,QAAM,8BAA8B,UAAU;AAC9C,QAAM,iCAAiC,UAAU;AAEjD,MAAI,qBAAqB,UAAa,gCAAgC,QAAW;AAC/E,WAAO,EAAE,YAAY,kBAAkB,oBAAoB,MAAM,MAAM,UAAU;AAAA,EACnF;AAEA,QAAM,mBAAmB,mCAAmC,UAAa,EAAE,+BAA+B;AAE1G,MAAI,gBAAgB,kBAAkB,2BAA2B,IAAI,GAAG;AACtE,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA;AAAA,MACA,MAAM;AAAA,MACN,GAAG;AAAA,IACL;AAAA,EACF;AAEA,MAAI,mCAAmC,UAAa,gBAAgB,kBAAkB,8BAA8B,IAAI,GAAG;AACzH,WAAO;AAAA,MACL;AAAA,MACA;AAAA,MACA,SAAS,sBAAsB,gBAAgB,kBAAkB,UAAU,gDAC9C,8BAA8B;AAAA,MAC3D;AAAA,MACA;AAAA,MACA,MAAM;AAAA,IACR;AAAA,EACF;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,MAAM;AAAA,IACN,GAAG;AAAA,EACL;AACF;",
  "names": []
}


package/dist/lib/esm/library.mjs

@@ -1,4 +1,4 @@
-const LIBRARY_VERSION = false ? "dev" : "8.1.2";
+const LIBRARY_VERSION = false ? "dev" : "8.2.1";
 export {
   LIBRARY_VERSION
 };

package/dist/lib/esm/spawn-options.d.mts

@@ -0,0 +1,60 @@
+/**
+ * @file
+ *
+ * Pure resolution of the `detached` / `windowsHide` spawn flags for the
+ * auto-started Appium server and Android emulator, derived from whether their
+ * console windows should be hidden.
+ *
+ * Kept separate from the integration-only launch code (`transport-factory`,
+ * excluded from unit tests) so the flag resolution stays unit-testable — the
+ * launcher itself needs a real Appium server / emulator. Mirrors the split in
+ * `visibility.ts` and `emulator-args.ts`.
+ *
+ * **Why these exact flags** (empirically verified on Windows):
+ * - `detached: true` sets `DETACHED_PROCESS`, which gives the child no console.
+ *   For a console-subsystem child that means Windows/the child later allocates a
+ *   **fresh, visible** console — and `windowsHide` (which only sets `SW_HIDE` on
+ *   an inherited/new console at `CreateProcess` time) is silently defeated. So a
+ *   process we want hidden must NOT be detached.
+ * - Not detaching lets the child inherit the parent's (hidden) console, and any
+ *   console-app **grandchildren** it spawns (e.g. the emulator's netsim/qemu
+ *   helpers) inherit that hidden console too, instead of each popping their own.
+ * - Teardown does not rely on `detached`: `killProcessTree` uses
+ *   `taskkill /F /T /PID`, and `child.unref()` alone lets the parent event loop
+ *   exit without waiting on the child.
+ */
+/**
+ * The subset of spawn options that control console-window visibility.
+ */
+export interface SpawnVisibilityFlags {
+    /**
+     * Whether to run the child in its own process group / detached from the
+     * parent console (`DETACHED_PROCESS` on Windows).
+     */
+    readonly detached: boolean;
+    /** Whether to hide the child's console window (`windowsHide`). */
+    readonly windowsHide: boolean;
+}
+/**
+ * Resolves the visibility spawn flags for the auto-started Appium server.
+ *
+ * When hidden, the server must NOT be detached (otherwise a console window
+ * appears despite `windowsHide`). When the user opts to see the console, it is
+ * detached so it gets its own dedicated window.
+ *
+ * @param isConsoleHidden - Whether the Appium console should be hidden.
+ * @returns The `detached` / `windowsHide` flags to pass to `spawn`.
+ */
+export declare function resolveAppiumSpawnFlags(isConsoleHidden: boolean): SpawnVisibilityFlags;
+/**
+ * Resolves the visibility spawn flags for the auto-started Android emulator.
+ *
+ * The emulator is never detached: detaching only causes its console-app
+ * grandchildren (netsim/qemu) to allocate their own visible consoles. Its
+ * on-screen device window is a GUI window controlled by the `-no-window`
+ * argument (see `emulator-args.ts`), independent of these console flags.
+ *
+ * @param isWindowHidden - Whether the emulator (and its console) should be hidden.
+ * @returns The `detached` / `windowsHide` flags to pass to `spawn`.
+ */
+export declare function resolveEmulatorSpawnFlags(isWindowHidden: boolean): SpawnVisibilityFlags;

package/dist/lib/esm/spawn-options.mjs

@@ -0,0 +1,17 @@
+function resolveAppiumSpawnFlags(isConsoleHidden) {
+  return {
+    detached: !isConsoleHidden,
+    windowsHide: isConsoleHidden
+  };
+}
+function resolveEmulatorSpawnFlags(isWindowHidden) {
+  return {
+    detached: false,
+    windowsHide: isWindowHidden
+  };
+}
+export {
+  resolveAppiumSpawnFlags,
+  resolveEmulatorSpawnFlags
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/transport-desktop-cdp.d.mts

@@ -16,6 +16,7 @@
  *
  * Requirements: Node.js 22+ (uses built-in `WebSocket` and `fetch` globals).
  */
+import type { ElectronCompatibility } from './electron-compatibility.mjs';
 import type { InstallerCompatibility } from './installer-compatibility.mjs';
 import type { ObsidianTransport, TransportEvalOptions } from './transport.mjs';
 /**
@@ -74,6 +75,15 @@ export interface DesktopCdpTransportConfig {
      * @default `false`
      */
     shouldDisableSandbox?: boolean;
+    /**
+     * Whether the post-boot runtime-Electron compatibility nag warning is emitted
+     * when the live Electron is below the app's recommended minimum. The verdict is
+     * always computed and surfaced via {@link DesktopCdpTransport.getElectronCompatibility};
+     * this only gates the log. Only meaningful in owned mode.
+     *
+     * @default `true`
+     */
+    shouldWarnOnCompatibilityIssues?: boolean;
 }
 /**
  * An asar to provision into a harness-owned instance's user-data dir before launch.
@@ -96,7 +106,10 @@ export interface OwnedInstanceConfig {
     /**
      * The resolved installer↔app compatibility verdict, when it could be determined
      * (an asar-swap onto a known shell version). Surfaced by
-     * {@link DesktopCdpTransport.getCompatibility}.
+     * {@link DesktopCdpTransport.getCompatibility}. An `'unrunnable'` verdict reaches
+     * this surface only when the proactive throw is disabled
+     * (`shouldThrowOnIncompatibleInstaller: false`); otherwise it throws
+     * `IncompatibleInstallerVersionError` before the config is built.
      */
     readonly compatibility?: InstallerCompatibility | undefined;
     /** Absolute path to the Obsidian shell executable to launch. */
@@ -133,12 +146,14 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
     private cdpUrl;
     private readonly commandTimeoutInMilliseconds;
     private readonly deadBootGraceInMilliseconds;
+    private electronCompatibility;
     private readonly isHarnessOwnedInstance;
     private readonly isObsidianAppVisible;
     private messageId;
     private readonly ownedConfig;
     private ownedInstance;
     private readonly shouldDisableSandbox;
+    private readonly shouldWarnOnCompatibilityIssues;
     private ws;
     /**
      * Creates a new CDP transport.
@@ -179,6 +194,17 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
      * @returns The compatibility verdict, or `undefined`.
      */
     getCompatibility(): InstallerCompatibility | undefined;
+    /**
+     * Returns the runtime Electron compatibility verdict for this owned instance —
+     * whether the Electron version it is actually running is new enough for the
+     * running app version (read live post-boot; see {@link ObsidianVersionMetadata.minRecommendedElectronVersion}).
+     * Returns `undefined` when this is not an owned instance, the instance has not
+     * booted yet, or the verdict could not be determined (the live version was
+     * unreadable, or the app version carries no recommended Electron version).
+     *
+     * @returns The runtime Electron compatibility verdict, or `undefined`.
+     */
+    getElectronCompatibility(): ElectronCompatibility | undefined;
     /**
      * Returns the CDP endpoint of the owned, launched instance so the global setup
      * can hand it to test workers (which then **attach** to it instead of
@@ -212,6 +238,25 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
      * @param vaultPath - The absolute path to the vault folder.
      */
     unregisterVault(vaultPath: string): Promise<void>;
+    /**
+     * Best-effort tier-2 runtime nag: reads the live Electron version and running
+     * app version from the booted owned renderer and warns when the Electron the
+     * instance is actually running is older than the app's recommended minimum.
+     * Stores the verdict on {@link getElectronCompatibility}.
+     *
+     * The app version is read **live** — the running app version from the main
+     * process (`ipcRenderer.sendSync('version')`, the same IPC channel the namespace
+     * bootstrap uses) rather than from the resolved config — so the nag reflects the
+     * version genuinely running across every owned sub-path (asar-swap / downgrade /
+     * own-installer) and stays truthful even under a silent asar fallback.
+     * `process.versions.electron` gives the shell's live Electron. Both are read at
+     * the renderer top level (no `require('obsidian')`, which resolves only inside a
+     * plugin-load context). Never throws — a read failure is logged and ignored, so
+     * it cannot break an otherwise-ready boot.
+     *
+     * @param vaultPath - The vault path to evaluate in.
+     */
+    private checkRuntimeElectronCompatibility;
     /**
      * Connects to a CDP target's WebSocket endpoint.
      *