obsidian-integration-testing 9.2.1 → 9.2.2

package/dist/lib/esm/parent-liveness.d.mts

@@ -0,0 +1,76 @@
+/**
+ * @file
+ *
+ * Ties a harness-owned Obsidian instance's lifetime to the harness process that
+ * launched it, in the one direction the operating system will not do for us.
+ *
+ * The owned instance is already a child of the harness process, but that link
+ * carries no lifetime guarantee. Windows never propagates a parent's death to
+ * its children — an orphan simply keeps running with a stale parent id — and on
+ * POSIX a `SIGKILL` aimed at a single pid never cascades either. The instance is
+ * additionally spawned `detached`, so it is not even in the harness's process
+ * group. Teardown therefore relies entirely on the harness running its own
+ * cleanup (`killProcessTree` from an `exit`/signal handler), which is exactly
+ * what a `SIGKILL`, a Task Manager kill, or an IDE stop button denies it. Every
+ * such kill leaks a hidden Obsidian holding a user-data dir and a CDP port, and
+ * they accumulate: the next run picks a fresh temp dir and a free port, so
+ * nothing collides and nothing complains.
+ *
+ * The guaranteed fix is an OS primitive — a Windows Job Object with
+ * `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`, or `prctl(PR_SET_PDEATHSIG)` on Linux —
+ * but neither is reachable from Node without a native addon, which is far too
+ * heavy a dependency for this harness.
+ *
+ * So we use the one cross-platform resource the kernel *does* reclaim
+ * deterministically on process death: a socket. The harness listens on a
+ * loopback port and the instance's renderer connects to it. However the harness
+ * dies — cleanly, `SIGKILL`ed, or crashed — the kernel closes its end, the
+ * renderer sees `close`, and the window destroys itself. No polling, no
+ * heartbeat interval, no timeout to tune.
+ *
+ * Deliberately fail-open: the renderer only arms the destroy handler after the
+ * connection is actually established. A watchdog that cannot reach the harness
+ * leaves the instance running rather than killing a window the developer is
+ * working in.
+ */
+/**
+ * A listening loopback server whose accepted connections act as liveness tokens
+ * for the harness process.
+ */
+export interface ParentLivenessServer {
+    /** Stops listening and drops every accepted connection. */
+    close(): void;
+    /** The loopback port the renderer watchdog should connect back to. */
+    readonly port: number;
+}
+/**
+ * Loopback host the liveness server binds to. Never exposed off-machine.
+ */
+export declare const PARENT_LIVENESS_HOST = "127.0.0.1";
+/**
+ * Builds the expression evaluated in the owned instance's renderer to arm the
+ * watchdog.
+ *
+ * Written in ES5 style (`var`, `function`) with no optional chaining, matching
+ * {@link DISMISS_TRUST_DIALOG_EXPR}: the same expression has to parse on the
+ * Chromium 80-era renderers of the oldest supported Obsidian versions (L26).
+ *
+ * Arming is idempotent — a second evaluation finds the stored socket and
+ * returns without opening another connection, so a retried readiness pass does
+ * not pile up sockets.
+ *
+ * @param port - The loopback port returned by {@link startParentLivenessServer}.
+ * @returns The expression to evaluate, yielding `'armed'`, `'already-armed'`, or `'unavailable'`.
+ */
+export declare function buildParentLivenessWatchdogExpr(port: number): string;
+/**
+ * Starts the loopback liveness server the owned instance's renderer connects
+ * back to.
+ *
+ * The server and every accepted socket are `unref`ed, so holding a watchdog
+ * connection open never keeps the harness process alive on its own — the
+ * connection is a token the kernel reclaims, not work to wait on.
+ *
+ * @returns A {@link Promise} resolving to the listening {@link ParentLivenessServer}.
+ */
+export declare function startParentLivenessServer(): Promise<ParentLivenessServer>;

package/dist/lib/esm/parent-liveness.mjs

@@ -0,0 +1,67 @@
+import { createServer } from "node:net";
+const PARENT_LIVENESS_HOST = "127.0.0.1";
+function buildParentLivenessWatchdogExpr(port) {
+  return `(function() {
+  var FLAG = '__obsidianIntegrationTestingParentLiveness';
+  if (window[FLAG]) { return 'already-armed'; }
+  var net;
+  try {
+    net = window.require('node:net');
+  } catch (nodePrefixError) {
+    try {
+      net = window.require('net');
+    } catch (barePrefixError) {
+      return 'unavailable';
+    }
+  }
+  var socket = net.connect(${String(port)}, '${PARENT_LIVENESS_HOST}');
+  window[FLAG] = socket;
+  var isConnected = false;
+  socket.on('connect', function() { isConnected = true; });
+  socket.on('error', function() { /* Handled by the close listener below. */ });
+  socket.on('close', function() {
+    if (!isConnected) { return; }
+    try {
+      window.electronWindow.destroy();
+    } catch (destroyError) {
+      window.close();
+    }
+  });
+  return 'armed';
+})()`;
+}
+async function startParentLivenessServer() {
+  const server = createServer((socket) => {
+    socket.unref();
+    socket.on("error", () => {
+    });
+  });
+  server.unref();
+  const port = await listenOnFreeLoopbackPort(server);
+  return {
+    close() {
+      server.close();
+    },
+    port
+  };
+}
+async function listenOnFreeLoopbackPort(server) {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, PARENT_LIVENESS_HOST, () => {
+      const address = server.address();
+      if (address === null || typeof address === "string") {
+        server.close();
+        reject(new Error("Failed to determine the parent-liveness port."));
+        return;
+      }
+      resolve(address.port);
+    });
+  });
+}
+export {
+  PARENT_LIVENESS_HOST,
+  buildParentLivenessWatchdogExpr,
+  startParentLivenessServer
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/parent-liveness.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Ties a harness-owned Obsidian instance's lifetime to the harness process that\n * launched it, in the one direction the operating system will not do for us.\n *\n * The owned instance is already a child of the harness process, but that link\n * carries no lifetime guarantee. Windows never propagates a parent's death to\n * its children \u2014 an orphan simply keeps running with a stale parent id \u2014 and on\n * POSIX a `SIGKILL` aimed at a single pid never cascades either. The instance is\n * additionally spawned `detached`, so it is not even in the harness's process\n * group. Teardown therefore relies entirely on the harness running its own\n * cleanup (`killProcessTree` from an `exit`/signal handler), which is exactly\n * what a `SIGKILL`, a Task Manager kill, or an IDE stop button denies it. Every\n * such kill leaks a hidden Obsidian holding a user-data dir and a CDP port, and\n * they accumulate: the next run picks a fresh temp dir and a free port, so\n * nothing collides and nothing complains.\n *\n * The guaranteed fix is an OS primitive \u2014 a Windows Job Object with\n * `JOB_OBJECT_LIMIT_KILL_ON_JOB_CLOSE`, or `prctl(PR_SET_PDEATHSIG)` on Linux \u2014\n * but neither is reachable from Node without a native addon, which is far too\n * heavy a dependency for this harness.\n *\n * So we use the one cross-platform resource the kernel *does* reclaim\n * deterministically on process death: a socket. The harness listens on a\n * loopback port and the instance's renderer connects to it. However the harness\n * dies \u2014 cleanly, `SIGKILL`ed, or crashed \u2014 the kernel closes its end, the\n * renderer sees `close`, and the window destroys itself. No polling, no\n * heartbeat interval, no timeout to tune.\n *\n * Deliberately fail-open: the renderer only arms the destroy handler after the\n * connection is actually established. A watchdog that cannot reach the harness\n * leaves the instance running rather than killing a window the developer is\n * working in.\n */\n\nimport type { Server } from 'node:net';\n\nimport { createServer } from 'node:net';\n\n/**\n * A listening loopback server whose accepted connections act as liveness tokens\n * for the harness process.\n */\nexport interface ParentLivenessServer {\n  /** Stops listening and drops every accepted connection. */\n  close(): void;\n\n  /** The loopback port the renderer watchdog should connect back to. */\n  readonly port: number;\n}\n\n/**\n * Loopback host the liveness server binds to. Never exposed off-machine.\n */\nexport const PARENT_LIVENESS_HOST = '127.0.0.1';\n\n/**\n * Builds the expression evaluated in the owned instance's renderer to arm the\n * watchdog.\n *\n * Written in ES5 style (`var`, `function`) with no optional chaining, matching\n * {@link DISMISS_TRUST_DIALOG_EXPR}: the same expression has to parse on the\n * Chromium 80-era renderers of the oldest supported Obsidian versions (L26).\n *\n * Arming is idempotent \u2014 a second evaluation finds the stored socket and\n * returns without opening another connection, so a retried readiness pass does\n * not pile up sockets.\n *\n * @param port - The loopback port returned by {@link startParentLivenessServer}.\n * @returns The expression to evaluate, yielding `'armed'`, `'already-armed'`, or `'unavailable'`.\n */\nexport function buildParentLivenessWatchdogExpr(port: number): string {\n  return `(function() {\n  var FLAG = '__obsidianIntegrationTestingParentLiveness';\n  if (window[FLAG]) { return 'already-armed'; }\n  var net;\n  try {\n    net = window.require('node:net');\n  } catch (nodePrefixError) {\n    try {\n      net = window.require('net');\n    } catch (barePrefixError) {\n      return 'unavailable';\n    }\n  }\n  var socket = net.connect(${String(port)}, '${PARENT_LIVENESS_HOST}');\n  window[FLAG] = socket;\n  var isConnected = false;\n  socket.on('connect', function() { isConnected = true; });\n  socket.on('error', function() { /* Handled by the close listener below. */ });\n  socket.on('close', function() {\n    if (!isConnected) { return; }\n    try {\n      window.electronWindow.destroy();\n    } catch (destroyError) {\n      window.close();\n    }\n  });\n  return 'armed';\n})()`;\n}\n\n/**\n * Starts the loopback liveness server the owned instance's renderer connects\n * back to.\n *\n * The server and every accepted socket are `unref`ed, so holding a watchdog\n * connection open never keeps the harness process alive on its own \u2014 the\n * connection is a token the kernel reclaims, not work to wait on.\n *\n * @returns A {@link Promise} resolving to the listening {@link ParentLivenessServer}.\n */\nexport async function startParentLivenessServer(): Promise<ParentLivenessServer> {\n  const server = createServer((socket) => {\n    socket.unref();\n    // The connection carries no data \u2014 it exists only so its close is observable.\n    socket.on('error', () => {\n      // A renderer torn down mid-connection resets rather than closes; not an error here.\n    });\n  });\n  server.unref();\n\n  const port = await listenOnFreeLoopbackPort(server);\n  return {\n    close(): void {\n      server.close();\n    },\n    port\n  };\n}\n\n/**\n * Binds the server to an ephemeral loopback port and reports which one it got.\n *\n * @param server - The server to bind.\n * @returns A {@link Promise} resolving to the assigned port.\n * @throws If the server reports an error before listening, or binds to a pipe rather than a port.\n */\nasync function listenOnFreeLoopbackPort(server: Server): Promise<number> {\n  return new Promise<number>((resolve, reject) => {\n    server.once('error', reject);\n    server.listen(0, PARENT_LIVENESS_HOST, () => {\n      const address = server.address();\n      if (address === null || typeof address === 'string') {\n        server.close();\n        reject(new Error('Failed to determine the parent-liveness port.'));\n        return;\n      }\n      resolve(address.port);\n    });\n  });\n}\n"],
  "mappings": "AAsCA,SAAS,oBAAoB;AAiBtB,MAAM,uBAAuB;AAiB7B,SAAS,gCAAgC,MAAsB;AACpE,SAAO;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,6BAaoB,OAAO,IAAI,CAAC,MAAM,oBAAoB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAenE;AAYA,eAAsB,4BAA2D;AAC/E,QAAM,SAAS,aAAa,CAAC,WAAW;AACtC,WAAO,MAAM;AAEb,WAAO,GAAG,SAAS,MAAM;AAAA,IAEzB,CAAC;AAAA,EACH,CAAC;AACD,SAAO,MAAM;AAEb,QAAM,OAAO,MAAM,yBAAyB,MAAM;AAClD,SAAO;AAAA,IACL,QAAc;AACZ,aAAO,MAAM;AAAA,IACf;AAAA,IACA;AAAA,EACF;AACF;AASA,eAAe,yBAAyB,QAAiC;AACvE,SAAO,IAAI,QAAgB,CAAC,SAAS,WAAW;AAC9C,WAAO,KAAK,SAAS,MAAM;AAC3B,WAAO,OAAO,GAAG,sBAAsB,MAAM;AAC3C,YAAM,UAAU,OAAO,QAAQ;AAC/B,UAAI,YAAY,QAAQ,OAAO,YAAY,UAAU;AACnD,eAAO,MAAM;AACb,eAAO,IAAI,MAAM,+CAA+C,CAAC;AACjE;AAAA,MACF;AACA,cAAQ,QAAQ,IAAI;AAAA,IACtB,CAAC;AAAA,EACH,CAAC;AACH;",
  "names": []
}


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

@@ -274,6 +274,18 @@ export declare class DesktopCdpTransport implements ObsidianTransport {
      * @param actualElectronVersion - The live Electron version, or `undefined` when unreadable.
      */
     private applyElectronCompatibility;
+    /**
+     * Points the owned instance's renderer at this process's liveness socket so it
+     * destroys itself if we die without running teardown (see `parent-liveness.ts`).
+     *
+     * Best-effort by design. A renderer without Node access reports `'unavailable'`
+     * and an evaluation failure is logged and swallowed: the watchdog is a backstop
+     * for an already-abnormal exit, never a reason to fail an otherwise good launch.
+     *
+     * @param vaultPath - The vault path to evaluate in.
+     * @param parentLivenessPort - The loopback port the renderer should connect back to.
+     */
+    private armParentLivenessWatchdog;
     /**
      * Verifies the running app (asar) version matches the swapped-in pin, storing the
      * verdict on {@link getAsarFallback}. On a **silent fallback** (the installer ran