obsidian-integration-testing 11.0.0 → 12.1.0

package/dist/lib/cjs/community-plugin-registry.cjs

@@ -0,0 +1,52 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var community_plugin_registry_exports = {};
+__export(community_plugin_registry_exports, {
+  COMMUNITY_PLUGINS_REGISTRY_URL: () => COMMUNITY_PLUGINS_REGISTRY_URL,
+  OPTIONAL_PLUGIN_ASSET_NAMES: () => OPTIONAL_PLUGIN_ASSET_NAMES,
+  REQUIRED_PLUGIN_ASSET_NAMES: () => REQUIRED_PLUGIN_ASSET_NAMES,
+  buildPluginAssetUrl: () => buildPluginAssetUrl,
+  isValidRepoReference: () => isValidRepoReference,
+  selectPluginRepo: () => selectPluginRepo
+});
+module.exports = __toCommonJS(community_plugin_registry_exports);
+const COMMUNITY_PLUGINS_REGISTRY_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/community-plugins.json";
+const REQUIRED_PLUGIN_ASSET_NAMES = ["main.js", "manifest.json"];
+const OPTIONAL_PLUGIN_ASSET_NAMES = ["styles.css"];
+function buildPluginAssetUrl(params) {
+  const { assetName, repo, version } = params;
+  const releasePath = version === void 0 ? "latest/download" : `download/${version}`;
+  return `https://github.com/${repo}/releases/${releasePath}/${assetName}`;
+}
+function isValidRepoReference(repo) {
+  return /^[\w.-]+\/[\w.-]+$/.test(repo);
+}
+function selectPluginRepo(params) {
+  return params.entries.find((entry) => entry.id === params.pluginId)?.repo;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  COMMUNITY_PLUGINS_REGISTRY_URL,
+  OPTIONAL_PLUGIN_ASSET_NAMES,
+  REQUIRED_PLUGIN_ASSET_NAMES,
+  buildPluginAssetUrl,
+  isValidRepoReference,
+  selectPluginRepo
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/community-plugin-registry.d.cts

@@ -0,0 +1,116 @@
+/**
+ * @file
+ *
+ * Pure helpers for resolving a community plugin's **GitHub release assets** from
+ * nothing but its plugin id — the id → repo lookup and the asset URL shapes.
+ *
+ * A plugin's built files never live in git: `.obsidian/plugins/*` is gitignored in
+ * a plugin repo, so a demo vault's injected community plugins exist on
+ * exactly the machine that once opened that vault in Obsidian. To install them
+ * headlessly (see `demo-vault-bootstrap.ts`) two things must be derivable:
+ *
+ * - **Which repo publishes the id.** Obsidian's own registry —
+ *   {@link COMMUNITY_PLUGINS_REGISTRY_URL}, served from the same
+ *   `obsidianmd/obsidian-releases` repository the installer downloader already
+ *   uses — maps every community plugin's `id` to its `owner/name` repo. That is
+ *   the same table the in-app community browser installs from, so no
+ *   plugin-specific mapping has to be hardcoded here.
+ * - **Where that repo's assets live.** A plugin release publishes `manifest.json`,
+ *   `main.js` and (optionally) `styles.css` as release assets;
+ *   {@link buildPluginAssetUrl} builds the URL for one, for either the latest
+ *   release or a pinned tag.
+ *
+ * Everything decidable without the network lives here so it stays unit-tested; the
+ * fetching and writing sit in `demo-vault-bootstrap.ts`, mirroring the
+ * `installer-asset.ts` / `obsidian-installer.ts` split.
+ */
+/**
+ * Obsidian's own community plugin registry: the `id` → `repo` table the in-app
+ * community browser installs from, served from the `obsidianmd/obsidian-releases`
+ * repository.
+ */
+export declare const COMMUNITY_PLUGINS_REGISTRY_URL = "https://raw.githubusercontent.com/obsidianmd/obsidian-releases/master/community-plugins.json";
+/**
+ * The `main.js` / `manifest.json` pair every plugin release must publish for the
+ * plugin to be loadable — the same two files `buildDemoVaultPopulate` requires on
+ * disk.
+ */
+export declare const REQUIRED_PLUGIN_ASSET_NAMES: readonly ["main.js", "manifest.json"];
+/**
+ * `styles.css` is published only by plugins that ship CSS, so a download of it is
+ * allowed to 404 without failing the install.
+ */
+export declare const OPTIONAL_PLUGIN_ASSET_NAMES: readonly ["styles.css"];
+/**
+ * Parameters for {@link buildPluginAssetUrl}.
+ */
+export interface BuildPluginAssetUrlParams {
+    /**
+    The release asset's file name, e.g. `main.js`.
+     */
+    readonly assetName: string;
+    /**
+    The publishing GitHub repository, as `owner/name`.
+     */
+    readonly repo: string;
+    /**
+     * The release tag to download from. Omit for the repository's latest release —
+     * which is what the in-app community browser installs.
+     */
+    readonly version?: string | undefined;
+}
+/**
+ * One row of Obsidian's `community-plugins.json`, reduced to the fields the
+ * bootstrap needs. The published rows carry `name`, `author` and `description`
+ * too; they are deliberately not modelled.
+ */
+export interface CommunityPluginRegistryEntry {
+    /**
+    The plugin's id — its `.obsidian/plugins/<id>` folder name.
+     */
+    readonly id: string;
+    /**
+    The publishing GitHub repository, as `owner/name`.
+     */
+    readonly repo: string;
+}
+/**
+ * Parameters for {@link selectPluginRepo}.
+ */
+export interface SelectPluginRepoParams {
+    /**
+    The registry rows, as published by {@link COMMUNITY_PLUGINS_REGISTRY_URL}.
+     */
+    readonly entries: readonly CommunityPluginRegistryEntry[];
+    /**
+    The plugin id to look up.
+     */
+    readonly pluginId: string;
+}
+/**
+ * Builds the download URL for one asset of a plugin's GitHub release.
+ *
+ * GitHub serves two forms — a pinned `releases/download/<tag>/<asset>` and the
+ * moving `releases/latest/download/<asset>` — so a pinned version and the default
+ * "whatever is current" share one builder.
+ *
+ * @param params - The {@link BuildPluginAssetUrlParams}.
+ * @returns The asset's download URL.
+ */
+export declare function buildPluginAssetUrl(params: BuildPluginAssetUrlParams): string;
+/**
+ * Checks that a string has the `owner/name` shape a GitHub repository reference
+ * needs, so a malformed override is rejected before it is spliced into a URL.
+ *
+ * @param repo - The candidate repository reference.
+ * @returns Whether it is a well-formed `owner/name` pair.
+ */
+export declare function isValidRepoReference(repo: string): boolean;
+/**
+ * Looks a plugin id up in Obsidian's community plugin registry.
+ *
+ * @param params - The {@link SelectPluginRepoParams}.
+ * @returns The publishing `owner/name` repo, or `undefined` when the id is not a
+ *   registered community plugin (a private or unlisted plugin, or a typo).
+ */
+export declare function selectPluginRepo(params: SelectPluginRepoParams): string | undefined;

package/dist/lib/cjs/config-directory-fallback-error.cjs

@@ -0,0 +1,57 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_directory_fallback_error_exports = {};
+__export(config_directory_fallback_error_exports, {
+  ConfigDirectoryFallbackError: () => ConfigDirectoryFallbackError
+});
+module.exports = __toCommonJS(config_directory_fallback_error_exports);
+class ConfigDirectoryFallbackError extends Error {
+  /**
+  The config folder the vault is actually using.
+   */
+  actualConfigDirectory;
+  /**
+  The config folder that was requested.
+   */
+  requestedConfigDirectory;
+  /**
+  Absolute path to the vault that was opened.
+   */
+  vaultPath;
+  /**
+   * Creates the error from the requested and actual config folders.
+   *
+   * @param params - The requested folder, the folder actually in use, and the vault path.
+   */
+  constructor(params) {
+    const { actualConfigDirectory, requestedConfigDirectory, vaultPath } = params;
+    super(
+      `Vault ${vaultPath} was opened with config folder ${actualConfigDirectory} but ${requestedConfigDirectory} was requested \u2014 Obsidian rejected the override or never saw it, and silently fell back. Check that ${requestedConfigDirectory} exists in the vault and is a name Obsidian accepts.`
+    );
+    this.name = "ConfigDirectoryFallbackError";
+    this.actualConfigDirectory = actualConfigDirectory;
+    this.requestedConfigDirectory = requestedConfigDirectory;
+    this.vaultPath = vaultPath;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigDirectoryFallbackError
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/config-directory-fallback-error.d.cts

@@ -0,0 +1,64 @@
+/**
+ * @file
+ *
+ * The distinct error thrown when an owned Obsidian instance booted a vault
+ * against a **different config folder** than the one requested through
+ * `configDirectory` — Obsidian rejected the override, or never saw it, and silently
+ * fell back to `.obsidian`.
+ *
+ * The fallback is silent by construction (`setConfigDir` swaps an invalid value
+ * for the default without a word) and the resulting vault looks perfectly
+ * healthy: it opens, its layout is ready, and it reports success. What it does
+ * not have is the settings, enabled plugins, and workspace of the folder that
+ * was asked for — so a suite that verifies behaviour against a real vault's
+ * plugin set would silently verify nothing. Hence a hard failure rather than a
+ * warning, and, unlike `SilentAsarFallbackError`, no knob to downgrade it: there
+ * is no version of this outcome worth continuing against.
+ *
+ * Exported so callers of `connectToCdp` / the transport can `instanceof`-match
+ * this specific failure.
+ */
+/**
+ * Parameters for the {@link ConfigDirectoryFallbackError} constructor.
+ */
+export interface ConfigDirectoryFallbackErrorConstructorParams {
+    /**
+    The config folder the vault is actually using, as read back from `app.vault.configDir`.
+     */
+    readonly actualConfigDirectory: string;
+    /**
+    The config folder that was requested through `configDirectory`.
+     */
+    readonly requestedConfigDirectory: string;
+    /**
+    Absolute path to the vault that was opened.
+     */
+    readonly vaultPath: string;
+}
+/**
+ * Thrown when a booted owned instance reports a different `app.vault.configDir`
+ * than the requested
+ * {@link ConfigDirectoryFallbackErrorConstructorParams.requestedConfigDirectory}.
+ * Carries both folder names and the vault path so callers can `instanceof`-match
+ * and report which vault was opened wrongly.
+ */
+export declare class ConfigDirectoryFallbackError extends Error {
+    /**
+    The config folder the vault is actually using.
+     */
+    readonly actualConfigDirectory: string;
+    /**
+    The config folder that was requested.
+     */
+    readonly requestedConfigDirectory: string;
+    /**
+    Absolute path to the vault that was opened.
+     */
+    readonly vaultPath: string;
+    /**
+     * Creates the error from the requested and actual config folders.
+     *
+     * @param params - The requested folder, the folder actually in use, and the vault path.
+     */
+    constructor(params: ConfigDirectoryFallbackErrorConstructorParams);
+}

package/dist/lib/cjs/config-directory.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_directory_exports = {};
+__export(config_directory_exports, {
+  DEFAULT_CONFIG_DIRECTORY: () => DEFAULT_CONFIG_DIRECTORY,
+  assertValidConfigDirectory: () => assertValidConfigDirectory
+});
+module.exports = __toCommonJS(config_directory_exports);
+const DEFAULT_CONFIG_DIRECTORY = ".obsidian";
+function assertValidConfigDirectory(configDirectory) {
+  if (!configDirectory.startsWith(".")) {
+    throw new Error(
+      `Invalid configDirectory ${JSON.stringify(configDirectory)}: an Obsidian config folder name must start with a dot, e.g. '${DEFAULT_CONFIG_DIRECTORY}'.`
+    );
+  }
+  if (configDirectory === ".") {
+    throw new Error(`Invalid configDirectory ${JSON.stringify(configDirectory)}: a bare dot is not a config folder name.`);
+  }
+  if (configDirectory.includes("/") || configDirectory.includes("\\")) {
+    throw new Error(
+      `Invalid configDirectory ${JSON.stringify(configDirectory)}: the config folder sits directly inside the vault, so its name cannot contain a path separator.`
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_CONFIG_DIRECTORY,
+  assertValidConfigDirectory
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/config-directory.d.cts

@@ -0,0 +1,45 @@
+/**
+ * @file
+ *
+ * Validates a vault's **config folder** name — the per-vault override Obsidian
+ * exposes as *Settings → About → Override config folder* and stores as the
+ * `<vaultId>-config` `localStorage` entry (see `transport-desktop-cdp`'s
+ * `openVaultFromStarterScreen`).
+ *
+ * Obsidian validates the same value before applying it, and **silently falls
+ * back** to {@link DEFAULT_CONFIG_DIRECTORY} when the value is rejected
+ * (Obsidian 1.13.7, `app.js`):
+ *
+ * ```js
+ * t.validateConfigDir = function (e) { return "." !== e && e.startsWith(".") && !HD.test(e) };
+ * t.prototype.setConfigDir = function (e) { t.validateConfigDir(e) || (e = UD), this.configDir = e };
+ * ```
+ *
+ * The two structural clauses are reproduced here so a bad value fails loudly at
+ * the call site, naming the option, instead of booting a vault against the wrong
+ * folder. The third — `HD`, a character blacklist minified past recovery — is
+ * deliberately **not** guessed at: a stricter local copy would reject folder
+ * names Obsidian accepts. Anything this validator lets through that Obsidian
+ * then rejects is caught post-boot by the `app.vault.configDir` readback, which
+ * throws `ConfigDirectoryFallbackError`. That readback is the real guarantee;
+ * this is the early, better-worded half of it.
+ */
+/**
+ * The config folder Obsidian uses when a vault has no override — and the one it
+ * silently falls back to when an override fails its own validation.
+ */
+export declare const DEFAULT_CONFIG_DIRECTORY = ".obsidian";
+/**
+ * Throws unless `configDirectory` is a structurally valid Obsidian config folder
+ * name.
+ *
+ * Mirrors the two recoverable clauses of Obsidian's own `validateConfigDir`: the
+ * name must start with a dot and must not be the bare dot. A path separator is
+ * rejected on top of those, because the override names a single folder directly
+ * inside the vault, never a nested path.
+ *
+ * @param configDirectory - The candidate config folder name, e.g. `'.obsidian-desktop'`.
+ * @throws {Error} When the name would be rejected by Obsidian and silently
+ *   replaced with {@link DEFAULT_CONFIG_DIRECTORY}.
+ */
+export declare function assertValidConfigDirectory(configDirectory: string): void;

package/dist/lib/cjs/connect-to-cdp.cjs

@@ -22,19 +22,28 @@ __export(connect_to_cdp_exports, {
 });
 module.exports = __toCommonJS(connect_to_cdp_exports);
 var import_eval_in_obsidian = require("./eval-in-obsidian.cjs");
+var import_headless_vault_config = require("./headless-vault-config.cjs");
 var import_leftover_cleanup = require("./leftover-cleanup.cjs");
 var import_log = require("./log.cjs");
 var import_normalize_optional_properties = require("./normalize-optional-properties.cjs");
 var import_temporary_vault = require("./temporary-vault.cjs");
 var import_transport_desktop_cdp = require("./transport-desktop-cdp.cjs");
 var import_transport_factory = require("./transport-factory.cjs");
+var import_transport_options = require("./transport-options.cjs");
 const DEFAULT_CDP_HOST = "localhost";
 async function connectToCdp(options) {
   const transportOptions = buildCdpTransportOptions(options);
   await sweepLeftovers(transportOptions);
   const transport = await (0, import_transport_factory.createTransportFromOptions)(transportOptions);
-  const vault = new import_temporary_vault.TemporaryVault(options?.vault);
   const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? options?.vault === void 0;
+  const vault = new import_temporary_vault.TemporaryVault(options?.vault, { shouldRemoveDirectoryOnDispose: shouldRemoveVaultOnDispose });
+  if (options?.vault === void 0) {
+    await (0, import_headless_vault_config.ensureHeadlessVaultConfig)({
+      configDirectory: (0, import_transport_options.resolveOwnedConfigDirectory)(transportOptions),
+      label: transportOptions.type,
+      vaultPath: vault.path
+    });
+  }
   await vault.register(transport);
   const { host, port } = resolveEndpoint(transport, options);
   const cdpUrl = `http://${host}:${String(port)}`;
@@ -54,11 +63,7 @@ async function connectToCdp(options) {
     },
     async dispose() {
       try {
-        if (shouldRemoveVaultOnDispose) {
-          await vault.dispose(transport);
-        } else {
-          await transport.unregisterVault(vault.path);
-        }
+        await vault.dispose(transport);
       } finally {
         await transport.dispose?.();
       }
@@ -80,6 +85,7 @@ async function connectToCdp(options) {
 function buildCdpTransportOptions(options) {
   return (0, import_normalize_optional_properties.normalizeOptionalProperties)({
     commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,
+    configDirectory: options?.configDirectory,
     deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,
     host: options?.host,
     isObsidianAppVisible: options?.isObsidianAppVisible ?? true,
@@ -126,4 +132,4 @@ async function sweepLeftovers(transportOptions) {
 0 && (module.exports = {
   connectToCdp
 });
-//# 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 { AsarFallback } from './asar-fallback-detection.cjs';\nimport type { CaptureScreenshotParams } from './capture-screenshot.cjs';\nimport type { ContextId } from './context-id.cjs';\nimport type { ElectronCompatibility } from './electron-compatibility.cjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport {\n  resolveLeftoverMaxAgeInMilliseconds,\n  sweepHostLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\nimport { TemporaryVault } from './temporary-vault.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\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 silent-asar-fallback verdict for an owned instance, read live after boot:\n   * whether the app version it is actually running matches the swapped-in pin, or\n   * the installer silently reverted to its own bundled asar. `undefined` in attach\n   * mode, when no asar was swapped, or when the running version was unreadable. A\n   * `'fallback'` verdict reaches here only when the throw is disabled\n   * ({@link ConnectToCdpOptions.shouldThrowOnSilentAsarFallback} `false`);\n   * otherwise it throws `SilentAsarFallbackError` before the connection is created.\n   */\n  readonly asarFallback?: AsarFallback | undefined;\n\n  /**\n   * Captures a PNG screenshot of this connection's Obsidian window, with the\n   * vault path pre-bound.\n   *\n   * Pass `widthInPixels` + `heightInPixels` to pin the viewport for the duration\n   * of the capture, so the emitted PNG is exactly that size whatever size the\n   * window happens to be.\n   *\n   * @param params - The exact size to capture at. Omit to capture the window at its natural size.\n   * @returns A {@link Promise} that resolves to the raw PNG bytes.\n   */\n  captureScreenshot(params?: Except<CaptureScreenshotParams, 'cwd'>): Promise<Uint8Array>;\n\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 reaches here only when the proactive throw\n   * is disabled ({@link ConnectToCdpOptions.shouldThrowOnIncompatibleInstaller}\n   * `false`); otherwise it throws `IncompatibleInstallerVersionError` before the\n   * 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   * The runtime Electron compatibility verdict for an owned instance, read live\n   * after boot: whether the Electron version it is actually running is new enough\n   * for the running app version. `undefined` in attach mode, or when the verdict\n   * is unknown (the live version was unreadable, or the app version carries no\n   * recommended Electron version). An old Electron never blocks \u2014 it only warns \u2014\n   * so unlike {@link compatibility} there is no throwing tier.\n   */\n  readonly electronCompatibility?: ElectronCompatibility | undefined;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `input`\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 (`callback`, optional `input`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `callback`.\n   */\n  evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Input, 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: TemporaryVault;\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   * Whether an **unrunnable** installer\u2194app version pair fails fast before launch.\n   *\n   * When `true` (the default), an installer below the app's run floor throws\n   * `IncompatibleInstallerVersionError` from version resolution before anything is\n   * downloaded or launched. Set `false` to let the pin proceed to launch \u2014 where\n   * the reactive dead-boot fast-fail still catches the black-screen boot, and the\n   * `'unrunnable'` verdict is surfaced on {@link CdpConnection.compatibility}\n   * rather than thrown. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnIncompatibleInstaller?: boolean;\n\n  /**\n   * Whether a post-boot **silent asar fallback** fails fast.\n   *\n   * When an asar is swapped onto an installer shell too old for it, the instance\n   * may silently revert to the installer's own bundled asar and run the **wrong\n   * (older)** version behind a healthy UI. When `true` (the default), the running\n   * app version is verified against the pin post-boot and a mismatch throws\n   * `SilentAsarFallbackError`. Set `false` to let the boot proceed \u2014 the mismatch\n   * is then surfaced on {@link CdpConnection.asarFallback} rather than thrown.\n   * Ignored in attach mode ({@link port} set) and when no asar is swapped.\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnSilentAsarFallback?: boolean;\n\n  /**\n   * Whether the owned-instance compatibility **nag warnings** are emitted.\n   *\n   * Covers both the offline installer\u2194app warning and the post-boot\n   * runtime-Electron warning. When `true` (the default) each fires via the harness\n   * log; set `false` to silence both \u2014 the verdicts are still surfaced on\n   * {@link CdpConnection.compatibility} / {@link CdpConnection.electronCompatibility},\n   * only the log is suppressed. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldWarnOnCompatibilityIssues?: 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 = buildCdpTransportOptions(options);\n  await sweepLeftovers(transportOptions);\n  const transport = await createTransportFromOptions(transportOptions);\n  const vault = new TemporaryVault(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 asarFallback = transport instanceof DesktopCdpTransport ? transport.getAsarFallback() : undefined;\n  const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : undefined;\n  const electronCompatibility = transport instanceof DesktopCdpTransport ? transport.getElectronCompatibility() : undefined;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n    ...(asarFallback && { asarFallback }),\n    ...(compatibility && { compatibility }),\n    ...(electronCompatibility && { electronCompatibility }),\n\n    async captureScreenshot(params?: Except<CaptureScreenshotParams, 'cwd'>): Promise<Uint8Array> {\n      // Every transport `connectToCdp` builds is a DesktopCdpTransport, which\n      // Implements the optional method \u2014 but the interface still types it\n      // Optional, so the absence is reported rather than silently thrown at.\n      if (!transport.captureScreenshot) {\n        throw new Error('connectToCdp: this transport cannot capture screenshots.');\n      }\n\n      return transport.captureScreenshot({ ...params, cwd: vault.path });\n    },\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<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Input, 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). Unset knobs pass through\n * as `undefined` and are read with `?? default` / `!== undefined` guards\n * downstream, so an explicit `undefined` is indistinguishable from an absent key.\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 normalizeOptionalProperties<ObsidianCdpTransportOptions>({\n    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,\n    deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,\n    host: options?.host,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    obsidianInstallerVersion: options?.obsidianInstallerVersion,\n    obsidianVersion: options?.obsidianVersion,\n    port: options?.port,\n    shouldDisableSandbox: options?.shouldDisableSandbox,\n    shouldThrowOnIncompatibleInstaller: options?.shouldThrowOnIncompatibleInstaller,\n    shouldThrowOnSilentAsarFallback: options?.shouldThrowOnSilentAsarFallback,\n    shouldWarnOnCompatibilityIssues: options?.shouldWarnOnCompatibilityIssues,\n    type: 'obsidian-cdp'\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/**\n * Removes the host-side temp directories earlier runs leaked, before this\n * connection adds its own.\n *\n * `connectToCdp` mints the same `temp-vault-*` / owned `userdata-*` directories\n * the test global setup does, and an ad-hoc debugging session is exactly the\n * kind that gets killed with a leftover behind \u2014 so it sweeps too. Age-gated and\n * best-effort; see the core's `sweepLeftovers`.\n *\n * @param transportOptions - The resolved transport options (source of the sweep knobs).\n */\nasync function sweepLeftovers(transportOptions: ObsidianCdpTransportOptions): Promise<void> {\n  if (!willSweepLeftovers(transportOptions)) {\n    return;\n  }\n\n  try {\n    const result = await sweepHostLeftovers({\n      maxAgeInMilliseconds: resolveLeftoverMaxAgeInMilliseconds(transportOptions)\n    });\n    if (result.removedCount > 0 || result.failedCount > 0) {\n      log(\n        `[connect-to-cdp] Swept ${String(result.removedCount)} leftover temp director(ies) from earlier runs `\n          + `(${String(result.failedCount)} still in use).`\n      );\n    }\n  } catch (error: unknown) {\n    log(`[connect-to-cdp] Leftover sweep error (non-fatal): ${String(error)}`);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}

+//# 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 { AsarFallback } from './asar-fallback-detection.cjs';\nimport type { CaptureScreenshotParams } from './capture-screenshot.cjs';\nimport type { ContextId } from './context-id.cjs';\nimport type { ElectronCompatibility } from './electron-compatibility.cjs';\nimport type {\n  EvalInObsidianParams,\n  GenericObject\n} from './eval-in-obsidian.cjs';\nimport type { InstallerCompatibility } from './installer-compatibility.cjs';\nimport type { ObsidianCdpTransportOptions } from './transport-options.cjs';\n\nimport { evalInObsidian } from './eval-in-obsidian.cjs';\nimport { ensureHeadlessVaultConfig } from './headless-vault-config.cjs';\nimport {\n  resolveLeftoverMaxAgeInMilliseconds,\n  sweepHostLeftovers,\n  willSweepLeftovers\n} from './leftover-cleanup.cjs';\nimport { log } from './log.cjs';\nimport { normalizeOptionalProperties } from './normalize-optional-properties.cjs';\nimport { TemporaryVault } from './temporary-vault.cjs';\nimport { DesktopCdpTransport } from './transport-desktop-cdp.cjs';\nimport { createTransportFromOptions } from './transport-factory.cjs';\nimport { resolveOwnedConfigDirectory } from './transport-options.cjs';\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 silent-asar-fallback verdict for an owned instance, read live after boot:\n   * whether the app version it is actually running matches the swapped-in pin, or\n   * the installer silently reverted to its own bundled asar. `undefined` in attach\n   * mode, when no asar was swapped, or when the running version was unreadable. A\n   * `'fallback'` verdict reaches here only when the throw is disabled\n   * ({@link ConnectToCdpOptions.shouldThrowOnSilentAsarFallback} `false`);\n   * otherwise it throws `SilentAsarFallbackError` before the connection is created.\n   */\n  readonly asarFallback?: AsarFallback | undefined;\n\n  /**\n   * Captures a PNG screenshot of this connection's Obsidian window, with the\n   * vault path pre-bound.\n   *\n   * Pass `widthInPixels` + `heightInPixels` to pin the viewport for the duration\n   * of the capture, so the emitted PNG is exactly that size whatever size the\n   * window happens to be.\n   *\n   * @param params - The exact size to capture at. Omit to capture the window at its natural size.\n   * @returns A {@link Promise} that resolves to the raw PNG bytes.\n   */\n  captureScreenshot(params?: Except<CaptureScreenshotParams, 'cwd'>): Promise<Uint8Array>;\n\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 reaches here only when the proactive throw\n   * is disabled ({@link ConnectToCdpOptions.shouldThrowOnIncompatibleInstaller}\n   * `false`); otherwise it throws `IncompatibleInstallerVersionError` before the\n   * 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   * The runtime Electron compatibility verdict for an owned instance, read live\n   * after boot: whether the Electron version it is actually running is new enough\n   * for the running app version. `undefined` in attach mode, or when the verdict\n   * is unknown (the live version was unreadable, or the app version carries no\n   * recommended Electron version). An old Electron never blocks \u2014 it only warns \u2014\n   * so unlike {@link compatibility} there is no throwing tier.\n   */\n  readonly electronCompatibility?: ElectronCompatibility | undefined;\n\n  /**\n   * Evaluates a self-contained function inside Obsidian via the rich helper\n   * path, receiving `{ app, lib, obsidianModule, context }` plus any `input`\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 (`callback`, optional `input`/`contextId`).\n   * @returns A {@link Promise} that resolves to the return value of `callback`.\n   */\n  evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n    params: Except<EvalInObsidianParams<Input, 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: TemporaryVault;\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   * The vault's **config folder** \u2014 Obsidian's per-vault *Override config\n   * folder* setting, e.g. `'.obsidian-desktop'`. Set it to open a vault that\n   * keeps its settings somewhere other than `.obsidian`; without it such a vault\n   * opens against `.obsidian`, which for a vault that has a stale one beside the\n   * real folder means opening successfully against the wrong settings.\n   *\n   * Must start with a dot, must not be the bare dot, and must not contain a path\n   * separator \u2014 anything else throws before Obsidian launches, since Obsidian\n   * would silently substitute `.obsidian`. After the vault opens, its actual\n   * `app.vault.configDir` is read back and a mismatch throws\n   * `ConfigDirectoryFallbackError`.\n   *\n   * Ignored in attach mode ({@link ConnectToCdpOptions.port} set), where the\n   * vault is opened by the user's own Obsidian under its own config.\n   *\n   * @default `undefined` (Obsidian's own default, `.obsidian`)\n   */\n  readonly configDirectory?: string;\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   * Whether an **unrunnable** installer\u2194app version pair fails fast before launch.\n   *\n   * When `true` (the default), an installer below the app's run floor throws\n   * `IncompatibleInstallerVersionError` from version resolution before anything is\n   * downloaded or launched. Set `false` to let the pin proceed to launch \u2014 where\n   * the reactive dead-boot fast-fail still catches the black-screen boot, and the\n   * `'unrunnable'` verdict is surfaced on {@link CdpConnection.compatibility}\n   * rather than thrown. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnIncompatibleInstaller?: boolean;\n\n  /**\n   * Whether a post-boot **silent asar fallback** fails fast.\n   *\n   * When an asar is swapped onto an installer shell too old for it, the instance\n   * may silently revert to the installer's own bundled asar and run the **wrong\n   * (older)** version behind a healthy UI. When `true` (the default), the running\n   * app version is verified against the pin post-boot and a mismatch throws\n   * `SilentAsarFallbackError`. Set `false` to let the boot proceed \u2014 the mismatch\n   * is then surfaced on {@link CdpConnection.asarFallback} rather than thrown.\n   * Ignored in attach mode ({@link port} set) and when no asar is swapped.\n   *\n   * @default `true`\n   */\n  readonly shouldThrowOnSilentAsarFallback?: boolean;\n\n  /**\n   * Whether the owned-instance compatibility **nag warnings** are emitted.\n   *\n   * Covers both the offline installer\u2194app warning and the post-boot\n   * runtime-Electron warning. When `true` (the default) each fires via the harness\n   * log; set `false` to silence both \u2014 the verdicts are still surfaced on\n   * {@link CdpConnection.compatibility} / {@link CdpConnection.electronCompatibility},\n   * only the log is suppressed. Ignored in attach mode ({@link port} set).\n   *\n   * @default `true`\n   */\n  readonly shouldWarnOnCompatibilityIssues?: 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 = buildCdpTransportOptions(options);\n  await sweepLeftovers(transportOptions);\n  const transport = await createTransportFromOptions(transportOptions);\n  const shouldRemoveVaultOnDispose = options?.shouldRemoveVaultOnDispose ?? (options?.vault === undefined);\n  const vault = new TemporaryVault(options?.vault, { shouldRemoveDirectoryOnDispose: shouldRemoveVaultOnDispose });\n\n  // The headless defaults go only into a vault the harness made \u2014 the same\n  // `options.vault === undefined` discriminator the disposal above turns on. A\n  // Caller-supplied vault is a real one the user keeps, and a debugging session\n  // Has no business rewriting its settings.\n  if (options?.vault === undefined) {\n    await ensureHeadlessVaultConfig({\n      configDirectory: resolveOwnedConfigDirectory(transportOptions),\n      label: transportOptions.type,\n      vaultPath: vault.path\n    });\n  }\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 asarFallback = transport instanceof DesktopCdpTransport ? transport.getAsarFallback() : undefined;\n  const compatibility = transport instanceof DesktopCdpTransport ? transport.getCompatibility() : undefined;\n  const electronCompatibility = transport instanceof DesktopCdpTransport ? transport.getElectronCompatibility() : undefined;\n\n  const connection: CdpConnection = {\n    cdpUrl,\n    ...(asarFallback && { asarFallback }),\n    ...(compatibility && { compatibility }),\n    ...(electronCompatibility && { electronCompatibility }),\n\n    async captureScreenshot(params?: Except<CaptureScreenshotParams, 'cwd'>): Promise<Uint8Array> {\n      // Every transport `connectToCdp` builds is a DesktopCdpTransport, which\n      // Implements the optional method \u2014 but the interface still types it\n      // Optional, so the absence is reported rather than silently thrown at.\n      if (!transport.captureScreenshot) {\n        throw new Error('connectToCdp: this transport cannot capture screenshots.');\n      }\n\n      return transport.captureScreenshot({ ...params, cwd: vault.path });\n    },\n\n    async dispose(): Promise<void> {\n      try {\n        // The vault carries `shouldRemoveVaultOnDispose` itself (handed to its constructor above), so\n        // This is one call rather than a branch: it always unregisters, and removes the directory only\n        // When that flag says to.\n        await vault.dispose(transport);\n      } finally {\n        await transport.dispose?.();\n      }\n    },\n\n    async evalInObsidian<Input extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n      params: Except<EvalInObsidianParams<Input, Result, TContextId>, 'transport' | 'vaultPath'>\n    ): Promise<Result> {\n      return evalInObsidian<Input, 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). Unset knobs pass through\n * as `undefined` and are read with `?? default` / `!== undefined` guards\n * downstream, so an explicit `undefined` is indistinguishable from an absent key.\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 normalizeOptionalProperties<ObsidianCdpTransportOptions>({\n    commandTimeoutInMilliseconds: options?.commandTimeoutInMilliseconds,\n    configDirectory: options?.configDirectory,\n    deadBootGraceInMilliseconds: options?.deadBootGraceInMilliseconds,\n    host: options?.host,\n    isObsidianAppVisible: options?.isObsidianAppVisible ?? true,\n    obsidianInstallerVersion: options?.obsidianInstallerVersion,\n    obsidianVersion: options?.obsidianVersion,\n    port: options?.port,\n    shouldDisableSandbox: options?.shouldDisableSandbox,\n    shouldThrowOnIncompatibleInstaller: options?.shouldThrowOnIncompatibleInstaller,\n    shouldThrowOnSilentAsarFallback: options?.shouldThrowOnSilentAsarFallback,\n    shouldWarnOnCompatibilityIssues: options?.shouldWarnOnCompatibilityIssues,\n    type: 'obsidian-cdp'\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/**\n * Removes the host-side temp directories earlier runs leaked, before this\n * connection adds its own.\n *\n * `connectToCdp` mints the same `temp-vault-*` / owned `userdata-*` directories\n * the test global setup does, and an ad-hoc debugging session is exactly the\n * kind that gets killed with a leftover behind \u2014 so it sweeps too. Age-gated and\n * best-effort; see the core's `sweepLeftovers`.\n *\n * @param transportOptions - The resolved transport options (source of the sweep knobs).\n */\nasync function sweepLeftovers(transportOptions: ObsidianCdpTransportOptions): Promise<void> {\n  if (!willSweepLeftovers(transportOptions)) {\n    return;\n  }\n\n  try {\n    const result = await sweepHostLeftovers({\n      maxAgeInMilliseconds: resolveLeftoverMaxAgeInMilliseconds(transportOptions)\n    });\n    if (result.removedCount > 0 || result.failedCount > 0) {\n      log(\n        `[connect-to-cdp] Swept ${String(result.removedCount)} leftover temp director(ies) from earlier runs `\n          + `(${String(result.failedCount)} still in use).`\n      );\n    }\n  } catch (error: unknown) {\n    log(`[connect-to-cdp] Leftover sweep error (non-fatal): ${String(error)}`);\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/connect-to-cdp.d.cts

@@ -120,6 +120,25 @@ export interface ConnectToCdpOptions {
      * @default `30000`
      */
     readonly commandTimeoutInMilliseconds?: number;
+    /**
+     * The vault's **config folder** — Obsidian's per-vault *Override config
+     * folder* setting, e.g. `'.obsidian-desktop'`. Set it to open a vault that
+     * keeps its settings somewhere other than `.obsidian`; without it such a vault
+     * opens against `.obsidian`, which for a vault that has a stale one beside the
+     * real folder means opening successfully against the wrong settings.
+     *
+     * Must start with a dot, must not be the bare dot, and must not contain a path
+     * separator — anything else throws before Obsidian launches, since Obsidian
+     * would silently substitute `.obsidian`. After the vault opens, its actual
+     * `app.vault.configDir` is read back and a mismatch throws
+     * `ConfigDirectoryFallbackError`.
+     *
+     * Ignored in attach mode ({@link ConnectToCdpOptions.port} set), where the
+     * vault is opened by the user's own Obsidian under its own config.
+     *
+     * @default `undefined` (Obsidian's own default, `.obsidian`)
+     */
+    readonly configDirectory?: string;
     /**
      * Grace window in milliseconds for fast-failing a dead boot of the owned
      * instance — the renderer loaded but the app never bootstrapped (empty