obsidian-integration-testing 4.3.0 → 5.0.0

package/dist/lib/esm/setup-lock.mjs

@@ -0,0 +1,132 @@
+import {
+  mkdirSync,
+  readFileSync,
+  rmSync,
+  writeFileSync
+} from "node:fs";
+import {
+  hostname,
+  tmpdir
+} from "node:os";
+import { join } from "node:path";
+import process from "node:process";
+import { log } from "./log.mjs";
+const LOCK_DIR_NAME = "obsidian-integration-testing";
+const LOCK_FILE_SUFFIX = ".setup.lock";
+const POLL_INTERVAL_IN_MILLISECONDS = 500;
+const MILLISECONDS_PER_SECOND = 1e3;
+const SECONDS_PER_MINUTE = 60;
+const STALE_LOCK_AGE_IN_MINUTES = 30;
+const DEFAULT_TIMEOUT_IN_MINUTES = 60;
+const STALE_LOCK_AGE_IN_MILLISECONDS = STALE_LOCK_AGE_IN_MINUTES * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;
+const DEFAULT_TIMEOUT_IN_MILLISECONDS = DEFAULT_TIMEOUT_IN_MINUTES * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;
+const PROCESS_EXISTENCE_PROBE_SIGNAL = 0;
+async function acquireSetupLock(params) {
+  const {
+    label,
+    scope
+  } = params;
+  const timeoutInMilliseconds = params.timeoutInMilliseconds ?? DEFAULT_TIMEOUT_IN_MILLISECONDS;
+  const lockFilePath = getLockFilePath(scope);
+  mkdirSync(getLockDir(), { recursive: true });
+  const deadlineInMilliseconds = Date.now() + timeoutInMilliseconds;
+  let hasLoggedWait = false;
+  for (; ; ) {
+    if (tryCreateLockFile(lockFilePath, label)) {
+      return createLockHandle(lockFilePath);
+    }
+    const info = readLockFileInfo(lockFilePath);
+    if (info && isLockStale(info)) {
+      log(`[integration-setup:${label}] Stealing stale '${scope}' setup lock from ${describeInfo(info)}.`);
+      rmSync(lockFilePath, { force: true });
+      continue;
+    }
+    if (Date.now() >= deadlineInMilliseconds) {
+      throw new Error(
+        `Timed out after ${String(timeoutInMilliseconds)}ms waiting for the '${scope}' integration-test setup lock held by ${describeHolder(info)}. Another integration-test run is still in progress.`
+      );
+    }
+    if (!hasLoggedWait) {
+      hasLoggedWait = true;
+      log(`[integration-setup:${label}] Waiting for the '${scope}' setup lock held by ${describeHolder(info)} to be released...`);
+    }
+    await delay(POLL_INTERVAL_IN_MILLISECONDS);
+  }
+}
+function createLockHandle(lockFilePath) {
+  let isReleased = false;
+  return {
+    release() {
+      if (isReleased) {
+        return;
+      }
+      isReleased = true;
+      rmSync(lockFilePath, { force: true });
+    }
+  };
+}
+function delay(milliseconds) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, milliseconds);
+  });
+}
+function describeHolder(info) {
+  return info ? describeInfo(info) : "another run";
+}
+function describeInfo(info) {
+  return `pid ${String(info.pid)} (${info.label}) on ${info.hostname}`;
+}
+function getErrorCode(error) {
+  if (error instanceof Error && "code" in error && typeof error.code === "string") {
+    return error.code;
+  }
+  return void 0;
+}
+function getLockDir() {
+  return join(tmpdir(), LOCK_DIR_NAME);
+}
+function getLockFilePath(scope) {
+  return join(getLockDir(), `${scope}${LOCK_FILE_SUFFIX}`);
+}
+function isLockStale(info) {
+  if (info.hostname === hostname()) {
+    return !isProcessAlive(info.pid);
+  }
+  return Date.now() - info.acquiredAtInMilliseconds > STALE_LOCK_AGE_IN_MILLISECONDS;
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, PROCESS_EXISTENCE_PROBE_SIGNAL);
+    return true;
+  } catch (error) {
+    return getErrorCode(error) === "EPERM";
+  }
+}
+function readLockFileInfo(lockFilePath) {
+  try {
+    return JSON.parse(readFileSync(lockFilePath, "utf-8"));
+  } catch {
+    return void 0;
+  }
+}
+function tryCreateLockFile(lockFilePath, label) {
+  const info = {
+    acquiredAtInMilliseconds: Date.now(),
+    hostname: hostname(),
+    label,
+    pid: process.pid
+  };
+  try {
+    writeFileSync(lockFilePath, JSON.stringify(info), { flag: "wx" });
+    return true;
+  } catch (error) {
+    if (getErrorCode(error) === "EEXIST") {
+      return false;
+    }
+    throw error;
+  }
+}
+export {
+  acquireSetupLock
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/setup-lock.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Cross-process advisory lock that serializes whole integration-test runs.\n *\n * Two test runs that drive the same shared resources corrupt each other: on\n * desktop they share the single local Obsidian instance, its `obsidian.json`\n * registry, and the CDP port; on Android they share the emulator and the Appium\n * server. One run's setup/teardown kills or reconfigures the instance the other\n * run is mid-eval on (observed as `ECONNREFUSED` or \"vault not open\"), so both\n * runs fail.\n *\n * This lock makes the second run **wait** for the first to finish instead of\n * running concurrently. It is held for the entire run: acquired at the start of\n * the core setup and released by the core teardown (and by the process cleanup\n * handlers). The lock is a sentinel file in a shared temp directory, carrying\n * the holder's PID so a run that crashed without releasing leaves a lock that\n * the next run detects as stale and steals.\n */\n\nimport {\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport {\n  hostname,\n  tmpdir\n} from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport { log } from './log.mjs';\n\nconst LOCK_DIR_NAME = 'obsidian-integration-testing';\nconst LOCK_FILE_SUFFIX = '.setup.lock';\nconst POLL_INTERVAL_IN_MILLISECONDS = 500;\nconst MILLISECONDS_PER_SECOND = 1000;\nconst SECONDS_PER_MINUTE = 60;\nconst STALE_LOCK_AGE_IN_MINUTES = 30;\nconst DEFAULT_TIMEOUT_IN_MINUTES = 60;\nconst STALE_LOCK_AGE_IN_MILLISECONDS = STALE_LOCK_AGE_IN_MINUTES * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;\nconst DEFAULT_TIMEOUT_IN_MILLISECONDS = DEFAULT_TIMEOUT_IN_MINUTES * SECONDS_PER_MINUTE * MILLISECONDS_PER_SECOND;\nconst PROCESS_EXISTENCE_PROBE_SIGNAL = 0;\n\n/**\n * Parameters for {@link acquireSetupLock}.\n */\nexport interface AcquireSetupLockParams {\n  /** Short transport label for log messages (e.g. `\"obsidian-cli\"`). */\n  readonly label: string;\n\n  /**\n   * Logical scope the lock serializes within. Runs that share resources must\n   * use the same scope (e.g. `\"desktop\"` for the CLI/CDP transports, `\"android\"`\n   * for the Appium transport).\n   */\n  readonly scope: string;\n\n  /**\n   * Maximum time to wait for a competing run to release the lock before giving\n   * up and throwing.\n   *\n   * @default 1 hour\n   */\n  readonly timeoutInMilliseconds?: number | undefined;\n}\n\n/**\n * A held setup lock. Release it once the run's teardown is complete.\n */\nexport interface SetupLock {\n  /** Releases the lock. Safe to call more than once. */\n  release(): void;\n}\n\n/**\n * The JSON payload stored inside a lock file, identifying the holder.\n */\ninterface LockFileInfo {\n  /** When the lock was acquired (`Date.now()` epoch milliseconds). */\n  readonly acquiredAtInMilliseconds: number;\n\n  /** The host that holds the lock (PID liveness is only valid on the same host). */\n  readonly hostname: string;\n\n  /** The transport label of the holding run. */\n  readonly label: string;\n\n  /** The process ID of the holding run. */\n  readonly pid: number;\n}\n\n/**\n * Acquires the cross-process setup lock for the given scope, waiting until any\n * competing run releases it (or its lock is detected as stale).\n *\n * @param params - The lock parameters.\n * @returns A handle whose {@link SetupLock.release} frees the lock.\n * @throws If the lock cannot be acquired within `timeoutInMilliseconds`.\n */\nexport async function acquireSetupLock(params: AcquireSetupLockParams): Promise<SetupLock> {\n  const {\n    label,\n    scope\n  } = params;\n  const timeoutInMilliseconds = params.timeoutInMilliseconds ?? DEFAULT_TIMEOUT_IN_MILLISECONDS;\n  const lockFilePath = getLockFilePath(scope);\n  mkdirSync(getLockDir(), { recursive: true });\n\n  const deadlineInMilliseconds = Date.now() + timeoutInMilliseconds;\n  let hasLoggedWait = false;\n\n  for (;;) {\n    if (tryCreateLockFile(lockFilePath, label)) {\n      return createLockHandle(lockFilePath);\n    }\n\n    const info = readLockFileInfo(lockFilePath);\n    if (info && isLockStale(info)) {\n      log(`[integration-setup:${label}] Stealing stale '${scope}' setup lock from ${describeInfo(info)}.`);\n      rmSync(lockFilePath, { force: true });\n      continue;\n    }\n\n    if (Date.now() >= deadlineInMilliseconds) {\n      throw new Error(\n        `Timed out after ${String(timeoutInMilliseconds)}ms waiting for the '${scope}' integration-test setup lock `\n          + `held by ${describeHolder(info)}. Another integration-test run is still in progress.`\n      );\n    }\n\n    if (!hasLoggedWait) {\n      hasLoggedWait = true;\n      log(`[integration-setup:${label}] Waiting for the '${scope}' setup lock held by ${describeHolder(info)} to be released...`);\n    }\n\n    await delay(POLL_INTERVAL_IN_MILLISECONDS);\n  }\n}\n\n/**\n * Creates a {@link SetupLock} handle that removes the lock file on release.\n *\n * @param lockFilePath - The path to the lock file to remove on release.\n * @returns The lock handle.\n */\nfunction createLockHandle(lockFilePath: string): SetupLock {\n  let isReleased = false;\n  return {\n    release(): void {\n      if (isReleased) {\n        return;\n      }\n      isReleased = true;\n      rmSync(lockFilePath, { force: true });\n    }\n  };\n}\n\n/**\n * Resolves after the given delay. Used to poll between lock-acquisition attempts.\n *\n * @param milliseconds - The delay in milliseconds.\n * @returns A promise that resolves after the delay.\n */\nfunction delay(milliseconds: number): Promise<void> {\n  return new Promise<void>((resolve) => {\n    setTimeout(resolve, milliseconds);\n  });\n}\n\n/**\n * Builds a human-readable description of the current lock holder for log/error\n * messages.\n *\n * @param info - The parsed lock info, or `undefined` if it could not be read.\n * @returns A description string.\n */\nfunction describeHolder(info: LockFileInfo | undefined): string {\n  return info ? describeInfo(info) : 'another run';\n}\n\n/**\n * Formats a {@link LockFileInfo} as a short identifier string.\n *\n * @param info - The lock info.\n * @returns A string like `pid 1234 (obsidian-cli) on host`.\n */\nfunction describeInfo(info: LockFileInfo): string {\n  return `pid ${String(info.pid)} (${info.label}) on ${info.hostname}`;\n}\n\n/**\n * Extracts the `code` from a Node.js system error, if present.\n *\n * @param error - The thrown value.\n * @returns The error code string, or `undefined` if not a coded error.\n */\nfunction getErrorCode(error: unknown): string | undefined {\n  if (error instanceof Error && 'code' in error && typeof error.code === 'string') {\n    return error.code;\n  }\n  return undefined;\n}\n\n/**\n * Returns the shared lock directory inside the OS temp directory.\n *\n * @returns The absolute path to the lock directory.\n */\nfunction getLockDir(): string {\n  return join(tmpdir(), LOCK_DIR_NAME);\n}\n\n/**\n * Returns the lock file path for the given scope.\n *\n * @param scope - The lock scope.\n * @returns The absolute path to the scope's lock file.\n */\nfunction getLockFilePath(scope: string): string {\n  return join(getLockDir(), `${scope}${LOCK_FILE_SUFFIX}`);\n}\n\n/**\n * Determines whether a lock can be considered abandoned.\n *\n * On the same host, the holder's PID is probed directly: a dead PID means the\n * run crashed without releasing. On a different host (a shared/network temp\n * directory) the PID cannot be probed, so an age threshold is used instead.\n *\n * @param info - The parsed lock info.\n * @returns `true` if the lock is stale and may be stolen.\n */\nfunction isLockStale(info: LockFileInfo): boolean {\n  if (info.hostname === hostname()) {\n    return !isProcessAlive(info.pid);\n  }\n\n  return Date.now() - info.acquiredAtInMilliseconds > STALE_LOCK_AGE_IN_MILLISECONDS;\n}\n\n/**\n * Checks whether a process with the given PID is currently alive.\n *\n * @param pid - The process ID to probe.\n * @returns `true` if the process exists.\n */\nfunction isProcessAlive(pid: number): boolean {\n  try {\n    process.kill(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 * Reads and parses the lock file, if it exists and is valid JSON.\n *\n * @param lockFilePath - The path to the lock file.\n * @returns The parsed lock info, or `undefined` if it could not be read.\n */\nfunction readLockFileInfo(lockFilePath: string): LockFileInfo | undefined {\n  try {\n    return JSON.parse(readFileSync(lockFilePath, 'utf-8')) as LockFileInfo;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Attempts to atomically create the lock file (failing if it already exists).\n *\n * @param lockFilePath - The path to the lock file.\n * @param label - The transport label to record in the lock file.\n * @returns `true` if the lock was acquired, `false` if it is already held.\n * @throws If the file system fails for any reason other than the file existing.\n */\nfunction tryCreateLockFile(lockFilePath: string, label: string): boolean {\n  const info: LockFileInfo = {\n    acquiredAtInMilliseconds: Date.now(),\n    hostname: hostname(),\n    label,\n    pid: process.pid\n  };\n\n  try {\n    writeFileSync(lockFilePath, JSON.stringify(info), { flag: 'wx' });\n    return true;\n  } catch (error: unknown) {\n    if (getErrorCode(error) === 'EEXIST') {\n      return false;\n    }\n    throw error;\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


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

@@ -4,18 +4,17 @@
  * Desktop CDP transport — evaluates expressions via Chrome DevTools Protocol
  * over WebSocket and manages vaults via Electron IPC.
  *
- * Obsidian exposes CDP on port 8315 by default. This transport connects to
- * page targets, sends `Runtime.evaluate` commands, and routes to the correct
- * vault target using `getBasePath()` probing.
+ * Two modes:
+ * - **Owned (default)**: the transport launches and owns an isolated Obsidian
+ *   instance against a temporary `--user-data-dir` on a free `--remote-debugging-port`,
+ *   never touching the user's Obsidian. Supports version pinning via the user-data asar.
+ * - **Attach**: when an explicit CDP port is configured, the transport connects
+ *   to an already-running Obsidian on that port.
  *
- * Advantages over CLI transport:
- * - No CLI binary installation needed
- * - No "CLI enabled" setting required in Obsidian
- * - Lower overhead (WebSocket vs. process spawn per eval)
+ * It connects to page targets, sends `Runtime.evaluate` commands, and routes to
+ * the correct vault target using `getBasePath()` probing.
  *
- * Requirements:
- * - Obsidian must be running with remote debugging enabled (port 8315)
- * - Node.js 22+ (uses built-in `WebSocket` and `fetch` globals)
+ * Requirements: Node.js 22+ (uses built-in `WebSocket` and `fetch` globals).
  */
 import type { ObsidianTransport, TransportEvalOptions } from './transport.mjs';
 /**
@@ -27,7 +26,9 @@ export interface DesktopCdpTransportConfig {
      */
     cdpHost?: string;
     /**
-     * CDP port. Defaults to `8315`.
+     * CDP port for **attach** mode (the `--remote-debugging-port` the running
+     * Obsidian was launched with). In owned-instance mode this is ignored — a
+     * free port is chosen at launch.
      */
     cdpPort?: number;
     /**
@@ -35,6 +36,37 @@ export interface DesktopCdpTransportConfig {
      * Defaults to `30000`.
      */
     commandTimeoutInMilliseconds?: number;
+    /**
+     * When set, the transport launches and owns an isolated Obsidian instance
+     * instead of attaching to a running one. This is the default desktop mode.
+     */
+    ownedInstance?: OwnedInstanceConfig;
+}
+/**
+ * An asar to provision into a harness-owned instance's user-data dir before launch.
+ */
+export interface OwnedInstanceAsar {
+    /** Absolute path to the cached/source asar file. */
+    readonly path: string;
+    /** The asar's `x.y.z` version. */
+    readonly version: string;
+}
+/**
+ * Configuration for a harness-owned, isolated Obsidian instance.
+ *
+ * When present, the transport launches and owns its own Obsidian process
+ * against an isolated user-data dir instead of attaching to a running instance.
+ */
+export interface OwnedInstanceConfig {
+    /** Optional asar to provision into {@link userDataDir} before launch. */
+    readonly asar?: OwnedInstanceAsar | undefined;
+    /** Absolute path to the Obsidian shell executable to launch. */
+    readonly exePath: string;
+    /**
+     * Absolute path to the isolated user-data dir. Created and owned by the
+     * transport, and deleted on dispose.
+     */
+    readonly userDataDir: string;
 }
 /**
  * Transport that communicates with Desktop Obsidian via Chrome DevTools Protocol.
@@ -48,10 +80,13 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
      */
     readonly isMobile = false;
     private activeVaultPath;
-    private readonly cdpPort;
-    private readonly cdpUrl;
+    private readonly cdpHost;
+    private cdpPort;
+    private cdpUrl;
     private readonly commandTimeoutInMilliseconds;
     private messageId;
+    private readonly ownedConfig;
+    private ownedInstance;
     private ws;
     /**
      * Creates a new CDP transport.
@@ -60,9 +95,19 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
      */
     constructor(config?: DesktopCdpTransportConfig);
     /**
-     * Disposes of the active WebSocket connection.
+     * Disposes of the active WebSocket connection and, in owned-instance mode,
+     * kills the owned Obsidian process and removes its isolated user-data dir.
+     *
+     * The removal is retried because Windows briefly holds the just-killed
+     * process's file handles, which would otherwise fail `rmSync` with `EPERM`.
      */
     dispose(): Promise<void>;
+    /**
+     * Synchronous disposal — kills the owned instance and makes a best-effort
+     * removal of its user-data dir. Safe to call from a process `exit` handler
+     * (where async retries are impossible; a leftover temp dir is acceptable).
+     */
+    disposeSync(): void;
     /**
      * Evaluates a JavaScript expression inside Obsidian via CDP `Runtime.evaluate`.
      *
@@ -170,6 +215,15 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
      * @returns The vault's base path.
      */
     private probeVaultPath;
+    /**
+     * Launches and connects to a harness-owned, isolated Obsidian instance for a
+     * vault: provisions the asar (if any), pre-seeds the isolated `obsidian.json`
+     * so the vault opens directly, launches the instance on a free CDP port, then
+     * waits until the vault window is ready and dismisses the trust dialog.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    private registerVaultInOwnedInstance;
     /**
      * Sends a CDP command over WebSocket and waits for the response.
      *
@@ -192,4 +246,11 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
      * @param vaultPath - The vault path to evaluate in.
      */
     private waitForLayoutReady;
+    /**
+     * Polls the owned instance until the vault target exists, layout is ready, and
+     * the trust dialog (if any) has been dismissed.
+     *
+     * @param vaultPath - The absolute path to the vault folder.
+     */
+    private waitForOwnedVaultReady;
 }