obsidian-integration-testing 8.0.1 → 8.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (65) hide show
  1. package/README.md +23 -4
  2. package/dist/lib/cjs/cli.cjs +29 -8
  3. package/dist/lib/cjs/cli.d.cts +2 -1
  4. package/dist/lib/cjs/connect-to-cdp.cjs +17 -11
  5. package/dist/lib/cjs/connect-to-cdp.d.cts +35 -3
  6. package/dist/lib/cjs/context-provider.cjs +1 -1
  7. package/dist/lib/cjs/context-provider.d.cts +1 -1
  8. package/dist/lib/cjs/global-setup-core.cjs +17 -5
  9. package/dist/lib/cjs/global-setup-core.d.cts +11 -1
  10. package/dist/lib/cjs/incompatible-installer-version-error.cjs +52 -0
  11. package/dist/lib/cjs/incompatible-installer-version-error.d.cts +44 -0
  12. package/dist/lib/cjs/index.cjs +13 -1
  13. package/dist/lib/cjs/index.d.cts +7 -0
  14. package/dist/lib/cjs/installer-compatibility.cjs +64 -0
  15. package/dist/lib/cjs/installer-compatibility.d.cts +75 -0
  16. package/dist/lib/cjs/library.cjs +1 -1
  17. package/dist/lib/cjs/namespace-bootstrap.cjs +16 -7
  18. package/dist/lib/cjs/obsidian-installer.cjs +7 -4
  19. package/dist/lib/cjs/obsidian-metadata.cjs +1811 -0
  20. package/dist/lib/cjs/obsidian-metadata.d.cts +56 -0
  21. package/dist/lib/cjs/renderer-boot-detection.cjs +49 -0
  22. package/dist/lib/cjs/renderer-boot-detection.d.cts +83 -0
  23. package/dist/lib/cjs/renderer-failed-to-initialize-error.cjs +41 -0
  24. package/dist/lib/cjs/renderer-failed-to-initialize-error.d.cts +23 -0
  25. package/dist/lib/cjs/transport-desktop-cdp.cjs +85 -3
  26. package/dist/lib/cjs/transport-desktop-cdp.d.cts +55 -1
  27. package/dist/lib/cjs/transport-factory.cjs +76 -21
  28. package/dist/lib/cjs/transport-factory.d.cts +1 -1
  29. package/dist/lib/cjs/transport-options.cjs +1 -1
  30. package/dist/lib/cjs/transport-options.d.cts +37 -4
  31. package/dist/lib/cjs/visibility.cjs +10 -2
  32. package/dist/lib/cjs/visibility.d.cts +27 -8
  33. package/dist/lib/esm/cli.d.mts +2 -1
  34. package/dist/lib/esm/cli.mjs +29 -8
  35. package/dist/lib/esm/connect-to-cdp.d.mts +35 -3
  36. package/dist/lib/esm/connect-to-cdp.mjs +17 -11
  37. package/dist/lib/esm/context-provider.d.mts +1 -1
  38. package/dist/lib/esm/context-provider.mjs +1 -1
  39. package/dist/lib/esm/global-setup-core.d.mts +11 -1
  40. package/dist/lib/esm/global-setup-core.mjs +15 -4
  41. package/dist/lib/esm/incompatible-installer-version-error.d.mts +44 -0
  42. package/dist/lib/esm/incompatible-installer-version-error.mjs +28 -0
  43. package/dist/lib/esm/index.d.mts +7 -0
  44. package/dist/lib/esm/index.mjs +9 -1
  45. package/dist/lib/esm/installer-compatibility.d.mts +75 -0
  46. package/dist/lib/esm/installer-compatibility.mjs +40 -0
  47. package/dist/lib/esm/library.mjs +1 -1
  48. package/dist/lib/esm/namespace-bootstrap.mjs +16 -7
  49. package/dist/lib/esm/obsidian-installer.mjs +7 -4
  50. package/dist/lib/esm/obsidian-metadata.d.mts +56 -0
  51. package/dist/lib/esm/obsidian-metadata.mjs +1787 -0
  52. package/dist/lib/esm/renderer-boot-detection.d.mts +83 -0
  53. package/dist/lib/esm/renderer-boot-detection.mjs +23 -0
  54. package/dist/lib/esm/renderer-failed-to-initialize-error.d.mts +23 -0
  55. package/dist/lib/esm/renderer-failed-to-initialize-error.mjs +17 -0
  56. package/dist/lib/esm/transport-desktop-cdp.d.mts +55 -1
  57. package/dist/lib/esm/transport-desktop-cdp.mjs +89 -3
  58. package/dist/lib/esm/transport-factory.d.mts +1 -1
  59. package/dist/lib/esm/transport-factory.mjs +76 -21
  60. package/dist/lib/esm/transport-options.d.mts +37 -4
  61. package/dist/lib/esm/visibility.d.mts +27 -8
  62. package/dist/lib/esm/visibility.mjs +8 -2
  63. package/dist/obsidian-integration-testing-8.1.1.tgz +0 -0
  64. package/package.json +2 -3
  65. package/dist/obsidian-integration-testing-8.0.1.tgz +0 -0
package/dist/lib/cjs/transport-options.d.cts CHANGED
@@ -166,6 +166,24 @@ export interface ObsidianCdpTransportOptions {
166
166
  * Defaults to 30000
167
167
  */
168
168
  readonly commandTimeoutInMilliseconds?: number;
169
+ /**
170
+ * Grace window in milliseconds for fast-failing a **dead boot** of the owned
171
+ * instance.
172
+ *
173
+ * When an asar cannot run on the launched Electron shell (the installer
174
+ * version is too old for the app version), the renderer loads but never
175
+ * bootstraps: `document.body` stays empty and `window.app` remains
176
+ * `undefined` — a black screen. Rather than waiting out the full readiness
177
+ * timeout, the owned-vault readiness poll concludes the boot is dead once the
178
+ * renderer has been `document.readyState` `'complete'` for this long with no
179
+ * `window.app` and an empty `<body>`, and throws a
180
+ * `RendererFailedToInitializeError`. Only applies to an owned instance
181
+ * (ignored in attach mode, {@link port} set). Set `0` to disable fast-fail and
182
+ * restore the plain wait-out-the-readiness-timeout behavior.
183
+ *
184
+ * @default `10000`
185
+ */
186
+ readonly deadBootGraceInMilliseconds?: number;
169
187
  /**
170
188
  * CDP host.
171
189
  * Defaults to `'localhost'`
@@ -190,16 +208,17 @@ export interface ObsidianCdpTransportOptions {
190
208
  /**
191
209
  * Whether the owned desktop Obsidian window is shown on screen.
192
210
  *
193
- * When `false` (the default), the harness launches the owned instance with
211
+ * When `false`, the harness launches the owned instance with
194
212
  * keep-alive Chromium flags and moves its window **off-screen** once Electron's
195
213
  * remote bridge is available, so the run never steals focus or pops a window in
196
214
  * front of you. Off-screen (not minimized) keeps the renderer live, so
197
215
  * `setTimeout`, `requestAnimationFrame`, `:hover`, and trusted input behave
198
- * identically to a visible window. Set `true` to watch the window (e.g. when
199
- * debugging). Ignored in attach mode ({@link port} set) — the harness never
216
+ * identically to a visible window. Defaults to `true`; integration setup
217
+ * explicitly passes `false` to avoid stealing focus. Ignored in attach mode
218
+ * ({@link port} set) — the harness never
200
219
  * moves the user's own running window.
201
220
  *
202
- * @default `false`
221
+ * @default `true`
203
222
  */
204
223
  readonly isObsidianAppVisible?: boolean;
205
224
  /**
@@ -235,6 +254,20 @@ export interface ObsidianCdpTransportOptions {
235
254
  * @default `undefined`
236
255
  */
237
256
  readonly port?: number;
257
+ /**
258
+ * Whether to launch the owned instance with Chromium's sandbox disabled
259
+ * (`--no-sandbox`).
260
+ *
261
+ * Needed to boot an owned instance on Linux when there is no
262
+ * correctly-configured setuid `chrome-sandbox` helper — e.g. a portable shell
263
+ * extracted from an installer, or a CI runner launching as a non-root user, in
264
+ * which case the renderer otherwise refuses to start. Harmless on
265
+ * Windows/macOS. Ignored in attach mode ({@link port} set) — the harness never
266
+ * relaunches the user's running instance.
267
+ *
268
+ * @default `false`
269
+ */
270
+ readonly shouldDisableSandbox?: boolean;
238
271
  /**
239
272
  * Discriminant for the transport type.
240
273
  */
package/dist/lib/cjs/visibility.cjs CHANGED
@@ -18,8 +18,10 @@ var __copyProps = (to, from, except, desc) => {
18
18
  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
19
19
  var visibility_exports = {};
20
20
  __export(visibility_exports, {
21
+ NO_SANDBOX_LAUNCH_FLAG: () => NO_SANDBOX_LAUNCH_FLAG,
21
22
  OWNED_HIDDEN_LAUNCH_FLAGS: () => OWNED_HIDDEN_LAUNCH_FLAGS,
22
23
  resolveOwnedHiddenLaunchArgs: () => resolveOwnedHiddenLaunchArgs,
24
+ resolveSandboxLaunchArgs: () => resolveSandboxLaunchArgs,
23
25
  shouldHideAppiumConsole: () => shouldHideAppiumConsole,
24
26
  shouldHideEmulatorWindow: () => shouldHideEmulatorWindow,
25
27
  shouldHideObsidianApp: () => shouldHideObsidianApp
@@ -31,9 +33,13 @@ const OWNED_HIDDEN_LAUNCH_FLAGS = [
31
33
  "--disable-backgrounding-occluded-windows",
32
34
  "--disable-renderer-backgrounding"
33
35
  ];
36
+ const NO_SANDBOX_LAUNCH_FLAG = "--no-sandbox";
34
37
  function resolveOwnedHiddenLaunchArgs(isObsidianAppVisible) {
35
38
  return shouldHideObsidianApp(isObsidianAppVisible) ? [...OWNED_HIDDEN_LAUNCH_FLAGS] : [];
36
39
  }
40
+ function resolveSandboxLaunchArgs(shouldDisableSandbox) {
41
+ return shouldDisableSandbox ?? false ? [NO_SANDBOX_LAUNCH_FLAG] : [];
42
+ }
37
43
  function shouldHideAppiumConsole(isAppiumConsoleVisible) {
38
44
  return !(isAppiumConsoleVisible ?? false);
39
45
  }
@@ -41,14 +47,16 @@ function shouldHideEmulatorWindow(isEmulatorVisible) {
41
47
  return !(isEmulatorVisible ?? false);
42
48
  }
43
49
  function shouldHideObsidianApp(isObsidianAppVisible) {
44
- return !(isObsidianAppVisible ?? false);
50
+ return !(isObsidianAppVisible ?? true);
45
51
  }
46
52
  // Annotate the CommonJS export names for ESM import in node:
47
53
  0 && (module.exports = {
54
+ NO_SANDBOX_LAUNCH_FLAG,
48
55
  OWNED_HIDDEN_LAUNCH_FLAGS,
49
56
  resolveOwnedHiddenLaunchArgs,
57
+ resolveSandboxLaunchArgs,
50
58
  shouldHideAppiumConsole,
51
59
  shouldHideEmulatorWindow,
52
60
  shouldHideObsidianApp
53
61
  });
54
- //# sourceMappingURL=data:application/json;base64,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
62
+ //# sourceMappingURL=data:application/json;base64,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
package/dist/lib/cjs/visibility.d.cts CHANGED
@@ -3,9 +3,9 @@
3
3
  *
4
4
  * Pure resolution of the process-visibility options — whether the launched
5
5
  * desktop Obsidian window, Android emulator window, and Appium server console
6
- * are shown on screen. All three surfaces are **hidden by default** (`is*Visible`
7
- * is `false` when omitted) so an integration run never steals focus or pops
8
- * windows in front of the user.
6
+ * are shown on screen. The desktop application is visible by default; integration
7
+ * setup explicitly requests an off-screen instance so test runs do not steal
8
+ * focus. Android surfaces are hidden by default.
9
9
  *
10
10
  * Kept separate from the integration-only launch/spawn code (`transport-factory`,
11
11
  * `transport-desktop-cdp`, `obsidian-instance`, all excluded from unit tests) so
@@ -28,15 +28,34 @@
28
28
  * the window off-screen rather than minimizing it.
29
29
  */
30
30
  export declare const OWNED_HIDDEN_LAUNCH_FLAGS: string[];
31
+ /**
32
+ * Chromium switch that disables the setuid sandbox for an owned instance.
33
+ *
34
+ * Electron's Linux sandbox needs a correctly-configured (root-owned, setuid)
35
+ * `chrome-sandbox` helper. A portable shell extracted from an installer — and a
36
+ * CI runner launching it as a non-root user — has no such helper, so the
37
+ * renderer refuses to start ("The SUID sandbox helper binary was found, but is
38
+ * not configured correctly"). Passing `--no-sandbox` disables it. It is harmless
39
+ * on Windows/macOS (their sandbox is unaffected by extraction), so an owned test
40
+ * instance can pass it uniformly across platforms.
41
+ */
42
+ export declare const NO_SANDBOX_LAUNCH_FLAG = "--no-sandbox";
31
43
  /**
32
44
  * Resolves the extra Chromium launch args for an owned desktop instance: the
33
- * {@link OWNED_HIDDEN_LAUNCH_FLAGS} when the window is hidden (the default), or
34
- * an empty list when it is visible.
45
+ * {@link OWNED_HIDDEN_LAUNCH_FLAGS} when the window is hidden, or an empty list
46
+ * when it is visible (the default).
35
47
  *
36
- * @param isObsidianAppVisible - The resolved option value (omitted → hidden).
48
+ * @param isObsidianAppVisible - The resolved option value (omitted → visible).
37
49
  * @returns The extra launch args (possibly empty).
38
50
  */
39
51
  export declare function resolveOwnedHiddenLaunchArgs(isObsidianAppVisible?: boolean): string[];
52
+ /**
53
+ * Resolves the extra Chromium launch args for disabling the sandbox.
54
+ *
55
+ * @param shouldDisableSandbox - The resolved option value (omitted → sandbox kept).
56
+ * @returns `[{@link NO_SANDBOX_LAUNCH_FLAG}]` when the sandbox should be disabled, else `[]`.
57
+ */
58
+ export declare function resolveSandboxLaunchArgs(shouldDisableSandbox?: boolean): string[];
40
59
  /**
41
60
  * Whether the auto-started Appium server console window should be hidden.
42
61
  *
@@ -55,7 +74,7 @@ export declare function shouldHideEmulatorWindow(isEmulatorVisible?: boolean): b
55
74
  /**
56
75
  * Whether the owned desktop Obsidian window should be hidden (moved off-screen).
57
76
  *
58
- * @param isObsidianAppVisible - The resolved option value (omitted → hidden).
59
- * @returns `true` when the window should be hidden (the default).
77
+ * @param isObsidianAppVisible - The resolved option value (omitted → visible).
78
+ * @returns `true` when the window should be hidden.
60
79
  */
61
80
  export declare function shouldHideObsidianApp(isObsidianAppVisible?: boolean): boolean;
package/dist/lib/esm/cli.d.mts CHANGED
@@ -8,7 +8,8 @@
8
8
  */
9
9
  /**
10
10
  * Parses CLI arguments, opens the connection, prints its endpoint, and blocks
11
- * until `SIGINT`/`SIGTERM`, disposing the connection on shutdown.
11
+ * until `SIGINT`/`SIGTERM` or the owned Obsidian window is closed, disposing the
12
+ * connection on shutdown.
12
13
  *
13
14
  * @returns A {@link Promise} that resolves once the connection has been disposed.
14
15
  */
package/dist/lib/esm/cli.mjs CHANGED
@@ -23,7 +23,7 @@ Runtime helpers bootstrapped as window.__obsidianIntegrationTesting.
23
23
  Press Ctrl+C to stop.
24
24
  `
25
25
  );
26
- await waitForShutdownSignal();
26
+ await waitForShutdownOrInstanceClose(connection.cdpUrl);
27
27
  process.stdout.write("\nShutting down\u2026\n");
28
28
  await connection.dispose();
29
29
  }
@@ -45,17 +45,38 @@ function parseNumber(flag, raw) {
45
45
  }
46
46
  return value;
47
47
  }
48
- function waitForShutdownSignal() {
48
+ function waitForShutdownOrInstanceClose(cdpUrl) {
49
+ const POLL_INTERVAL_IN_MILLISECONDS = 1e3;
49
50
  return new Promise((resolve) => {
50
- process.once("SIGINT", () => {
51
- resolve();
52
- });
53
- process.once("SIGTERM", () => {
51
+ const versionUrl = `${cdpUrl}/json/version`;
52
+ let isSettled = false;
53
+ const timer = setInterval(() => {
54
+ checkAlive().catch(() => {
55
+ });
56
+ }, POLL_INTERVAL_IN_MILLISECONDS);
57
+ process.once("SIGINT", settle);
58
+ process.once("SIGTERM", settle);
59
+ async function checkAlive() {
60
+ try {
61
+ const response = await fetch(versionUrl);
62
+ if (!response.ok) {
63
+ settle();
64
+ }
65
+ } catch {
66
+ settle();
67
+ }
68
+ }
69
+ function settle() {
70
+ if (isSettled) {
71
+ return;
72
+ }
73
+ isSettled = true;
74
+ clearInterval(timer);
54
75
  resolve();
55
- });
76
+ }
56
77
  });
57
78
  }
58
79
  export {
59
80
  main
60
81
  };
61
- //# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NsaS50cyJdLAogICJzb3VyY2VzQ29udGVudCI6IFsiLyoqXG4gKiBAZmlsZVxuICpcbiAqIFRoaW4gQ0xJIG92ZXIge0BsaW5rIGNvbm5lY3RUb0NkcH06IGxhdW5jaGVzIChvciBhdHRhY2hlcyB0bykgYSBDRFAtZW5hYmxlZFxuICogT2JzaWRpYW4gaW5zdGFuY2Ugd2l0aCB0aGUgcnVudGltZSBoZWxwZXIgbmFtZXNwYWNlIGJvb3RzdHJhcHBlZCwgcHJpbnRzIHRoZVxuICogY2hvc2VuIENEUCBwb3J0L1VSTCwgYW5kIHN0YXlzIGFsaXZlIHVudGlsIGludGVycnVwdGVkIHNvIGFuIGV4dGVybmFsIHRvb2xcbiAqIChyYXcgQ0RQIGB3c2AsIERldlRvb2xzLCBcdTIwMjYpIGNhbiBhdHRhY2guXG4gKi9cblxuLyogdjggaWdub3JlIHN0YXJ0IC0tIEludGVncmF0aW9uLXRpbWUgQ0xJIChsYXVuY2hlcyBPYnNpZGlhbiAvIENEUCkgY292ZXJlZCBtYW51YWxseSwgbm90IGJ5IHVuaXQgdGVzdHMuICovXG5cbmltcG9ydCBwcm9jZXNzIGZyb20gJ25vZGU6cHJvY2Vzcyc7XG5pbXBvcnQgeyBwYXJzZUFyZ3MgfSBmcm9tICdub2RlOnV0aWwnO1xuXG5pbXBvcnQgdHlwZSB7IENvbm5lY3RUb0NkcE9wdGlvbnMgfSBmcm9tICcuL2Nvbm5lY3QtdG8tY2RwLm1qcyc7XG5cbmltcG9ydCB7IGNvbm5lY3RUb0NkcCB9IGZyb20gJy4vY29ubmVjdC10by1jZHAubWpzJztcblxuLyoqXG4gKiBUaGUgc2hhcGUgb2YgdGhlIHBhcnNlZCBDTEkgZmxhZyB2YWx1ZXMuXG4gKi9cbmludGVyZmFjZSBQYXJzZWRDbGlWYWx1ZXMge1xuICAnY29tbWFuZC10aW1lb3V0Jz86IHN0cmluZyB8IHVuZGVmaW5lZDtcbiAgJ2hvc3QnPzogc3RyaW5nIHwgdW5kZWZpbmVkO1xuICAnbm8tcmVtb3ZlLXZhdWx0Jz86IGJvb2xlYW4gfCB1bmRlZmluZWQ7XG4gICdvYnNpZGlhbi1pbnN0YWxsZXItdmVyc2lvbic/OiBzdHJpbmcgfCB1bmRlZmluZWQ7XG4gICdvYnNpZGlhbi12ZXJzaW9uJz86IHN0cmluZyB8IHVuZGVmaW5lZDtcbiAgJ3BvcnQnPzogc3RyaW5nIHwgdW5kZWZpbmVkO1xuICAndmF1bHQnPzogc3RyaW5nIHwgdW5kZWZpbmVkO1xufVxuXG4vKipcbiAqIFBhcnNlcyBDTEkgYXJndW1lbnRzLCBvcGVucyB0aGUgY29ubmVjdGlvbiwgcHJpbnRzIGl0cyBlbmRwb2ludCwgYW5kIGJsb2Nrc1xuICogdW50aWwgYFNJR0lOVGAvYFNJR1RFUk1gLCBkaXNwb3NpbmcgdGhlIGNvbm5lY3Rpb24gb24gc2h1dGRvd24uXG4gKlxuICogQHJldHVybnMgQSB7QGxpbmsgUHJvbWlzZX0gdGhhdCByZXNvbHZlcyBvbmNlIHRoZSBjb25uZWN0aW9uIGhhcyBiZWVuIGRpc3Bvc2VkLlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gbWFpbigpOiBQcm9taXNlPHZvaWQ+IHtcbiAgY29uc3QgeyB2YWx1ZXMgfSA9IHBhcnNlQXJncyh7XG4gICAgb3B0aW9uczoge1xuICAgICAgJ2NvbW1hbmQtdGltZW91dCc6IHsgdHlwZTogJ3N0cmluZycgfSxcbiAgICAgICdob3N0JzogeyB0eXBlOiAnc3RyaW5nJyB9LFxuICAgICAgJ25vLXJlbW92ZS12YXVsdCc6IHsgdHlwZTogJ2Jvb2xlYW4nIH0sXG4gICAgICAnb2JzaWRpYW4taW5zdGFsbGVyLXZlcnNpb24nOiB7IHR5cGU6ICdzdHJpbmcnIH0sXG4gICAgICAnb2JzaWRpYW4tdmVyc2lvbic6IHsgdHlwZTogJ3N0cmluZycgfSxcbiAgICAgICdwb3J0JzogeyB0eXBlOiAnc3RyaW5nJyB9LFxuICAgICAgJ3ZhdWx0JzogeyB0eXBlOiAnc3RyaW5nJyB9XG4gICAgfVxuICB9KTtcblxuICBjb25zdCBjb25uZWN0aW9uID0gYXdhaXQgY29ubmVjdFRvQ2RwKGJ1aWxkT3B0aW9ucyh2YWx1ZXMpKTtcblxuICBwcm9jZXNzLnN0ZG91dC53cml0ZShcbiAgICAnT2JzaWRpYW4gQ0RQIHJlYWR5LlxcbidcbiAgICAgICsgYCAgcG9ydDogICAke1N0cmluZyhjb25uZWN0aW9uLnBvcnQpfVxcbmBcbiAgICAgICsgYCAgY2RwVXJsOiAke2Nvbm5lY3Rpb24uY2RwVXJsfVxcbmBcbiAgICAgICsgYCAgdmF1bHQ6ICAke2Nvbm5lY3Rpb24udmF1bHQucGF0aH1cXG5gXG4gICAgICArICdSdW50aW1lIGhlbHBlcnMgYm9vdHN0cmFwcGVkIGFzIHdpbmRvdy5fX29ic2lkaWFuSW50ZWdyYXRpb25UZXN0aW5nLlxcbidcbiAgICAgICsgJ1ByZXNzIEN0cmwrQyB0byBzdG9wLlxcbidcbiAgKTtcblxuICBhd2FpdCB3YWl0Rm9yU2h1dGRvd25TaWduYWwoKTtcblxuICBwcm9jZXNzLnN0ZG91dC53cml0ZSgnXFxuU2h1dHRpbmcgZG93blx1MjAyNlxcbicpO1xuICBhd2FpdCBjb25uZWN0aW9uLmRpc3Bvc2UoKTtcbn1cblxuLyoqXG4gKiBCdWlsZHMge0BsaW5rIENvbm5lY3RUb0NkcE9wdGlvbnN9IGZyb20gcGFyc2VkIENMSSBmbGFnIHZhbHVlcy5cbiAqXG4gKiBAcGFyYW0gdmFsdWVzIC0gVGhlIHBhcnNlZCBgcGFyc2VBcmdzYCB2YWx1ZXMuXG4gKiBAcmV0dXJucyBUaGUgY29ubmVjdGlvbiBvcHRpb25zLlxuICovXG5mdW5jdGlvbiBidWlsZE9wdGlvbnModmFsdWVzOiBQYXJzZWRDbGlWYWx1ZXMpOiBDb25uZWN0VG9DZHBPcHRpb25zIHtcbiAgcmV0dXJuIHtcbiAgICAuLi4odmFsdWVzWydjb21tYW5kLXRpbWVvdXQnXSAhPT0gdW5kZWZpbmVkICYmIHsgY29tbWFuZFRpbWVvdXRJbk1pbGxpc2Vjb25kczogcGFyc2VOdW1iZXIoJ2NvbW1hbmQtdGltZW91dCcsIHZhbHVlc1snY29tbWFuZC10aW1lb3V0J10pIH0pLFxuICAgIC4uLih2YWx1ZXMuaG9zdCAhPT0gdW5kZWZpbmVkICYmIHsgaG9zdDogdmFsdWVzLmhvc3QgfSksXG4gICAgLi4uKHZhbHVlc1snbm8tcmVtb3ZlLXZhdWx0J10gPT09IHRydWUgJiYgeyBzaG91bGRSZW1vdmVWYXVsdE9uRGlzcG9zZTogZmFsc2UgfSksXG4gICAgLi4uKHZhbHVlc1snb2JzaWRpYW4taW5zdGFsbGVyLXZlcnNpb24nXSAhPT0gdW5kZWZpbmVkICYmIHsgb2JzaWRpYW5JbnN0YWxsZXJWZXJzaW9uOiB2YWx1ZXNbJ29ic2lkaWFuLWluc3RhbGxlci12ZXJzaW9uJ10gfSksXG4gICAgLi4uKHZhbHVlc1snb2JzaWRpYW4tdmVyc2lvbiddICE9PSB1bmRlZmluZWQgJiYgeyBvYnNpZGlhblZlcnNpb246IHZhbHVlc1snb2JzaWRpYW4tdmVyc2lvbiddIH0pLFxuICAgIC4uLih2YWx1ZXMucG9ydCAhPT0gdW5kZWZpbmVkICYmIHsgcG9ydDogcGFyc2VOdW1iZXIoJ3BvcnQnLCB2YWx1ZXMucG9ydCkgfSksXG4gICAgLi4uKHZhbHVlcy52YXVsdCAhPT0gdW5kZWZpbmVkICYmIHsgdmF1bHQ6IHZhbHVlcy52YXVsdCB9KVxuICB9O1xufVxuXG4vKipcbiAqIFBhcnNlcyBhIG51bWVyaWMgQ0xJIGZsYWcgdmFsdWUsIHRocm93aW5nIG9uIGEgbm9uLWZpbml0ZSByZXN1bHQuXG4gKlxuICogQHBhcmFtIGZsYWcgLSBUaGUgZmxhZyBuYW1lIChmb3IgdGhlIGVycm9yIG1lc3NhZ2UpLlxuICogQHBhcmFtIHJhdyAtIFRoZSByYXcgc3RyaW5nIHZhbHVlLlxuICogQHJldHVybnMgVGhlIHBhcnNlZCBudW1iZXIuXG4gKiBAdGhyb3dzIEVycm9yIGlmIGByYXdgIGlzIG5vdCBhIGZpbml0ZSBudW1iZXIuXG4gKi9cbmZ1bmN0aW9uIHBhcnNlTnVtYmVyKGZsYWc6IHN0cmluZywgcmF3OiBzdHJpbmcpOiBudW1iZXIge1xuICBjb25zdCB2YWx1ZSA9IE51bWJlcihyYXcpO1xuICBpZiAoIU51bWJlci5pc0Zpbml0ZSh2YWx1ZSkpIHtcbiAgICB0aHJvdyBuZXcgRXJyb3IoYC0tJHtmbGFnfSBtdXN0IGJlIGEgbnVtYmVyLCBnb3Q6ICR7cmF3fWApO1xuICB9XG4gIHJldHVybiB2YWx1ZTtcbn1cblxuLyoqXG4gKiBSZXNvbHZlcyBvbmNlIHRoZSBwcm9jZXNzIHJlY2VpdmVzIGBTSUdJTlRgIG9yIGBTSUdURVJNYC5cbiAqXG4gKiBAcmV0dXJucyBBIHtAbGluayBQcm9taXNlfSB0aGF0IHJlc29sdmVzIG9uIHRoZSBmaXJzdCBzaHV0ZG93biBzaWduYWwuXG4gKi9cbmZ1bmN0aW9uIHdhaXRGb3JTaHV0ZG93blNpZ25hbCgpOiBQcm9taXNlPHZvaWQ+IHtcbiAgcmV0dXJuIG5ldyBQcm9taXNlPHZvaWQ+KChyZXNvbHZlKSA9PiB7XG4gICAgcHJvY2Vzcy5vbmNlKCdTSUdJTlQnLCAoKSA9PiB7XG4gICAgICByZXNvbHZlKCk7XG4gICAgfSk7XG4gICAgcHJvY2Vzcy5vbmNlKCdTSUdURVJNJywgKCkgPT4ge1xuICAgICAgcmVzb2x2ZSgpO1xuICAgIH0pO1xuICB9KTtcbn1cblxuLyogdjggaWdub3JlIHN0b3AgKi9cbiJdLAogICJtYXBwaW5ncyI6ICJBQVdBLE9BQU8sYUFBYTtBQUNwQixTQUFTLGlCQUFpQjtBQUkxQixTQUFTLG9CQUFvQjtBQXFCN0IsZUFBc0IsT0FBc0I7QUFDMUMsUUFBTSxFQUFFLE9BQU8sSUFBSSxVQUFVO0FBQUEsSUFDM0IsU0FBUztBQUFBLE1BQ1AsbUJBQW1CLEVBQUUsTUFBTSxTQUFTO0FBQUEsTUFDcEMsUUFBUSxFQUFFLE1BQU0sU0FBUztBQUFBLE1BQ3pCLG1CQUFtQixFQUFFLE1BQU0sVUFBVTtBQUFBLE1BQ3JDLDhCQUE4QixFQUFFLE1BQU0sU0FBUztBQUFBLE1BQy9DLG9CQUFvQixFQUFFLE1BQU0sU0FBUztBQUFBLE1BQ3JDLFFBQVEsRUFBRSxNQUFNLFNBQVM7QUFBQSxNQUN6QixTQUFTLEVBQUUsTUFBTSxTQUFTO0FBQUEsSUFDNUI7QUFBQSxFQUNGLENBQUM7QUFFRCxRQUFNLGFBQWEsTUFBTSxhQUFhLGFBQWEsTUFBTSxDQUFDO0FBRTFELFVBQVEsT0FBTztBQUFBLElBQ2I7QUFBQSxZQUNpQixPQUFPLFdBQVcsSUFBSSxDQUFDO0FBQUEsWUFDdkIsV0FBVyxNQUFNO0FBQUEsWUFDakIsV0FBVyxNQUFNLElBQUk7QUFBQTtBQUFBO0FBQUE7QUFBQSxFQUd4QztBQUVBLFFBQU0sc0JBQXNCO0FBRTVCLFVBQVEsT0FBTyxNQUFNLHlCQUFvQjtBQUN6QyxRQUFNLFdBQVcsUUFBUTtBQUMzQjtBQVFBLFNBQVMsYUFBYSxRQUE4QztBQUNsRSxTQUFPO0FBQUEsSUFDTCxHQUFJLE9BQU8saUJBQWlCLE1BQU0sVUFBYSxFQUFFLDhCQUE4QixZQUFZLG1CQUFtQixPQUFPLGlCQUFpQixDQUFDLEVBQUU7QUFBQSxJQUN6SSxHQUFJLE9BQU8sU0FBUyxVQUFhLEVBQUUsTUFBTSxPQUFPLEtBQUs7QUFBQSxJQUNyRCxHQUFJLE9BQU8saUJBQWlCLE1BQU0sUUFBUSxFQUFFLDRCQUE0QixNQUFNO0FBQUEsSUFDOUUsR0FBSSxPQUFPLDRCQUE0QixNQUFNLFVBQWEsRUFBRSwwQkFBMEIsT0FBTyw0QkFBNEIsRUFBRTtBQUFBLElBQzNILEdBQUksT0FBTyxrQkFBa0IsTUFBTSxVQUFhLEVBQUUsaUJBQWlCLE9BQU8sa0JBQWtCLEVBQUU7QUFBQSxJQUM5RixHQUFJLE9BQU8sU0FBUyxVQUFhLEVBQUUsTUFBTSxZQUFZLFFBQVEsT0FBTyxJQUFJLEVBQUU7QUFBQSxJQUMxRSxHQUFJLE9BQU8sVUFBVSxVQUFhLEVBQUUsT0FBTyxPQUFPLE1BQU07QUFBQSxFQUMxRDtBQUNGO0FBVUEsU0FBUyxZQUFZLE1BQWMsS0FBcUI7QUFDdEQsUUFBTSxRQUFRLE9BQU8sR0FBRztBQUN4QixNQUFJLENBQUMsT0FBTyxTQUFTLEtBQUssR0FBRztBQUMzQixVQUFNLElBQUksTUFBTSxLQUFLLElBQUksMkJBQTJCLEdBQUcsRUFBRTtBQUFBLEVBQzNEO0FBQ0EsU0FBTztBQUNUO0FBT0EsU0FBUyx3QkFBdUM7QUFDOUMsU0FBTyxJQUFJLFFBQWMsQ0FBQyxZQUFZO0FBQ3BDLFlBQVEsS0FBSyxVQUFVLE1BQU07QUFDM0IsY0FBUTtBQUFBLElBQ1YsQ0FBQztBQUNELFlBQVEsS0FBSyxXQUFXLE1BQU07QUFDNUIsY0FBUTtBQUFBLElBQ1YsQ0FBQztBQUFBLEVBQ0gsQ0FBQztBQUNIOyIsCiAgIm5hbWVzIjogW10KfQo=
82
+ //# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/cli.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Thin CLI over {@link connectToCdp}: launches (or attaches to) a CDP-enabled\n * Obsidian instance with the runtime helper namespace bootstrapped, prints the\n * chosen CDP port/URL, and stays alive until interrupted so an external tool\n * (raw CDP `ws`, DevTools, \u2026) can attach.\n */\n\n/* v8 ignore start -- Integration-time CLI (launches Obsidian / CDP) covered manually, not by unit tests. */\n\nimport process from 'node:process';\nimport { parseArgs } from 'node:util';\n\nimport type { ConnectToCdpOptions } from './connect-to-cdp.mjs';\n\nimport { connectToCdp } from './connect-to-cdp.mjs';\n\n/**\n * The shape of the parsed CLI flag values.\n */\ninterface ParsedCliValues {\n  'command-timeout'?: string | undefined;\n  'host'?: string | undefined;\n  'no-remove-vault'?: boolean | undefined;\n  'obsidian-installer-version'?: string | undefined;\n  'obsidian-version'?: string | undefined;\n  'port'?: string | undefined;\n  'vault'?: string | undefined;\n}\n\n/**\n * Parses CLI arguments, opens the connection, prints its endpoint, and blocks\n * until `SIGINT`/`SIGTERM` or the owned Obsidian window is closed, disposing the\n * connection on shutdown.\n *\n * @returns A {@link Promise} that resolves once the connection has been disposed.\n */\nexport async function main(): Promise<void> {\n  const { values } = parseArgs({\n    options: {\n      'command-timeout': { type: 'string' },\n      'host': { type: 'string' },\n      'no-remove-vault': { type: 'boolean' },\n      'obsidian-installer-version': { type: 'string' },\n      'obsidian-version': { type: 'string' },\n      'port': { type: 'string' },\n      'vault': { type: 'string' }\n    }\n  });\n\n  const connection = await connectToCdp(buildOptions(values));\n\n  process.stdout.write(\n    'Obsidian CDP ready.\\n'\n      + `  port:   ${String(connection.port)}\\n`\n      + `  cdpUrl: ${connection.cdpUrl}\\n`\n      + `  vault:  ${connection.vault.path}\\n`\n      + 'Runtime helpers bootstrapped as window.__obsidianIntegrationTesting.\\n'\n      + 'Press Ctrl+C to stop.\\n'\n  );\n\n  await waitForShutdownOrInstanceClose(connection.cdpUrl);\n\n  process.stdout.write('\\nShutting down\u2026\\n');\n  await connection.dispose();\n}\n\n/**\n * Builds {@link ConnectToCdpOptions} from parsed CLI flag values.\n *\n * @param values - The parsed `parseArgs` values.\n * @returns The connection options.\n */\nfunction buildOptions(values: ParsedCliValues): ConnectToCdpOptions {\n  return {\n    ...(values['command-timeout'] !== undefined && { commandTimeoutInMilliseconds: parseNumber('command-timeout', values['command-timeout']) }),\n    ...(values.host !== undefined && { host: values.host }),\n    ...(values['no-remove-vault'] === true && { shouldRemoveVaultOnDispose: false }),\n    ...(values['obsidian-installer-version'] !== undefined && { obsidianInstallerVersion: values['obsidian-installer-version'] }),\n    ...(values['obsidian-version'] !== undefined && { obsidianVersion: values['obsidian-version'] }),\n    ...(values.port !== undefined && { port: parseNumber('port', values.port) }),\n    ...(values.vault !== undefined && { vault: values.vault })\n  };\n}\n\n/**\n * Parses a numeric CLI flag value, throwing on a non-finite result.\n *\n * @param flag - The flag name (for the error message).\n * @param raw - The raw string value.\n * @returns The parsed number.\n * @throws Error if `raw` is not a finite number.\n */\nfunction parseNumber(flag: string, raw: string): number {\n  const value = Number(raw);\n  if (!Number.isFinite(value)) {\n    throw new Error(`--${flag} must be a number, got: ${raw}`);\n  }\n  return value;\n}\n\n/**\n * Resolves once the process receives `SIGINT`/`SIGTERM`, or the CDP endpoint\n * stops answering (the owned Obsidian window was closed).\n *\n * @param cdpUrl - The connection's CDP base URL to poll.\n * @returns A {@link Promise} that resolves on the first shutdown trigger.\n */\nfunction waitForShutdownOrInstanceClose(cdpUrl: string): Promise<void> {\n  const POLL_INTERVAL_IN_MILLISECONDS = 1000;\n  return new Promise<void>((resolve) => {\n    const versionUrl = `${cdpUrl}/json/version`;\n    let isSettled = false;\n\n    const timer = setInterval(() => {\n      checkAlive().catch(() => {\n        // Ignore poll errors.\n      });\n    }, POLL_INTERVAL_IN_MILLISECONDS);\n\n    process.once('SIGINT', settle);\n    process.once('SIGTERM', settle);\n\n    async function checkAlive(): Promise<void> {\n      try {\n        const response = await fetch(versionUrl);\n        if (!response.ok) {\n          settle();\n        }\n      } catch {\n        // The CDP port stopped answering: the Obsidian window was closed.\n        settle();\n      }\n    }\n\n    function settle(): void {\n      if (isSettled) {\n        return;\n      }\n      isSettled = true;\n      clearInterval(timer);\n      resolve();\n    }\n  });\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAWA,OAAO,aAAa;AACpB,SAAS,iBAAiB;AAI1B,SAAS,oBAAoB;AAsB7B,eAAsB,OAAsB;AAC1C,QAAM,EAAE,OAAO,IAAI,UAAU;AAAA,IAC3B,SAAS;AAAA,MACP,mBAAmB,EAAE,MAAM,SAAS;AAAA,MACpC,QAAQ,EAAE,MAAM,SAAS;AAAA,MACzB,mBAAmB,EAAE,MAAM,UAAU;AAAA,MACrC,8BAA8B,EAAE,MAAM,SAAS;AAAA,MAC/C,oBAAoB,EAAE,MAAM,SAAS;AAAA,MACrC,QAAQ,EAAE,MAAM,SAAS;AAAA,MACzB,SAAS,EAAE,MAAM,SAAS;AAAA,IAC5B;AAAA,EACF,CAAC;AAED,QAAM,aAAa,MAAM,aAAa,aAAa,MAAM,CAAC;AAE1D,UAAQ,OAAO;AAAA,IACb;AAAA,YACiB,OAAO,WAAW,IAAI,CAAC;AAAA,YACvB,WAAW,MAAM;AAAA,YACjB,WAAW,MAAM,IAAI;AAAA;AAAA;AAAA;AAAA,EAGxC;AAEA,QAAM,+BAA+B,WAAW,MAAM;AAEtD,UAAQ,OAAO,MAAM,yBAAoB;AACzC,QAAM,WAAW,QAAQ;AAC3B;AAQA,SAAS,aAAa,QAA8C;AAClE,SAAO;AAAA,IACL,GAAI,OAAO,iBAAiB,MAAM,UAAa,EAAE,8BAA8B,YAAY,mBAAmB,OAAO,iBAAiB,CAAC,EAAE;AAAA,IACzI,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,OAAO,KAAK;AAAA,IACrD,GAAI,OAAO,iBAAiB,MAAM,QAAQ,EAAE,4BAA4B,MAAM;AAAA,IAC9E,GAAI,OAAO,4BAA4B,MAAM,UAAa,EAAE,0BAA0B,OAAO,4BAA4B,EAAE;AAAA,IAC3H,GAAI,OAAO,kBAAkB,MAAM,UAAa,EAAE,iBAAiB,OAAO,kBAAkB,EAAE;AAAA,IAC9F,GAAI,OAAO,SAAS,UAAa,EAAE,MAAM,YAAY,QAAQ,OAAO,IAAI,EAAE;AAAA,IAC1E,GAAI,OAAO,UAAU,UAAa,EAAE,OAAO,OAAO,MAAM;AAAA,EAC1D;AACF;AAUA,SAAS,YAAY,MAAc,KAAqB;AACtD,QAAM,QAAQ,OAAO,GAAG;AACxB,MAAI,CAAC,OAAO,SAAS,KAAK,GAAG;AAC3B,UAAM,IAAI,MAAM,KAAK,IAAI,2BAA2B,GAAG,EAAE;AAAA,EAC3D;AACA,SAAO;AACT;AASA,SAAS,+BAA+B,QAA+B;AACrE,QAAM,gCAAgC;AACtC,SAAO,IAAI,QAAc,CAAC,YAAY;AACpC,UAAM,aAAa,GAAG,MAAM;AAC5B,QAAI,YAAY;AAEhB,UAAM,QAAQ,YAAY,MAAM;AAC9B,iBAAW,EAAE,MAAM,MAAM;AAAA,MAEzB,CAAC;AAAA,IACH,GAAG,6BAA6B;AAEhC,YAAQ,KAAK,UAAU,MAAM;AAC7B,YAAQ,KAAK,WAAW,MAAM;AAE9B,mBAAe,aAA4B;AACzC,UAAI;AACF,cAAM,WAAW,MAAM,MAAM,UAAU;AACvC,YAAI,CAAC,SAAS,IAAI;AAChB,iBAAO;AAAA,QACT;AAAA,MACF,QAAQ;AAEN,eAAO;AAAA,MACT;AAAA,IACF;AAEA,aAAS,SAAe;AACtB,UAAI,WAAW;AACb;AAAA,MACF;AACA,kBAAY;AACZ,oBAAc,KAAK;AACnB,cAAQ;AAAA,IACV;AAAA,EACF,CAAC;AACH;",
  "names": []
}

package/dist/lib/esm/connect-to-cdp.d.mts CHANGED
@@ -13,6 +13,7 @@
13
13
  import type { Except } from 'type-fest';
14
14
  import type { ContextId } from './context-id.mjs';
15
15
  import type { EvalInObsidianParams, GenericObject } from './eval-in-obsidian.mjs';
16
+ import type { InstallerCompatibility } from './installer-compatibility.mjs';
16
17
  import { TempVault } from './temp-vault.mjs';
17
18
  /**
18
19
  * A live connection to a CDP-enabled Obsidian instance with the runtime helper
@@ -27,6 +28,14 @@ export interface CdpConnection extends AsyncDisposable {
27
28
  * The base CDP URL, e.g. `http://localhost:51888`.
28
29
  */
29
30
  readonly cdpUrl: string;
31
+ /**
32
+ * The resolved installer↔app compatibility verdict for an owned instance, when
33
+ * it could be determined. `undefined` in attach mode, or when the verdict is
34
+ * unknown (undetectable shell version, or the app version is absent from the
35
+ * table). An `'unrunnable'` verdict never reaches here — it throws
36
+ * `IncompatibleInstallerVersionError` before the connection is created.
37
+ */
38
+ readonly compatibility?: InstallerCompatibility | undefined;
30
39
  /**
31
40
  * Disposes the connection: kills an owned instance and removes its isolated
32
41
  * user-data dir. The vault directory is removed only when it is a throw-away
@@ -75,6 +84,18 @@ export interface ConnectToCdpOptions {
75
84
  * @default `30000`
76
85
  */
77
86
  readonly commandTimeoutInMilliseconds?: number;
87
+ /**
88
+ * Grace window in milliseconds for fast-failing a dead boot of the owned
89
+ * instance — the renderer loaded but the app never bootstrapped (empty
90
+ * `<body>`, no `window.app`), the terminal state when the asar cannot run on
91
+ * the launched Electron shell. Once it has held this long a
92
+ * `RendererFailedToInitializeError` is thrown instead of waiting out the full
93
+ * readiness timeout. Ignored in attach mode ({@link port} set). Set `0` to
94
+ * disable fast-fail.
95
+ *
96
+ * @default `10000`
97
+ */
98
+ readonly deadBootGraceInMilliseconds?: number;
78
99
  /**
79
100
  * CDP host.
80
101
  *
@@ -82,9 +103,8 @@ export interface ConnectToCdpOptions {
82
103
  */
83
104
  readonly host?: string;
84
105
  /**
85
- * Whether the Obsidian window is shown on screen. Unlike the test transports
86
- * (hidden by default), `connectToCdp` **defaults to `true`** — it is meant for
87
- * watching/debugging a real Obsidian. Set `false` to launch it off-screen.
106
+ * Whether the Obsidian window is shown on screen. Defaults to `true`; set
107
+ * `false` to launch it off-screen.
88
108
  * Ignored in attach mode ({@link port} set).
89
109
  *
90
110
  * @default `true`
@@ -113,6 +133,18 @@ export interface ConnectToCdpOptions {
113
133
  * @default `undefined`
114
134
  */
115
135
  readonly port?: number;
136
+ /**
137
+ * Whether to launch the owned instance with Chromium's sandbox disabled
138
+ * (`--no-sandbox`).
139
+ *
140
+ * Needed to boot on Linux without a correctly-configured setuid
141
+ * `chrome-sandbox` helper (e.g. an installer-extracted portable shell, or CI
142
+ * running as a non-root user); harmless on Windows/macOS. Ignored in attach
143
+ * mode ({@link port} set).
144
+ *
145
+ * @default `false`
146
+ */
147
+ readonly shouldDisableSandbox?: boolean;
116
148
  /**
117
149
  * Whether to remove the vault directory on {@link CdpConnection.dispose}.
118
150
  *
package/dist/lib/esm/connect-to-cdp.mjs CHANGED
@@ -4,23 +4,16 @@ import { DesktopCdpTransport } from "./transport-desktop-cdp.mjs";
4
4
  import { createTransportFromOptions } from "./transport-factory.mjs";
5
5
  const DEFAULT_CDP_HOST = "localhost";
6
6
  async function connectToCdp(options) {
7
- const transportOptions = {
8
- isObsidianAppVisible: options?.isObsidianAppVisible ?? true,
9
- type: "obsidian-cdp",
10
- ...options?.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds },
11
- ...options?.host !== void 0 && { host: options.host },
12
- ...options?.obsidianInstallerVersion !== void 0 && { obsidianInstallerVersion: options.obsidianInstallerVersion },
13
- ...options?.obsidianVersion !== void 0 && { obsidianVersion: options.obsidianVersion },
14
- ...options?.port !== void 0 && { port: options.port }
15
- };
16
- const transport = await createTransportFromOptions(transportOptions);
7
+ const transport = await createTransportFromOptions(buildCdpTransportOptions(options));
17
8
  const vault = new TempVault(options?.vault);
18
9
  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? options?.vault === void 0;
19
10
  await vault.register(transport);
20
11
  const { host, port } = resolveEndpoint(transport, options);
21
12
  const cdpUrl = `http://${host}:${String(port)}`;
13
+ const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : void 0;
22
14
  const connection = {
23
15
  cdpUrl,
16
+ ...compatibility && { compatibility },
24
17
  async dispose() {
25
18
  try {
26
19
  if (shouldRemoveVaultOnDispose) {
@@ -46,6 +39,19 @@ async function connectToCdp(options) {
46
39
  };
47
40
  return connection;
48
41
  }
42
+ function buildCdpTransportOptions(options) {
43
+ return {
44
+ isObsidianAppVisible: options?.isObsidianAppVisible ?? true,
45
+ type: "obsidian-cdp",
46
+ ...options?.commandTimeoutInMilliseconds !== void 0 && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds },
47
+ ...options?.deadBootGraceInMilliseconds !== void 0 && { deadBootGraceInMilliseconds: options.deadBootGraceInMilliseconds },
48
+ ...options?.host !== void 0 && { host: options.host },
49
+ ...options?.obsidianInstallerVersion !== void 0 && { obsidianInstallerVersion: options.obsidianInstallerVersion },
50
+ ...options?.obsidianVersion !== void 0 && { obsidianVersion: options.obsidianVersion },
51
+ ...options?.port !== void 0 && { port: options.port },
52
+ ...options?.shouldDisableSandbox !== void 0 && { shouldDisableSandbox: options.shouldDisableSandbox }
53
+ };
54
+ }
49
55
  function resolveEndpoint(transport, options) {
50
56
  if (transport instanceof DesktopCdpTransport) {
51
57
  const endpoint = transport.getOwnedInstanceEndpoint();
@@ -61,4 +67,4 @@ function resolveEndpoint(transport, options) {
61
67
  export {
62
68
  connectToCdp
63
69
  };
64
- //# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * the base `lib` helpers, `errorToString`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { ContextId } from './context-id.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { TempVault } from './temp-vault.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `args`\n   * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors\n   * the top-level `evalInObsidian`, with the transport and vault path pre-bound\n   * to this connection.\n   *\n   * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TempVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Unlike the test transports\n   * (hidden by default), `connectToCdp` **defaults to `true`** \u2014 it is meant for\n   * watching/debugging a real Obsidian. Set `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transportOptions: ObsidianCdpTransportOptions = {\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    type: 'obsidian-cdp',\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    ...(options?.host !== undefined && { host: options.host }),\n    ...(options?.obsidianInstallerVersion !== undefined && { obsidianInstallerVersion: options.obsidianInstallerVersion }),\n    ...(options?.obsidianVersion !== undefined && { obsidianVersion: options.obsidianVersion }),\n    ...(options?.port !== undefined && { port: options.port })\n  };\n\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAwBA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,mBAAmB;AAqJzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,mBAAgD;AAAA,IACpD,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,MAAM;AAAA,IACN,GAAI,SAAS,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IAChI,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,6BAA6B,UAAa,EAAE,0BAA0B,QAAQ,yBAAyB;AAAA,IACpH,GAAI,SAAS,oBAAoB,UAAa,EAAE,iBAAiB,QAAQ,gBAAgB;AAAA,IACzF,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,EAC1D;AAEA,QAAM,YAAY,MAAM,2BAA2B,gBAAgB;AACnE,QAAM,QAAQ,IAAI,UAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAE7C,QAAM,aAA4B;AAAA,IAChC;AAAA,IAEA,MAAM,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,aAAO,eAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;AAAA,IAEA,MAAM,OAAO,YAAqC;AAChD,aAAO,UAAU,SAAS,YAAY,EAAE,KAAK,MAAM,KAAK,CAAC;AAAA,IAC3D;AAAA,IAEA;AAAA,IAEA,OAAO,OAAO,YAAY,IAAmB;AAC3C,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,IAEA;AAAA,EACF;AAEA,SAAO;AACT;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,qBAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "names": []
}

70
+ //# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/connect-to-cdp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Programmatic helper to launch (or attach to) a CDP-enabled Obsidian instance\n * with the runtime helper namespace bootstrapped, for ad-hoc real-app debugging.\n *\n * A single {@link connectToCdp} call resolves the owned-instance config, opens a\n * vault, and bootstraps `window.__obsidianIntegrationTesting` (so `evalWrapper`,\n * the base `lib` helpers, `errorToString`, `getObsidianModule`, \u2026 are available), then\n * hands back a disposable {@link CdpConnection} exposing the chosen CDP port, a\n * raw {@link CdpConnection.invoke} and the rich {@link CdpConnection.evalInObsidian}.\n */\n\n/* v8 ignore start -- Integration-time code (launches Obsidian / CDP) covered by integration tests, not unit tests. */\n\nimport type { Except } from 'type-fest';\n\nimport type { ContextId } from './context-id.mjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.mjs';\nimport type { InstallerCompatibility } from './installer-compatibility.mjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.mjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.mjs';\nimport { TempVault } from './temp-vault.mjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.mjs';\nimport { createTransportFromOptions } from './transport-factory.mjs';\n\nconst DEFAULT_CDP_HOST = 'localhost';\n\n/**\n * A live connection to a CDP-enabled Obsidian instance with the runtime helper\n * namespace bootstrapped.\n *\n * Implements `AsyncDisposable`, so `await using conn = await connectToCdp(\u2026)`\n * disposes it (killing an owned instance and \u2014 for a throw-away temp vault \u2014\n * removing its directory) automatically.\n */\nexport interface CdpConnection extends AsyncDisposable {\n  /**\n   * The base CDP URL, e.g. `http://localhost:51888`.\n   */\n  readonly cdpUrl: string;\n\n  /**\n   * The resolved installer\u2194app compatibility verdict for an owned instance, when\n   * it could be determined. `undefined` in attach mode, or when the verdict is\n   * unknown (undetectable shell version, or the app version is absent from the\n   * table). An `'unrunnable'` verdict never reaches here \u2014 it throws\n   * `IncompatibleInstallerVersionError` before the connection is created.\n   */\n  readonly compatibility?: InstallerCompatibility | undefined;\n\n  /**\n   * Disposes the connection: kills an owned instance and removes its isolated\n   * user-data dir. The vault directory is removed only when it is a throw-away\n   * temp vault (see {@link ConnectToCdpOptions.shouldRemoveVaultOnDispose}); a\n   * real vault passed via {@link ConnectToCdpOptions.vault} is never deleted.\n   *\n   * @returns A {@link Promise} that resolves once disposal completes.\n   */\n  dispose(): Promise<void>;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `args`\n   * (shared helpers like `typeIntoEditor` / `waitUntil` live on `lib`). Mirrors\n   * the top-level `evalInObsidian`, with the transport and vault path pre-bound\n   * to this connection.\n   *\n   * @param params - The evaluation parameters (`fn`, optional `args`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `fn`.\n   */\n  evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n  ): Promise<Result>;\n\n  /**\n   * Evaluates a raw JavaScript expression inside Obsidian and returns the\n   * normalized string result (e.g. `'5'`, a JSON string, or `'(no output)'`).\n   *\n   * @param expression - A self-contained JavaScript expression.\n   * @returns A {@link Promise} that resolves to the raw result string.\n   */\n  invoke(expression: string): Promise<string>;\n\n  /**\n   * The CDP port the instance is reachable on (the free port chosen for an\n   * owned instance, or the attached {@link ConnectToCdpOptions.port}).\n   */\n  readonly port: number;\n\n  /**\n   * The opened vault. Exposes `path` and `populate(...)` for seeding files.\n   */\n  readonly vault: TempVault;\n}\n\n/**\n * Options for {@link connectToCdp}.\n */\nexport interface ConnectToCdpOptions {\n  /**\n   * Timeout in milliseconds for individual CDP commands.\n   *\n   * @default `30000`\n   */\n  readonly commandTimeoutInMilliseconds?: number;\n\n  /**\n   * Grace window in milliseconds for fast-failing a dead boot of the owned\n   * instance \u2014 the renderer loaded but the app never bootstrapped (empty\n   * `<body>`, no `window.app`), the terminal state when the asar cannot run on\n   * the launched Electron shell. Once it has held this long a\n   * `RendererFailedToInitializeError` is thrown instead of waiting out the full\n   * readiness timeout. Ignored in attach mode ({@link port} set). Set `0` to\n   * disable fast-fail.\n   *\n   * @default `10000`\n   */\n  readonly deadBootGraceInMilliseconds?: number;\n\n  /**\n   * CDP host.\n   *\n   * @default `'localhost'`\n   */\n  readonly host?: string;\n\n  /**\n   * Whether the Obsidian window is shown on screen. Defaults to `true`; set\n   * `false` to launch it off-screen.\n   * Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly isObsidianAppVisible?: boolean;\n\n  /**\n   * Pins the Electron shell (installer build) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed shell is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianInstallerVersion?: string;\n\n  /**\n   * Pins the Obsidian app version (asar) the owned instance runs. Accepts\n   * `'x.y.z'`, `'public-latest'`, or `'catalyst-latest'`. Ignored when\n   * {@link port} (attach mode) is set. When omitted, the installed version is used.\n   *\n   * @default `undefined`\n   */\n  readonly obsidianVersion?: string;\n\n  /**\n   * CDP port of an already-running Obsidian to **attach** to. When omitted, an\n   * isolated instance is launched on an automatically chosen free port.\n   *\n   * @default `undefined`\n   */\n  readonly port?: number;\n\n  /**\n   * Whether to launch the owned instance with Chromium's sandbox disabled\n   * (`--no-sandbox`).\n   *\n   * Needed to boot on Linux without a correctly-configured setuid\n   * `chrome-sandbox` helper (e.g. an installer-extracted portable shell, or CI\n   * running as a non-root user); harmless on Windows/macOS. Ignored in attach\n   * mode ({@link port} set).\n   *\n   * @default `false`\n   */\n  readonly shouldDisableSandbox?: boolean;\n\n  /**\n   * Whether to remove the vault directory on {@link CdpConnection.dispose}.\n   *\n   * When omitted, defaults to `true` for an implicit throw-away temp vault\n   * ({@link vault} not given) and `false` when a {@link vault} path is given, so\n   * a real vault is never deleted. Set explicitly to override.\n   */\n  readonly shouldRemoveVaultOnDispose?: boolean;\n\n  /**\n   * Absolute path to an existing vault to open. When omitted, an empty temporary\n   * vault is created (and removed on dispose unless\n   * {@link shouldRemoveVaultOnDispose} says otherwise).\n   *\n   * @default `undefined`\n   */\n  readonly vault?: string;\n}\n\n/**\n * A resolved CDP host/port pair.\n */\ninterface ResolvedEndpoint {\n  host: string;\n  port: number;\n}\n\n/**\n * Launches (or attaches to) a CDP-enabled Obsidian instance, opens a vault, and\n * bootstraps the runtime helper namespace, returning a disposable connection.\n *\n * @param options - Connection options.\n * @returns A {@link Promise} that resolves to the live {@link CdpConnection}.\n */\nexport async function connectToCdp(options?: ConnectToCdpOptions): Promise<CdpConnection> {\n  const transport = await createTransportFromOptions(buildCdpTransportOptions(options));\n  const vault = new TempVault(options?.vault);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n\n  // Registering the vault is what launches the owned instance (provisions the\n  // Asar, opens the vault, and bootstraps the helper namespace), or opens the\n  // Vault in the attached instance.\n  await vault.register(transport);\n\n  const { host, port } = resolveEndpoint(transport, options);\n  const cdpUrl = `http://${host}:${String(port)}`;\n  const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : undefined;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n    ...(compatibility && { compatibility }),\n\n    async dispose(): Promise<void> {\n      try {\n        if (shouldRemoveVaultOnDispose) {\n          await vault.dispose(transport);\n        } else {\n          await transport.unregisterVault(vault.path);\n        }\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Args, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Args, Result, TContextId>({ ...params, transport, vaultPath: vault.path });\n    },\n\n    async invoke(expression: string): Promise<string> {\n      return transport.evaluate(expression, { cwd: vault.path });\n    },\n\n    port,\n\n    async [Symbol.asyncDispose](): Promise<void> {\n      await connection.dispose();\n    },\n\n    vault\n  };\n\n  return connection;\n}\n\n/**\n * Builds the {@link ObsidianCdpTransportOptions} for a connection, threading only\n * the provided {@link ConnectToCdpOptions} through (owned-visible defaults to\n * `true`, unlike the hidden-by-default test transports).\n *\n * @param options - The connection options.\n * @returns The transport options to create the connection's transport from.\n */\nfunction buildCdpTransportOptions(options?: ConnectToCdpOptions): ObsidianCdpTransportOptions {\n  return {\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    type: 'obsidian-cdp',\n    ...(options?.commandTimeoutInMilliseconds !== undefined && { commandTimeoutInMilliseconds: options.commandTimeoutInMilliseconds }),\n    ...(options?.deadBootGraceInMilliseconds !== undefined && { deadBootGraceInMilliseconds: options.deadBootGraceInMilliseconds }),\n    ...(options?.host !== undefined && { host: options.host }),\n    ...(options?.obsidianInstallerVersion !== undefined && { obsidianInstallerVersion: options.obsidianInstallerVersion }),\n    ...(options?.obsidianVersion !== undefined && { obsidianVersion: options.obsidianVersion }),\n    ...(options?.port !== undefined && { port: options.port }),\n    ...(options?.shouldDisableSandbox !== undefined && { shouldDisableSandbox: options.shouldDisableSandbox })\n  };\n}\n\n/**\n * Resolves the CDP host/port for the connection: from the owned instance's\n * launched endpoint when present, otherwise from the attach options.\n *\n * @param transport - The transport created for this connection.\n * @param options - The connection options.\n * @returns The resolved host and port.\n * @throws Error if the port cannot be determined.\n */\nfunction resolveEndpoint(transport: unknown, options: ConnectToCdpOptions | undefined): ResolvedEndpoint {\n  if (transport instanceof DesktopCdpTransport) {\n    const endpoint = transport.getOwnedInstanceEndpoint();\n    if (endpoint) {\n      return { host: endpoint.host, port: endpoint.port };\n    }\n  }\n\n  if (options?.port !== undefined) {\n    return { host: options.host ?? DEFAULT_CDP_HOST, port: options.port };\n  }\n\n  throw new Error('connectToCdp: could not determine the CDP port.');\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "AAyBA,SAAS,sBAAsB;AAC/B,SAAS,iBAAiB;AAC1B,SAAS,2BAA2B;AACpC,SAAS,kCAAkC;AAE3C,MAAM,mBAAmB;AAuLzB,eAAsB,aAAa,SAAuD;AACxF,QAAM,YAAY,MAAM,2BAA2B,yBAAyB,OAAO,CAAC;AACpF,QAAM,QAAQ,IAAI,UAAU,SAAS,KAAK;AAC1C,QAAM,6BAA6B,SAAS,8BAA+B,SAAS,UAAU;AAK9F,QAAM,MAAM,SAAS,SAAS;AAE9B,QAAM,EAAE,MAAM,KAAK,IAAI,gBAAgB,WAAW,OAAO;AACzD,QAAM,SAAS,UAAU,IAAI,IAAI,OAAO,IAAI,CAAC;AAC7C,QAAM,gBAAgB,qBAAqB,sBAAsB,UAAU,iBAAiB,IAAI;AAEhG,QAAM,aAA4B;AAAA,IAChC;AAAA,IACA,GAAI,iBAAiB,EAAE,cAAc;AAAA,IAErC,MAAM,UAAyB;AAC7B,UAAI;AACF,YAAI,4BAA4B;AAC9B,gBAAM,MAAM,QAAQ,SAAS;AAAA,QAC/B,OAAO;AACL,gBAAM,UAAU,gBAAgB,MAAM,IAAI;AAAA,QAC5C;AAAA,MACF,UAAE;AACA,cAAM,UAAU,UAAU;AAAA,MAC5B;AAAA,IACF;AAAA,IAEA,MAAM,eACJ,QACiB;AACjB,aAAO,eAAyC,EAAE,GAAG,QAAQ,WAAW,WAAW,MAAM,KAAK,CAAC;AAAA,IACjG;AAAA,IAEA,MAAM,OAAO,YAAqC;AAChD,aAAO,UAAU,SAAS,YAAY,EAAE,KAAK,MAAM,KAAK,CAAC;AAAA,IAC3D;AAAA,IAEA;AAAA,IAEA,OAAO,OAAO,YAAY,IAAmB;AAC3C,YAAM,WAAW,QAAQ;AAAA,IAC3B;AAAA,IAEA;AAAA,EACF;AAEA,SAAO;AACT;AAUA,SAAS,yBAAyB,SAA4D;AAC5F,SAAO;AAAA,IACL,sBAAsB,SAAS,wBAAwB;AAAA,IACvD,MAAM;AAAA,IACN,GAAI,SAAS,iCAAiC,UAAa,EAAE,8BAA8B,QAAQ,6BAA6B;AAAA,IAChI,GAAI,SAAS,gCAAgC,UAAa,EAAE,6BAA6B,QAAQ,4BAA4B;AAAA,IAC7H,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,6BAA6B,UAAa,EAAE,0BAA0B,QAAQ,yBAAyB;AAAA,IACpH,GAAI,SAAS,oBAAoB,UAAa,EAAE,iBAAiB,QAAQ,gBAAgB;AAAA,IACzF,GAAI,SAAS,SAAS,UAAa,EAAE,MAAM,QAAQ,KAAK;AAAA,IACxD,GAAI,SAAS,yBAAyB,UAAa,EAAE,sBAAsB,QAAQ,qBAAqB;AAAA,EAC1G;AACF;AAWA,SAAS,gBAAgB,WAAoB,SAA4D;AACvG,MAAI,qBAAqB,qBAAqB;AAC5C,UAAM,WAAW,UAAU,yBAAyB;AACpD,QAAI,UAAU;AACZ,aAAO,EAAE,MAAM,SAAS,MAAM,MAAM,SAAS,KAAK;AAAA,IACpD;AAAA,EACF;AAEA,MAAI,SAAS,SAAS,QAAW;AAC/B,WAAO,EAAE,MAAM,QAAQ,QAAQ,kBAAkB,MAAM,QAAQ,KAAK;AAAA,EACtE;AAEA,QAAM,IAAI,MAAM,iDAAiD;AACnE;",
  "names": []
}

package/dist/lib/esm/context-provider.d.mts CHANGED
@@ -20,7 +20,7 @@ export type VaultPathResolver = () => string | undefined;
20
20
  /**
21
21
  * Returns the transport options resolved by the registered framework adapter.
22
22
  *
23
- * @returns The transport options, or `undefined` if not configured (defaults to CLI transport).
23
+ * @returns The transport options, or `undefined` if not configured.
24
24
  */
25
25
  export declare function getTransportOptions(): ObsidianTransportOptions | undefined;
26
26
  /**
package/dist/lib/esm/context-provider.mjs CHANGED
@@ -18,4 +18,4 @@ export {
18
18
  setTransportOptionsResolver,
19
19
  setVaultPathResolver
20
20
  };
21
- //# sourceMappingURL=data:application/json;base64,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
21
+ //# sourceMappingURL=data:application/json;base64,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
package/dist/lib/esm/global-setup-core.d.mts CHANGED
@@ -20,7 +20,7 @@ export interface CoreSetupParams {
20
20
  * forcing a re-scan is far slower and less reliable.
21
21
  */
22
22
  readonly populate?: PopulateFilesParams | undefined;
23
- /** Transport options. When omitted, defaults to the CLI transport. */
23
+ /** Transport options. When omitted, uses an off-screen owned desktop instance. */
24
24
  readonly transportOptions?: ObsidianTransportOptions | undefined;
25
25
  }
26
26
  /**
@@ -56,3 +56,13 @@ export declare function coreSetup(params?: CoreSetupParams): Promise<CoreSetupRe
56
56
  * @param result - The result from {@link coreSetup}. When `undefined`, does nothing.
57
57
  */
58
58
  export declare function coreTeardown(result?: CoreSetupResult): Promise<void>;
59
+ /**
60
+ * Resolves transport options for an integration run.
61
+ *
62
+ * Desktop launches are normally visible, but test setup explicitly keeps its
63
+ * owned instance off-screen so it does not interrupt the developer.
64
+ *
65
+ * @param options - Consumer-provided transport options.
66
+ * @returns Options with the desktop integration visibility default applied.
67
+ */
68
+ export declare function resolveIntegrationTransportOptions(options?: ObsidianTransportOptions): ObsidianTransportOptions;