obsidian-integration-testing 12.2.0 → 13.0.0

package/dist/lib/esm/webview-cdp.mjs

@@ -11,6 +11,18 @@ class WebViewCdpConnection {
   /**
    * Wraps an already-open debugger socket, plus what is needed to tear its port forward down.
    *
+   * ONE `message` listener for the socket's whole life, routing both halves of what
+   * arrives — CDP events to their subscribed handler, command replies to the
+   * {@link send} call waiting on the id. A listener per in-flight command instead
+   * would make the count scale with concurrency, so eleven commands in flight at
+   * once would cross Node's default `maxListeners` of 10 and report a memory leak
+   * that is not one (see the desktop transport's `getPendingCommands`, where the
+   * same shape was measured).
+   *
+   * The parse is guarded because a frame this connection cannot read belongs to
+   * nothing it sent: throwing here would throw out of the event dispatch, where
+   * nothing can catch it.
+   *
    * @param webSocket - The open debugger socket.
    * @param deviceId - The adb device id, needed to drop the port forward on dispose.
    * @param port - The forwarded local port.
@@ -20,11 +32,25 @@ class WebViewCdpConnection {
     this.deviceId = deviceId;
     this.port = port;
     this.webSocket.addEventListener("message", (event) => {
-      const message = JSON.parse(String(event.data));
-      if (message.method === void 0) {
+      let message;
+      try {
+        message = JSON.parse(String(event.data));
+      } catch {
+        return;
+      }
+      if (message.method !== void 0) {
+        this.eventHandlers.get(message.method)?.(message.params ?? {});
+        return;
+      }
+      if (message.id === void 0) {
+        return;
+      }
+      const pendingCommand = this.pendingCommands.get(message.id);
+      if (!pendingCommand) {
         return;
       }
-      this.eventHandlers.get(message.method)?.(message.params ?? {});
+      this.pendingCommands.delete(message.id);
+      pendingCommand(message);
     });
   }
   webSocket;
@@ -43,6 +69,11 @@ class WebViewCdpConnection {
   }
   eventHandlers = /* @__PURE__ */ new Map();
   messageId = 0;
+  /**
+   * The commands still waiting for a reply, keyed by the CDP message id each was
+   * sent with. Emptied by whichever of the reply and the timeout comes first.
+   */
+  pendingCommands = /* @__PURE__ */ new Map();
   /**
    * Closes the socket and drops the adb port forward.
    */
@@ -86,24 +117,24 @@ class WebViewCdpConnection {
     const id = ++this.messageId;
     return new Promise((resolve, reject) => {
       const timeout = setTimeout(() => {
-        this.webSocket.removeEventListener("message", handler);
+        this.pendingCommands.delete(id);
         reject(new Error(`WebView CDP command timed out after ${String(CDP_COMMAND_TIMEOUT_IN_MILLISECONDS)}ms: ${method}`));
       }, CDP_COMMAND_TIMEOUT_IN_MILLISECONDS);
-      const handler = (event) => {
-        const message = JSON.parse(String(event.data));
-        if (message.id !== id) {
-          return;
-        }
+      this.pendingCommands.set(id, (message) => {
         clearTimeout(timeout);
-        this.webSocket.removeEventListener("message", handler);
         if (message.error) {
           reject(new Error(`WebView CDP command ${method} failed: ${message.error.message ?? "unknown error"}`));
           return;
         }
         resolve(message.result ?? {});
-      };
-      this.webSocket.addEventListener("message", handler);
-      this.webSocket.send(JSON.stringify({ id, method, params }));
+      });
+      try {
+        this.webSocket.send(JSON.stringify({ id, method, params }));
+      } catch (error) {
+        clearTimeout(timeout);
+        this.pendingCommands.delete(id);
+        reject(error instanceof Error ? error : new Error(String(error)));
+      }
     });
   }
   /**
@@ -232,4 +263,4 @@ export {
   parseWebViewDevtoolsSocketName,
   selectWebViewPageTarget
 };
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/webview-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A second, independent Chrome DevTools Protocol connection to Obsidian Mobile's WebView, used to inject\n * **trusted** input on Android (see **L39**).\n *\n * It is deliberately separate from the Appium session rather than layered on it. `AppiumTransport.evaluate`\n * runs the whole `evalInObsidian` closure inside one W3C *Execute Script*, which awaits the returned\n * promise \u2014 so while a closure sits waiting on `lib.clickElement(...)`, the WebDriver session is busy and\n * cannot be asked to do anything else. CDP is id-multiplexed and Chromium accepts multiple debugger\n * clients, so this socket stays free exactly when the Appium one does not. That is what lets the renderer\n * call back out to the host mid-closure.\n *\n * Reaching the WebView's debugger is a two-step: the app publishes an abstract unix socket named\n * `webview_devtools_remote_<pid>`, `adb forward` maps it to a local TCP port, and the usual `/json`\n * endpoint then lists the page targets.\n */\n\nimport { execFileSync } from 'node:child_process';\n\nimport type { CdpInputCommand } from './mobile-input.mjs';\n\nimport { exec } from './exec.mjs';\nimport { log } from './log.mjs';\nimport { pickFreePort } from './obsidian-instance.mjs';\n\nconst ADB_TIMEOUT_IN_MILLISECONDS = 15_000;\n// `adb forward --list` prints three columns: `<deviceId> tcp:<port> localabstract:<socketName>`.\nconst FORWARD_LIST_COLUMN_COUNT = 3;\nconst DECIMAL_RADIX = 10;\nconst CDP_COMMAND_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst CDP_HOST = '127.0.0.1';\n\n/**\n * One entry of the debugger's `/json` target list.\n */\nexport interface CdpTarget {\n  readonly title?: string;\n  readonly type?: string;\n  readonly url?: string;\n  readonly webSocketDebuggerUrl?: string;\n}\n\n/**\n * Parameters for {@link connectToWebViewCdp}.\n */\nexport interface ConnectToWebViewCdpParams {\n  /**\n   * The Android application id whose WebView to attach to, e.g. `md.obsidian`.\n   */\n  readonly appId: string;\n\n  /**\n   * The adb device id (`emulator-5554`, a serial) to run adb against.\n   */\n  readonly deviceId: string;\n}\n\n/**\n * The error half of a failed CDP command response.\n */\ninterface CdpError {\n  readonly message?: string;\n}\n\n/**\n * Handles a CDP event.\n */\ntype CdpEventHandler = (params: Record<string, unknown>) => void;\n\n/**\n * A CDP message: either a response to a command (`id`) or an event (`method`).\n */\ninterface CdpMessage {\n  readonly error?: CdpError;\n  readonly id?: number;\n  readonly method?: string;\n  readonly params?: Record<string, unknown>;\n  readonly result?: Record<string, unknown>;\n}\n\n/* v8 ignore start -- Integration-time code (a live WebSocket to a WebView, adb port forwarding). Covered by the Android integration tests, not by unit tests. It ends before `parseForwardedPort`: `perfectionist/sort-modules` places the pure, unit-tested helpers AFTER this class and `connectToWebViewCdp`, so they must stay measured. */\n\n/**\n * An open CDP connection to a WebView.\n *\n * Commands are id-multiplexed, so a command issued from inside an event handler completes while an earlier\n * `Runtime.evaluate` is still awaiting its promise \u2014 which is the whole reason this class exists.\n */\nexport class WebViewCdpConnection {\n  /**\n   * Whether the socket is still usable.\n   *\n   * Restarting the app tears its WebView down and takes the debugger target with it, so a cached\n   * connection has to be re-checked rather than assumed live.\n   *\n   * @returns `true` while the socket is open.\n   */\n  public get isOpen(): boolean {\n    return this.webSocket.readyState === WebSocket.OPEN;\n  }\n\n  private readonly eventHandlers = new Map<string, CdpEventHandler>();\n\n  private messageId = 0;\n\n  /**\n   * Wraps an already-open debugger socket, plus what is needed to tear its port forward down.\n   *\n   * @param webSocket - The open debugger socket.\n   * @param deviceId - The adb device id, needed to drop the port forward on dispose.\n   * @param port - The forwarded local port.\n   */\n  public constructor(private readonly webSocket: WebSocket, private readonly deviceId: string, private readonly port: number) {\n    this.webSocket.addEventListener('message', (event: MessageEvent) => {\n      const message = JSON.parse(String(event.data)) as CdpMessage;\n      if (message.method === undefined) {\n        return;\n      }\n\n      this.eventHandlers.get(message.method)?.(message.params ?? {});\n    });\n  }\n\n  /**\n   * Closes the socket and drops the adb port forward.\n   */\n  public async dispose(): Promise<void> {\n    this.closeSocket();\n    await removeForward(this.deviceId, this.port);\n  }\n\n  /**\n   * Synchronous disposal, for `process.on('exit')` handlers where async work cannot run.\n   *\n   * Without this an abrupt worker exit leaves the port forward behind \u2014 the async {@link dispose} above\n   * never gets a turn.\n   */\n  public disposeSync(): void {\n    this.closeSocket();\n    try {\n      execFileSync('adb', ['-s', this.deviceId, 'forward', '--remove', `tcp:${String(this.port)}`], {\n        stdio: 'ignore',\n        timeout: ADB_TIMEOUT_IN_MILLISECONDS\n      });\n    } catch {\n      // Best effort: adb drops every forward when the device disconnects anyway.\n    }\n  }\n\n  /**\n   * Subscribes to a CDP event. One handler per method; subscribing again replaces it.\n   *\n   * @param method - The CDP event name, e.g. `Runtime.bindingCalled`.\n   * @param handler - Called with the event parameters.\n   */\n  public on(method: string, handler: CdpEventHandler): void {\n    this.eventHandlers.set(method, handler);\n  }\n\n  /**\n   * Sends a CDP command and waits for its response.\n   *\n   * @param method - The CDP method name.\n   * @param params - The CDP method parameters.\n   * @returns The command result.\n   */\n  public send(method: string, params: Record<string, unknown> = {}): Promise<Record<string, unknown>> {\n    const id = ++this.messageId;\n\n    return new Promise<Record<string, unknown>>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        this.webSocket.removeEventListener('message', handler);\n        reject(new Error(`WebView CDP command timed out after ${String(CDP_COMMAND_TIMEOUT_IN_MILLISECONDS)}ms: ${method}`));\n      }, CDP_COMMAND_TIMEOUT_IN_MILLISECONDS);\n\n      const handler = (event: MessageEvent): void => {\n        const message = JSON.parse(String(event.data)) as CdpMessage;\n        if (message.id !== id) {\n          return;\n        }\n\n        clearTimeout(timeout);\n        this.webSocket.removeEventListener('message', handler);\n        if (message.error) {\n          reject(new Error(`WebView CDP command ${method} failed: ${message.error.message ?? 'unknown error'}`));\n          return;\n        }\n\n        resolve(message.result ?? {});\n      };\n\n      this.webSocket.addEventListener('message', handler);\n      this.webSocket.send(JSON.stringify({ id, method, params }));\n    });\n  }\n\n  /**\n   * Sends an ordered command sequence, one command at a time.\n   *\n   * Each command is awaited before the next is sent, which is the only ordering guarantee an input\n   * sequence needs \u2014 a long-press holds itself for its own `duration` rather than asking the host to\n   * sleep between two touches, so there is no inter-command delay to honor.\n   *\n   * @param commands - The commands to send, in order.\n   */\n  public async sendAll(commands: readonly CdpInputCommand[]): Promise<void> {\n    for (const command of commands) {\n      await this.send(command.method, command.params);\n    }\n  }\n\n  /**\n   * Closes the debugger socket and stops routing its events.\n   */\n  private closeSocket(): void {\n    this.eventHandlers.clear();\n    if (this.webSocket.readyState === WebSocket.OPEN) {\n      this.webSocket.close();\n    }\n  }\n}\n\n/**\n * Opens a CDP connection to the app's WebView.\n *\n * @param params - Which app on which device.\n * @returns The open connection. Dispose it to close the socket and drop the adb port forward.\n */\nexport async function connectToWebViewCdp(params: ConnectToWebViewCdpParams): Promise<WebViewCdpConnection> {\n  const { appId, deviceId } = params;\n\n  // `pidof` lists every matching process; the app's main one is first.\n  const pidofOutput = await adb(deviceId, ['shell', 'pidof', appId]);\n  const pid = pidofOutput.split(/\\s+/, 1)[0] ?? '';\n  if (!pid) {\n    throw new Error(`${appId} is not running on ${deviceId}, so its WebView has no debugger to attach to.`);\n  }\n\n  const procNetUnix = await adb(deviceId, ['shell', 'cat', '/proc/net/unix']);\n  const socketName = parseWebViewDevtoolsSocketName(procNetUnix, pid);\n\n  const forwardList = await adb(deviceId, ['forward', '--list']);\n  const existingPort = parseForwardedPort(forwardList, deviceId, socketName);\n  const port = existingPort ?? await pickFreePort();\n  if (existingPort === undefined) {\n    await adb(deviceId, ['forward', `tcp:${String(port)}`, `localabstract:${socketName}`]);\n    log(`[webview-cdp] Forwarded tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);\n  } else {\n    log(`[webview-cdp] Reusing forward tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);\n  }\n\n  try {\n    const response = await fetch(`http://${CDP_HOST}:${String(port)}/json`);\n    const target = selectWebViewPageTarget(await response.json() as CdpTarget[]);\n    const webSocket = new WebSocket(target.webSocketDebuggerUrl ?? '');\n    await new Promise<void>((resolve, reject) => {\n      webSocket.addEventListener('open', () => {\n        resolve();\n      }, { once: true });\n      webSocket.addEventListener('error', () => {\n        reject(new Error(`Could not open the WebView CDP socket at ${target.webSocketDebuggerUrl ?? ''}.`));\n      }, { once: true });\n    });\n    log(`[webview-cdp] Attached to WebView target \"${target.title ?? ''}\"`);\n\n    return new WebViewCdpConnection(webSocket, deviceId, port);\n  } catch (error: unknown) {\n    await removeForward(deviceId, port);\n    throw error;\n  }\n}\n\n/* v8 ignore stop */\n\n/**\n * Finds a port already forwarded to this device socket, so repeated runs reuse one forward.\n *\n * Without this every run allocates a fresh port, and any run that exits without the async\n * {@link WebViewCdpConnection.dispose} \u2014 an abrupt worker exit, where only the synchronous teardown\n * path runs \u2014 leaves its forward behind forever. Reuse bounds that to a single forward per socket\n * rather than one per run.\n *\n * @param forwardList - The output of `adb forward --list`.\n * @param deviceId - The adb device id to match.\n * @param socketName - The abstract socket name to match.\n * @returns The already-forwarded local port, or `undefined` when there is none.\n */\nexport function parseForwardedPort(forwardList: string, deviceId: string, socketName: string): number | undefined {\n  for (const line of forwardList.split('\\n')) {\n    // `adb forward --list` prints `<deviceId> tcp:<port> localabstract:<socketName>`.\n    const [lineDeviceId, local, remote] = line.trim().split(/\\s+/, FORWARD_LIST_COLUMN_COUNT);\n    if (lineDeviceId !== deviceId || remote !== `localabstract:${socketName}` || !local?.startsWith('tcp:')) {\n      continue;\n    }\n\n    const port = Number.parseInt(local.slice('tcp:'.length), DECIMAL_RADIX);\n    if (Number.isSafeInteger(port)) {\n      return port;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Picks the WebView's devtools socket name out of `/proc/net/unix`.\n *\n * A device can host several debuggable WebViews (other apps, a leftover process), so the app's own pid is\n * what disambiguates them. When no socket matches that pid the sole remaining candidate is used \u2014 a\n * WebView whose socket is named after a child process rather than the one `pidof` reported still has to be\n * reachable \u2014 but two unattributable candidates is ambiguous enough to refuse.\n *\n * @param procNetUnix - The contents of `/proc/net/unix`.\n * @param pid - The application's process id.\n * @returns The socket name, e.g. `webview_devtools_remote_18056`.\n */\nexport function parseWebViewDevtoolsSocketName(procNetUnix: string, pid: string): string {\n  // The whole match minus its leading `@`, rather than a named capture group: a mandatory group is always\n  // Present once the pattern has matched, so `match.groups?.['name'] ?? ''` would leave behind two branches\n  // No input can ever reach \u2014 and this file is measured against a 100% branch gate.\n  const names = [\n    ...new Set([...procNetUnix.matchAll(/@webview_devtools_remote_\\w+/g)]\n      .map((match) => match[0].slice('@'.length)))\n  ];\n\n  // Destructured rather than indexed for the same reason: `soleName` carries the \"there is at least one\"\n  // Fact in the type, so neither the empty check below nor the single-candidate one leaves a dead branch.\n  const [soleName, ...otherNames] = names;\n\n  if (soleName === undefined) {\n    throw new Error(\n      'No `webview_devtools_remote_*` socket on the device. Obsidian Mobile is not running, or its WebView '\n        + 'debugger is disabled.'\n    );\n  }\n\n  const exactName = `webview_devtools_remote_${pid}`;\n  if (names.includes(exactName)) {\n    return exactName;\n  }\n\n  if (otherNames.length === 0) {\n    return soleName;\n  }\n\n  throw new Error(\n    `No \\`${exactName}\\` socket, and ${String(names.length)} other debuggable WebViews are present `\n      + `(${names.join(', ')}), so the right one cannot be chosen.`\n  );\n}\n\n/**\n * Picks the Obsidian page target out of the debugger's `/json` list.\n *\n * @param targets - The `/json` response.\n * @returns The page target to attach to.\n */\nexport function selectWebViewPageTarget(targets: readonly CdpTarget[]): CdpTarget {\n  const target = targets.find((candidate) => candidate.type === 'page' && Boolean(candidate.webSocketDebuggerUrl))\n    ?? targets.find((candidate) => Boolean(candidate.webSocketDebuggerUrl));\n\n  if (!target) {\n    throw new Error('The WebView debugger listed no target with a WebSocket endpoint.');\n  }\n\n  return target;\n}\n\n/* v8 ignore start -- Integration-time code (adb shell-outs). Covered by the Android integration tests, not by unit tests. */\n\n/**\n * Runs an adb command against one device.\n *\n * @param deviceId - The adb device id.\n * @param commandArguments - The adb arguments after `-s <deviceId>`.\n * @returns Trimmed stdout.\n */\nasync function adb(deviceId: string, commandArguments: string[]): Promise<string> {\n  const stdout = await exec(['adb', '-s', deviceId, ...commandArguments], {\n    isQuiet: true,\n    timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS\n  });\n\n  return stdout.trim();\n}\n\n/**\n * Drops an adb port forward, ignoring the \"not found\" case.\n *\n * @param deviceId - The adb device id.\n * @param port - The forwarded local port.\n */\nasync function removeForward(deviceId: string, port: number): Promise<void> {\n  try {\n    await exec(['adb', '-s', deviceId, 'forward', '--remove', `tcp:${String(port)}`], {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS\n    });\n  } catch {\n    // Best effort: the forward is per-run and adb drops it when the device disconnects anyway.\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/webview-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * A second, independent Chrome DevTools Protocol connection to Obsidian Mobile's WebView, used to inject\n * **trusted** input on Android (see **L39**).\n *\n * It is deliberately separate from the Appium session rather than layered on it. `AppiumTransport.evaluate`\n * runs the whole `evalInObsidian` closure inside one W3C *Execute Script*, which awaits the returned\n * promise \u2014 so while a closure sits waiting on `lib.clickElement(...)`, the WebDriver session is busy and\n * cannot be asked to do anything else. CDP is id-multiplexed and Chromium accepts multiple debugger\n * clients, so this socket stays free exactly when the Appium one does not. That is what lets the renderer\n * call back out to the host mid-closure.\n *\n * Reaching the WebView's debugger is a two-step: the app publishes an abstract unix socket named\n * `webview_devtools_remote_<pid>`, `adb forward` maps it to a local TCP port, and the usual `/json`\n * endpoint then lists the page targets.\n */\n\nimport { execFileSync } from 'node:child_process';\n\nimport type { CdpInputCommand } from './mobile-input.mjs';\n\nimport { exec } from './exec.mjs';\nimport { log } from './log.mjs';\nimport { pickFreePort } from './obsidian-instance.mjs';\n\nconst ADB_TIMEOUT_IN_MILLISECONDS = 15_000;\n// `adb forward --list` prints three columns: `<deviceId> tcp:<port> localabstract:<socketName>`.\nconst FORWARD_LIST_COLUMN_COUNT = 3;\nconst DECIMAL_RADIX = 10;\n/*\n * Bounds one command on THIS side channel \u2014 an `Input.dispatchMouseEvent`, a target list. It is not the\n * per-eval cap and must not be derived from `DEFAULT_EVAL_CAP_IN_MILLISECONDS`: no test closure travels\n * this socket, and the whole point of the second connection is that it stays free while the Appium session\n * is busy running one. The shared value is a coincidence.\n */\nconst CDP_COMMAND_TIMEOUT_IN_MILLISECONDS = 30_000;\nconst CDP_HOST = '127.0.0.1';\n\n/**\n * One entry of the debugger's `/json` target list.\n */\nexport interface CdpTarget {\n  readonly title?: string;\n  readonly type?: string;\n  readonly url?: string;\n  readonly webSocketDebuggerUrl?: string;\n}\n\n/**\n * Parameters for {@link connectToWebViewCdp}.\n */\nexport interface ConnectToWebViewCdpParams {\n  /**\n   * The Android application id whose WebView to attach to, e.g. `md.obsidian`.\n   */\n  readonly appId: string;\n\n  /**\n   * The adb device id (`emulator-5554`, a serial) to run adb against.\n   */\n  readonly deviceId: string;\n}\n\n/**\n * The error half of a failed CDP command response.\n */\ninterface CdpError {\n  readonly message?: string;\n}\n\n/**\n * Handles a CDP event.\n */\ntype CdpEventHandler = (params: Record<string, unknown>) => void;\n\n/**\n * A CDP message: either a response to a command (`id`) or an event (`method`).\n */\ninterface CdpMessage {\n  readonly error?: CdpError;\n  readonly id?: number;\n  readonly method?: string;\n  readonly params?: Record<string, unknown>;\n  readonly result?: Record<string, unknown>;\n}\n\n/**\n * A command waiting for its reply: settles the {@link WebViewCdpConnection.send}\n * call's promise and cancels the timeout that would otherwise fail it.\n */\ntype PendingCommand = (message: CdpMessage) => void;\n\n/* v8 ignore start -- Integration-time code (a live WebSocket to a WebView, adb port forwarding). Covered by the Android integration tests, not by unit tests. It ends before `parseForwardedPort`: `perfectionist/sort-modules` places the pure, unit-tested helpers AFTER this class and `connectToWebViewCdp`, so they must stay measured. */\n\n/**\n * An open CDP connection to a WebView.\n *\n * Commands are id-multiplexed, so a command issued from inside an event handler completes while an earlier\n * `Runtime.evaluate` is still awaiting its promise \u2014 which is the whole reason this class exists.\n */\nexport class WebViewCdpConnection {\n  /**\n   * Whether the socket is still usable.\n   *\n   * Restarting the app tears its WebView down and takes the debugger target with it, so a cached\n   * connection has to be re-checked rather than assumed live.\n   *\n   * @returns `true` while the socket is open.\n   */\n  public get isOpen(): boolean {\n    return this.webSocket.readyState === WebSocket.OPEN;\n  }\n\n  private readonly eventHandlers = new Map<string, CdpEventHandler>();\n\n  private messageId = 0;\n\n  /**\n   * The commands still waiting for a reply, keyed by the CDP message id each was\n   * sent with. Emptied by whichever of the reply and the timeout comes first.\n   */\n  private readonly pendingCommands = new Map<number, PendingCommand>();\n\n  /**\n   * Wraps an already-open debugger socket, plus what is needed to tear its port forward down.\n   *\n   * ONE `message` listener for the socket's whole life, routing both halves of what\n   * arrives \u2014 CDP events to their subscribed handler, command replies to the\n   * {@link send} call waiting on the id. A listener per in-flight command instead\n   * would make the count scale with concurrency, so eleven commands in flight at\n   * once would cross Node's default `maxListeners` of 10 and report a memory leak\n   * that is not one (see the desktop transport's `getPendingCommands`, where the\n   * same shape was measured).\n   *\n   * The parse is guarded because a frame this connection cannot read belongs to\n   * nothing it sent: throwing here would throw out of the event dispatch, where\n   * nothing can catch it.\n   *\n   * @param webSocket - The open debugger socket.\n   * @param deviceId - The adb device id, needed to drop the port forward on dispose.\n   * @param port - The forwarded local port.\n   */\n  public constructor(private readonly webSocket: WebSocket, private readonly deviceId: string, private readonly port: number) {\n    this.webSocket.addEventListener('message', (event: MessageEvent) => {\n      let message: CdpMessage;\n      try {\n        message = JSON.parse(String(event.data)) as CdpMessage;\n      } catch {\n        return;\n      }\n\n      if (message.method !== undefined) {\n        this.eventHandlers.get(message.method)?.(message.params ?? {});\n        return;\n      }\n\n      if (message.id === undefined) {\n        return;\n      }\n\n      const pendingCommand = this.pendingCommands.get(message.id);\n      if (!pendingCommand) {\n        return;\n      }\n\n      this.pendingCommands.delete(message.id);\n      pendingCommand(message);\n    });\n  }\n\n  /**\n   * Closes the socket and drops the adb port forward.\n   */\n  public async dispose(): Promise<void> {\n    this.closeSocket();\n    await removeForward(this.deviceId, this.port);\n  }\n\n  /**\n   * Synchronous disposal, for `process.on('exit')` handlers where async work cannot run.\n   *\n   * Without this an abrupt worker exit leaves the port forward behind \u2014 the async {@link dispose} above\n   * never gets a turn.\n   */\n  public disposeSync(): void {\n    this.closeSocket();\n    try {\n      execFileSync('adb', ['-s', this.deviceId, 'forward', '--remove', `tcp:${String(this.port)}`], {\n        stdio: 'ignore',\n        timeout: ADB_TIMEOUT_IN_MILLISECONDS\n      });\n    } catch {\n      // Best effort: adb drops every forward when the device disconnects anyway.\n    }\n  }\n\n  /**\n   * Subscribes to a CDP event. One handler per method; subscribing again replaces it.\n   *\n   * @param method - The CDP event name, e.g. `Runtime.bindingCalled`.\n   * @param handler - Called with the event parameters.\n   */\n  public on(method: string, handler: CdpEventHandler): void {\n    this.eventHandlers.set(method, handler);\n  }\n\n  /**\n   * Sends a CDP command and waits for its response.\n   *\n   * @param method - The CDP method name.\n   * @param params - The CDP method parameters.\n   * @returns The command result.\n   */\n  public send(method: string, params: Record<string, unknown> = {}): Promise<Record<string, unknown>> {\n    const id = ++this.messageId;\n\n    return new Promise<Record<string, unknown>>((resolve, reject) => {\n      const timeout = setTimeout(() => {\n        this.pendingCommands.delete(id);\n        reject(new Error(`WebView CDP command timed out after ${String(CDP_COMMAND_TIMEOUT_IN_MILLISECONDS)}ms: ${method}`));\n      }, CDP_COMMAND_TIMEOUT_IN_MILLISECONDS);\n\n      this.pendingCommands.set(id, (message) => {\n        clearTimeout(timeout);\n        if (message.error) {\n          reject(new Error(`WebView CDP command ${method} failed: ${message.error.message ?? 'unknown error'}`));\n          return;\n        }\n\n        resolve(message.result ?? {});\n      });\n\n      try {\n        this.webSocket.send(JSON.stringify({ id, method, params }));\n      } catch (error: unknown) {\n        // Nothing will answer a send that threw, so holding the entry for the full timeout would only delay the failure and then misname it.\n        clearTimeout(timeout);\n        this.pendingCommands.delete(id);\n        reject(error instanceof Error ? error : new Error(String(error)));\n      }\n    });\n  }\n\n  /**\n   * Sends an ordered command sequence, one command at a time.\n   *\n   * Each command is awaited before the next is sent, which is the only ordering guarantee an input\n   * sequence needs \u2014 a long-press holds itself for its own `duration` rather than asking the host to\n   * sleep between two touches, so there is no inter-command delay to honor.\n   *\n   * @param commands - The commands to send, in order.\n   */\n  public async sendAll(commands: readonly CdpInputCommand[]): Promise<void> {\n    for (const command of commands) {\n      await this.send(command.method, command.params);\n    }\n  }\n\n  /**\n   * Closes the debugger socket and stops routing its events.\n   */\n  private closeSocket(): void {\n    this.eventHandlers.clear();\n    if (this.webSocket.readyState === WebSocket.OPEN) {\n      this.webSocket.close();\n    }\n  }\n}\n\n/**\n * Opens a CDP connection to the app's WebView.\n *\n * @param params - Which app on which device.\n * @returns The open connection. Dispose it to close the socket and drop the adb port forward.\n */\nexport async function connectToWebViewCdp(params: ConnectToWebViewCdpParams): Promise<WebViewCdpConnection> {\n  const { appId, deviceId } = params;\n\n  // `pidof` lists every matching process; the app's main one is first.\n  const pidofOutput = await adb(deviceId, ['shell', 'pidof', appId]);\n  const pid = pidofOutput.split(/\\s+/, 1)[0] ?? '';\n  if (!pid) {\n    throw new Error(`${appId} is not running on ${deviceId}, so its WebView has no debugger to attach to.`);\n  }\n\n  const procNetUnix = await adb(deviceId, ['shell', 'cat', '/proc/net/unix']);\n  const socketName = parseWebViewDevtoolsSocketName(procNetUnix, pid);\n\n  const forwardList = await adb(deviceId, ['forward', '--list']);\n  const existingPort = parseForwardedPort(forwardList, deviceId, socketName);\n  const port = existingPort ?? await pickFreePort();\n  if (existingPort === undefined) {\n    await adb(deviceId, ['forward', `tcp:${String(port)}`, `localabstract:${socketName}`]);\n    log(`[webview-cdp] Forwarded tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);\n  } else {\n    log(`[webview-cdp] Reusing forward tcp:${String(port)} -> localabstract:${socketName} (${appId} pid ${pid})`);\n  }\n\n  try {\n    const response = await fetch(`http://${CDP_HOST}:${String(port)}/json`);\n    const target = selectWebViewPageTarget(await response.json() as CdpTarget[]);\n    const webSocket = new WebSocket(target.webSocketDebuggerUrl ?? '');\n    await new Promise<void>((resolve, reject) => {\n      webSocket.addEventListener('open', () => {\n        resolve();\n      }, { once: true });\n      webSocket.addEventListener('error', () => {\n        reject(new Error(`Could not open the WebView CDP socket at ${target.webSocketDebuggerUrl ?? ''}.`));\n      }, { once: true });\n    });\n    log(`[webview-cdp] Attached to WebView target \"${target.title ?? ''}\"`);\n\n    return new WebViewCdpConnection(webSocket, deviceId, port);\n  } catch (error: unknown) {\n    await removeForward(deviceId, port);\n    throw error;\n  }\n}\n\n/* v8 ignore stop */\n\n/**\n * Finds a port already forwarded to this device socket, so repeated runs reuse one forward.\n *\n * Without this every run allocates a fresh port, and any run that exits without the async\n * {@link WebViewCdpConnection.dispose} \u2014 an abrupt worker exit, where only the synchronous teardown\n * path runs \u2014 leaves its forward behind forever. Reuse bounds that to a single forward per socket\n * rather than one per run.\n *\n * @param forwardList - The output of `adb forward --list`.\n * @param deviceId - The adb device id to match.\n * @param socketName - The abstract socket name to match.\n * @returns The already-forwarded local port, or `undefined` when there is none.\n */\nexport function parseForwardedPort(forwardList: string, deviceId: string, socketName: string): number | undefined {\n  for (const line of forwardList.split('\\n')) {\n    // `adb forward --list` prints `<deviceId> tcp:<port> localabstract:<socketName>`.\n    const [lineDeviceId, local, remote] = line.trim().split(/\\s+/, FORWARD_LIST_COLUMN_COUNT);\n    if (lineDeviceId !== deviceId || remote !== `localabstract:${socketName}` || !local?.startsWith('tcp:')) {\n      continue;\n    }\n\n    const port = Number.parseInt(local.slice('tcp:'.length), DECIMAL_RADIX);\n    if (Number.isSafeInteger(port)) {\n      return port;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Picks the WebView's devtools socket name out of `/proc/net/unix`.\n *\n * A device can host several debuggable WebViews (other apps, a leftover process), so the app's own pid is\n * what disambiguates them. When no socket matches that pid the sole remaining candidate is used \u2014 a\n * WebView whose socket is named after a child process rather than the one `pidof` reported still has to be\n * reachable \u2014 but two unattributable candidates is ambiguous enough to refuse.\n *\n * @param procNetUnix - The contents of `/proc/net/unix`.\n * @param pid - The application's process id.\n * @returns The socket name, e.g. `webview_devtools_remote_18056`.\n */\nexport function parseWebViewDevtoolsSocketName(procNetUnix: string, pid: string): string {\n  // The whole match minus its leading `@`, rather than a named capture group: a mandatory group is always\n  // present once the pattern has matched, so `match.groups?.['name'] ?? ''` would leave behind two branches\n  // no input can ever reach \u2014 and this file is measured against a 100% branch gate.\n  const names = [\n    ...new Set([...procNetUnix.matchAll(/@webview_devtools_remote_\\w+/g)]\n      .map((match) => match[0].slice('@'.length)))\n  ];\n\n  // Destructured rather than indexed for the same reason: `soleName` carries the \"there is at least one\"\n  // fact in the type, so neither the empty check below nor the single-candidate one leaves a dead branch.\n  const [soleName, ...otherNames] = names;\n\n  if (soleName === undefined) {\n    throw new Error(\n      'No `webview_devtools_remote_*` socket on the device. Obsidian Mobile is not running, or its WebView '\n        + 'debugger is disabled.'\n    );\n  }\n\n  const exactName = `webview_devtools_remote_${pid}`;\n  if (names.includes(exactName)) {\n    return exactName;\n  }\n\n  if (otherNames.length === 0) {\n    return soleName;\n  }\n\n  throw new Error(\n    `No \\`${exactName}\\` socket, and ${String(names.length)} other debuggable WebViews are present `\n      + `(${names.join(', ')}), so the right one cannot be chosen.`\n  );\n}\n\n/**\n * Picks the Obsidian page target out of the debugger's `/json` list.\n *\n * @param targets - The `/json` response.\n * @returns The page target to attach to.\n */\nexport function selectWebViewPageTarget(targets: readonly CdpTarget[]): CdpTarget {\n  const target = targets.find((candidate) => candidate.type === 'page' && Boolean(candidate.webSocketDebuggerUrl))\n    ?? targets.find((candidate) => Boolean(candidate.webSocketDebuggerUrl));\n\n  if (!target) {\n    throw new Error('The WebView debugger listed no target with a WebSocket endpoint.');\n  }\n\n  return target;\n}\n\n/* v8 ignore start -- Integration-time code (adb shell-outs). Covered by the Android integration tests, not by unit tests. */\n\n/**\n * Runs an adb command against one device.\n *\n * @param deviceId - The adb device id.\n * @param commandArguments - The adb arguments after `-s <deviceId>`.\n * @returns Trimmed stdout.\n */\nasync function adb(deviceId: string, commandArguments: string[]): Promise<string> {\n  const stdout = await exec(['adb', '-s', deviceId, ...commandArguments], {\n    isQuiet: true,\n    timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS\n  });\n\n  return stdout.trim();\n}\n\n/**\n * Drops an adb port forward, ignoring the \"not found\" case.\n *\n * @param deviceId - The adb device id.\n * @param port - The forwarded local port.\n */\nasync function removeForward(deviceId: string, port: number): Promise<void> {\n  try {\n    await exec(['adb', '-s', deviceId, 'forward', '--remove', `tcp:${String(port)}`], {\n      isQuiet: true,\n      shouldIgnoreExitCode: true,\n      timeoutInMilliseconds: ADB_TIMEOUT_IN_MILLISECONDS\n    });\n  } catch {\n    // Best effort: the forward is per-run and adb drops it when the device disconnects anyway.\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "obsidian-integration-testing",
-  "version": "12.2.0",
+  "version": "13.0.0",
   "description": "Simplifies integration testing of Obsidian plugins.",
   "keywords": [
     "obsidian",
@@ -165,18 +165,12 @@
   "overrides": {
     "@puppeteer/browsers": "^3.2.2",
     "@sinonjs/fake-timers": "13.0.5",
-    "brace-expansion": "^5.0.9",
     "deepmerge-ts": "^8.0.2",
     "eslint-plugin-import": "$eslint-plugin-import-x",
     "fflate": "^0.8.3",
-    "glob": "^13.0.6",
     "js-yaml": "4.3.2",
     "lodash": "4.18.1",
-    "markdown-it": "^15.0.2",
-    "readdir-glob": "^3.0.0",
     "smol-toml": "^1.8.0",
-    "test-exclude": "^8.0.0",
-    "tmp": "^0.2.7",
     "type-fest": "$type-fest",
     "typescript": "$typescript",
     "vite": "$vite"