obsidian-integration-testing 10.4.0 → 12.0.0

package/dist/lib/esm/cli.mjs

@@ -1,7 +1,116 @@
+import {
+  existsSync,
+  readdirSync
+} from "node:fs";
+import {
+  join,
+  resolve as resolvePath
+} from "node:path";
 import process from "node:process";
 import { parseArgs } from "node:util";
 import { connectToCdp } from "./connect-to-cdp.mjs";
+import { bootstrapDemoVaultPlugins } from "./demo-vault-bootstrap.mjs";
+const BOOTSTRAP_DEMO_VAULT_COMMAND = "bootstrap-demo-vault";
+const HELP_FLAGS = /* @__PURE__ */ new Set(["--help", "-h"]);
+const SUBCOMMAND_ARGUMENTS_START_INDEX = 3;
+const USAGE = `Usage:
+  obsidian-integration-testing [options]
+      Launch (or attach to) a CDP-enabled Obsidian instance and print its endpoint.
+      Options: --vault, --port, --host, --obsidian-version, --obsidian-installer-version,
+               --command-timeout, --no-remove-vault
+
+  obsidian-integration-testing ${BOOTSTRAP_DEMO_VAULT_COMMAND} [options]
+      Install a demo vault's injected community plugins from their published GitHub
+      releases, so integration tests run without opening Obsidian by hand.
+      Options: --demo-vault <path>   demo vault directory (default: ./demo-vault)
+               --plugin <id>         plugin id to install (repeatable; default: every
+                                     id already present under .obsidian/plugins/)
+               --repo <owner/name>   override the registry lookup (single --plugin only)
+               --version <tag>       pin a release tag (single --plugin only)
+               --force               re-download plugins that are already installed
+`;
 async function main() {
+  const [, , firstArgument] = process.argv;
+  if (firstArgument !== void 0 && HELP_FLAGS.has(firstArgument)) {
+    process.stdout.write(USAGE);
+    return;
+  }
+  if (firstArgument === BOOTSTRAP_DEMO_VAULT_COMMAND) {
+    await runBootstrapDemoVaultCommand(process.argv.slice(SUBCOMMAND_ARGUMENTS_START_INDEX));
+    return;
+  }
+  await runConnectCommand();
+}
+function buildOptions(values) {
+  return {
+    ...values["command-timeout"] !== void 0 && { commandTimeoutInMilliseconds: parseNumber("command-timeout", values["command-timeout"]) },
+    ...values.host !== void 0 && { host: values.host },
+    ...values["no-remove-vault"] === true && { shouldRemoveVaultOnDispose: false },
+    ...values["obsidian-installer-version"] !== void 0 && { obsidianInstallerVersion: values["obsidian-installer-version"] },
+    ...values["obsidian-version"] !== void 0 && { obsidianVersion: values["obsidian-version"] },
+    ...values.port !== void 0 && { port: parseNumber("port", values.port) },
+    ...values.vault !== void 0 && { vault: values.vault }
+  };
+}
+function discoverDemoVaultPluginIds(demoVaultPath) {
+  const pluginsDirectory = join(demoVaultPath, ".obsidian", "plugins");
+  if (!existsSync(pluginsDirectory)) {
+    return [];
+  }
+  return readdirSync(pluginsDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+}
+function parseNumber(flag, raw) {
+  const value = Number(raw);
+  if (!Number.isFinite(value)) {
+    throw new TypeError(`--${flag} must be a number, got: ${raw}`);
+  }
+  return value;
+}
+async function runBootstrapDemoVaultCommand(commandArguments) {
+  const { values } = parseArgs({
+    // eslint-disable-next-line unicorn/name-replacements -- `args` is Node's own `parseArgs` option name.
+    args: commandArguments,
+    options: {
+      "demo-vault": { type: "string" },
+      "force": { type: "boolean" },
+      "plugin": { multiple: true, type: "string" },
+      "repo": { type: "string" },
+      "version": { type: "string" }
+    }
+  });
+  const demoVaultPath = resolvePath(values["demo-vault"] ?? join(process.cwd(), "demo-vault"));
+  const pluginIds = values.plugin ?? discoverDemoVaultPluginIds(demoVaultPath);
+  if (pluginIds.length === 0) {
+    throw new Error(
+      `No community plugins to install: ${demoVaultPath} has no .obsidian/plugins/ entries. Name them explicitly, e.g. --plugin fix-require-modules.`
+    );
+  }
+  if (pluginIds.length > 1 && (values.repo !== void 0 || values.version !== void 0)) {
+    throw new Error("--repo and --version apply to a single plugin; pass exactly one --plugin, or run the command once per plugin.");
+  }
+  const injectPlugins = pluginIds.map((pluginId) => ({
+    pluginId,
+    ...values.repo !== void 0 && { repo: values.repo },
+    ...values.version !== void 0 && { version: values.version }
+  }));
+  const result = await bootstrapDemoVaultPlugins({
+    demoVaultPath,
+    injectPlugins,
+    shouldForce: values.force === true
+  });
+  for (const info of result.installed) {
+    process.stdout.write(`Installed ${info.pluginId} from ${info.repo}@${info.version ?? "latest"}: ${info.assetNames.join(", ")}
+`);
+  }
+  if (result.skippedPluginIds.length > 0) {
+    process.stdout.write(`Already installed (use --force to re-download): ${result.skippedPluginIds.join(", ")}
+`);
+  }
+  if (result.installed.length === 0) {
+    process.stdout.write("Nothing to install.\n");
+  }
+}
+async function runConnectCommand() {
   const { values } = parseArgs({
     options: {
       "command-timeout": { type: "string" },
@@ -27,24 +136,6 @@ Press Ctrl+C to stop.
   process.stdout.write("\nShutting down\u2026\n");
   await connection.dispose();
 }
-function buildOptions(values) {
-  return {
-    ...values["command-timeout"] !== void 0 && { commandTimeoutInMilliseconds: parseNumber("command-timeout", values["command-timeout"]) },
-    ...values.host !== void 0 && { host: values.host },
-    ...values["no-remove-vault"] === true && { shouldRemoveVaultOnDispose: false },
-    ...values["obsidian-installer-version"] !== void 0 && { obsidianInstallerVersion: values["obsidian-installer-version"] },
-    ...values["obsidian-version"] !== void 0 && { obsidianVersion: values["obsidian-version"] },
-    ...values.port !== void 0 && { port: parseNumber("port", values.port) },
-    ...values.vault !== void 0 && { vault: values.vault }
-  };
-}
-function parseNumber(flag, raw) {
-  const value = Number(raw);
-  if (!Number.isFinite(value)) {
-    throw new TypeError(`--${flag} must be a number, got: ${raw}`);
-  }
-  return value;
-}
 function waitForShutdownOrInstanceClose(cdpUrl) {
   const POLL_INTERVAL_IN_MILLISECONDS = 1e3;
   return new Promise((resolve) => {
@@ -79,4 +170,4 @@ function waitForShutdownOrInstanceClose(cdpUrl) {
 export {
   main
 };
-//# 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 TypeError(`--${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      probeAlive().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 probeAlive(): 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,UAAU,KAAK,IAAI,2BAA2B,GAAG,EAAE;AAAA,EAC/D;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": []
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/cli.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * The package's CLI. Two commands:\n *\n * - The **default** (no subcommand) \u2014 a thin CLI over {@link connectToCdp}: launches\n *   (or attaches to) a CDP-enabled Obsidian instance with the runtime helper\n *   namespace bootstrapped, prints the chosen CDP port/URL, and stays alive until\n *   interrupted so an external tool (raw CDP `ws`, DevTools, \u2026) can attach.\n * - **`bootstrap-demo-vault`** \u2014 installs a demo vault's injected community plugins\n *   headlessly (see `demo-vault-bootstrap.ts`). This is the copy-pasteable remedy\n *   `buildDemoVaultPopulate`'s throw names, replacing the GUI-only \"open\n *   `demo-vault/` in Obsidian once\" step that a fresh clone or CI cannot perform.\n *\n * Anything that is not a recognized subcommand falls through to the default\n * command, so `obsidian-integration-testing --vault \u2026` keeps working unchanged.\n */\n\n/* v8 ignore start -- Integration-time CLI (launches Obsidian / CDP, downloads releases) covered manually, not by unit tests. */\n\nimport {\n  existsSync,\n  readdirSync\n} from 'node:fs';\nimport {\n  join,\n  resolve as resolvePath\n} from 'node:path';\nimport process from 'node:process';\nimport { parseArgs } from 'node:util';\n\nimport type { ConnectToCdpOptions } from './connect-to-cdp.mjs';\nimport type { InjectPluginParams } from './demo-vault-populate.mjs';\n\nimport { connectToCdp } from './connect-to-cdp.mjs';\nimport { bootstrapDemoVaultPlugins } from './demo-vault-bootstrap.mjs';\n\nconst BOOTSTRAP_DEMO_VAULT_COMMAND = 'bootstrap-demo-vault';\nconst HELP_FLAGS = new Set(['--help', '-h']);\n\n/**\nIndex of a subcommand's first argument in `process.argv` (`[node, script, subcommand, \u2026]`).\n */\nconst SUBCOMMAND_ARGUMENTS_START_INDEX = 3;\n\nconst USAGE = `Usage:\n  obsidian-integration-testing [options]\n      Launch (or attach to) a CDP-enabled Obsidian instance and print its endpoint.\n      Options: --vault, --port, --host, --obsidian-version, --obsidian-installer-version,\n               --command-timeout, --no-remove-vault\n\n  obsidian-integration-testing ${BOOTSTRAP_DEMO_VAULT_COMMAND} [options]\n      Install a demo vault's injected community plugins from their published GitHub\n      releases, so integration tests run without opening Obsidian by hand.\n      Options: --demo-vault <path>   demo vault directory (default: ./demo-vault)\n               --plugin <id>         plugin id to install (repeatable; default: every\n                                     id already present under .obsidian/plugins/)\n               --repo <owner/name>   override the registry lookup (single --plugin only)\n               --version <tag>       pin a release tag (single --plugin only)\n               --force               re-download plugins that are already installed\n`;\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 * Dispatches to the requested subcommand, falling through to the default CDP\n * command for anything that is not one.\n *\n * @returns A {@link Promise} that resolves once the chosen command has finished.\n */\nexport async function main(): Promise<void> {\n  const [, , firstArgument] = process.argv;\n\n  if (firstArgument !== undefined && HELP_FLAGS.has(firstArgument)) {\n    process.stdout.write(USAGE);\n    return;\n  }\n\n  if (firstArgument === BOOTSTRAP_DEMO_VAULT_COMMAND) {\n    await runBootstrapDemoVaultCommand(process.argv.slice(SUBCOMMAND_ARGUMENTS_START_INDEX));\n    return;\n  }\n\n  await runConnectCommand();\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 * Lists the plugin ids already present under a demo vault's `.obsidian/plugins/`, used as the default\n * install set when `--plugin` is omitted. A folder that exists but lacks `main.js` is exactly the state\n * this command repairs, so presence \u2014 not completeness \u2014 is the criterion.\n *\n * @param demoVaultPath - The demo vault root.\n * @returns The plugin ids, or an empty array when the vault has no plugins folder.\n */\nfunction discoverDemoVaultPluginIds(demoVaultPath: string): string[] {\n  const pluginsDirectory = join(demoVaultPath, '.obsidian', 'plugins');\n  if (!existsSync(pluginsDirectory)) {\n    return [];\n  }\n  return readdirSync(pluginsDirectory, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);\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 TypeError(`--${flag} must be a number, got: ${raw}`);\n  }\n  return value;\n}\n\n/**\n * Runs the `bootstrap-demo-vault` subcommand.\n *\n * @param commandArguments - The subcommand's arguments (everything after the subcommand name).\n * @returns A {@link Promise} that resolves once the install has finished.\n * @throws Error if no plugin ids can be determined, or `--repo` / `--version` are used with several plugins.\n */\nasync function runBootstrapDemoVaultCommand(commandArguments: string[]): Promise<void> {\n  const { values } = parseArgs({\n    // eslint-disable-next-line unicorn/name-replacements -- `args` is Node's own `parseArgs` option name.\n    args: commandArguments,\n    options: {\n      'demo-vault': { type: 'string' },\n      'force': { type: 'boolean' },\n      'plugin': { multiple: true, type: 'string' },\n      'repo': { type: 'string' },\n      'version': { type: 'string' }\n    }\n  });\n\n  const demoVaultPath = resolvePath(values['demo-vault'] ?? join(process.cwd(), 'demo-vault'));\n  const pluginIds = values.plugin ?? discoverDemoVaultPluginIds(demoVaultPath);\n\n  if (pluginIds.length === 0) {\n    throw new Error(\n      `No community plugins to install: ${demoVaultPath} has no .obsidian/plugins/ entries. `\n        + 'Name them explicitly, e.g. --plugin fix-require-modules.'\n    );\n  }\n\n  if (pluginIds.length > 1 && (values.repo !== undefined || values.version !== undefined)) {\n    throw new Error('--repo and --version apply to a single plugin; pass exactly one --plugin, or run the command once per plugin.');\n  }\n\n  const injectPlugins: InjectPluginParams[] = pluginIds.map((pluginId) => ({\n    pluginId,\n    ...(values.repo !== undefined && { repo: values.repo }),\n    ...(values.version !== undefined && { version: values.version })\n  }));\n\n  const result = await bootstrapDemoVaultPlugins({\n    demoVaultPath,\n    injectPlugins,\n    shouldForce: values.force === true\n  });\n\n  for (const info of result.installed) {\n    process.stdout.write(`Installed ${info.pluginId} from ${info.repo}@${info.version ?? 'latest'}: ${info.assetNames.join(', ')}\\n`);\n  }\n\n  if (result.skippedPluginIds.length > 0) {\n    process.stdout.write(`Already installed (use --force to re-download): ${result.skippedPluginIds.join(', ')}\\n`);\n  }\n\n  if (result.installed.length === 0) {\n    process.stdout.write('Nothing to install.\\n');\n  }\n}\n\n/**\n * Runs the default command: parses CLI arguments, opens the connection, prints its\n * endpoint, and blocks until `SIGINT`/`SIGTERM` or the owned Obsidian window is\n * closed, disposing the connection on shutdown.\n *\n * @returns A {@link Promise} that resolves once the connection has been disposed.\n */\nasync function runConnectCommand(): 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 * 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      probeAlive().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 probeAlive(): 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": "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",
  "names": []
}


package/dist/lib/esm/community-plugin-registry.d.mts

@@ -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
+ * every fleet 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/esm/community-plugin-registry.mjs

@@ -0,0 +1,23 @@
+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;
+}
+export {
+  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/esm/context-provider.d.mts

@@ -4,11 +4,16 @@
  * Framework-neutral context provider for integration test state.
  *
  * Each framework adapter (vitest, jest) registers resolvers via
- * {@link setTransportOptionsResolver} and {@link setVaultPathResolver}
- * during module initialization. Core modules call the corresponding
- * getters to retrieve state without depending on any specific test framework.
+ * {@link setTransportOptionsResolver}, {@link setVaultPathResolver} and
+ * {@link setSetupErrorResolver} during module initialization. Core modules call the
+ * corresponding getters to retrieve state without depending on any specific test framework.
  */
+import type { IntegrationSetupFailedErrorConstructorParams } from './integration-setup-failed-error.mjs';
 import type { ObsidianTransportOptions } from './transport-options.mjs';
+/**
+ * A function that resolves the failure of this project's global setup, if it failed.
+ */
+export type SetupErrorResolver = () => IntegrationSetupFailedErrorConstructorParams | undefined;
 /**
  * A function that resolves the current transport options.
  */
@@ -17,6 +22,15 @@ export type TransportOptionsResolver = () => ObsidianTransportOptions | undefine
  * A function that resolves the current vault path.
  */
 export type VaultPathResolver = () => string | undefined;
+/**
+ * Returns the failure of this project's global setup, as published by the registered
+ * framework adapter. A test worker must fail with this rather than build a transport
+ * of its own: with no options published, the default is the owned **desktop** CDP
+ * instance, whatever platform the project asked for.
+ *
+ * @returns The setup failure, or `undefined` if the setup succeeded (or never ran).
+ */
+export declare function getSetupError(): IntegrationSetupFailedErrorConstructorParams | undefined;
 /**
  * Returns the transport options resolved by the registered framework adapter.
  *
@@ -29,6 +43,15 @@ export declare function getTransportOptions(): ObsidianTransportOptions | undefi
  * @returns The vault path, or `undefined` if not configured (falls back to `process.cwd()`).
  */
 export declare function getVaultPath(): string | undefined;
+/**
+ * Registers a resolver function for this project's setup failure. Called by framework
+ * adapters at module load time to bridge their native injection mechanisms — most
+ * importantly in the **per-worker** setup file, which is where the failure has to be
+ * seen (see `vitest/setup.ts`).
+ *
+ * @param callback - The resolver function.
+ */
+export declare function setSetupErrorResolver(callback: SetupErrorResolver): void;
 /**
  * Registers a resolver function for transport options. Called by framework
  * adapters at module load time to bridge their native injection mechanisms.

package/dist/lib/esm/context-provider.mjs

@@ -1,11 +1,18 @@
+let setupErrorResolver;
 let transportOptionsResolver;
 let vaultPathResolver;
+function getSetupError() {
+  return setupErrorResolver?.();
+}
 function getTransportOptions() {
   return transportOptionsResolver?.();
 }
 function getVaultPath() {
   return vaultPathResolver?.();
 }
+function setSetupErrorResolver(callback) {
+  setupErrorResolver = callback;
+}
 function setTransportOptionsResolver(callback) {
   transportOptionsResolver = callback;
 }
@@ -13,9 +20,11 @@ function setVaultPathResolver(callback) {
   vaultPathResolver = callback;
 }
 export {
+  getSetupError,
   getTransportOptions,
   getVaultPath,
+  setSetupErrorResolver,
   setTransportOptionsResolver,
   setVaultPathResolver
 };
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2NvbnRleHQtcHJvdmlkZXIudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qKlxuICogQGZpbGVcbiAqXG4gKiBGcmFtZXdvcmstbmV1dHJhbCBjb250ZXh0IHByb3ZpZGVyIGZvciBpbnRlZ3JhdGlvbiB0ZXN0IHN0YXRlLlxuICpcbiAqIEVhY2ggZnJhbWV3b3JrIGFkYXB0ZXIgKHZpdGVzdCwgamVzdCkgcmVnaXN0ZXJzIHJlc29sdmVycyB2aWFcbiAqIHtAbGluayBzZXRUcmFuc3BvcnRPcHRpb25zUmVzb2x2ZXJ9LCB7QGxpbmsgc2V0VmF1bHRQYXRoUmVzb2x2ZXJ9IGFuZFxuICoge0BsaW5rIHNldFNldHVwRXJyb3JSZXNvbHZlcn0gZHVyaW5nIG1vZHVsZSBpbml0aWFsaXphdGlvbi4gQ29yZSBtb2R1bGVzIGNhbGwgdGhlXG4gKiBjb3JyZXNwb25kaW5nIGdldHRlcnMgdG8gcmV0cmlldmUgc3RhdGUgd2l0aG91dCBkZXBlbmRpbmcgb24gYW55IHNwZWNpZmljIHRlc3QgZnJhbWV3b3JrLlxuICovXG5cbmltcG9ydCB0eXBlIHsgSW50ZWdyYXRpb25TZXR1cEZhaWxlZEVycm9yQ29uc3RydWN0b3JQYXJhbXMgfSBmcm9tICcuL2ludGVncmF0aW9uLXNldHVwLWZhaWxlZC1lcnJvci5tanMnO1xuaW1wb3J0IHR5cGUgeyBPYnNpZGlhblRyYW5zcG9ydE9wdGlvbnMgfSBmcm9tICcuL3RyYW5zcG9ydC1vcHRpb25zLm1qcyc7XG5cbi8qKlxuICogQSBmdW5jdGlvbiB0aGF0IHJlc29sdmVzIHRoZSBmYWlsdXJlIG9mIHRoaXMgcHJvamVjdCdzIGdsb2JhbCBzZXR1cCwgaWYgaXQgZmFpbGVkLlxuICovXG5leHBvcnQgdHlwZSBTZXR1cEVycm9yUmVzb2x2ZXIgPSAoKSA9PiBJbnRlZ3JhdGlvblNldHVwRmFpbGVkRXJyb3JDb25zdHJ1Y3RvclBhcmFtcyB8IHVuZGVmaW5lZDtcblxuLyoqXG4gKiBBIGZ1bmN0aW9uIHRoYXQgcmVzb2x2ZXMgdGhlIGN1cnJlbnQgdHJhbnNwb3J0IG9wdGlvbnMuXG4gKi9cbmV4cG9ydCB0eXBlIFRyYW5zcG9ydE9wdGlvbnNSZXNvbHZlciA9ICgpID0+IE9ic2lkaWFuVHJhbnNwb3J0T3B0aW9ucyB8IHVuZGVmaW5lZDtcblxuLyoqXG4gKiBBIGZ1bmN0aW9uIHRoYXQgcmVzb2x2ZXMgdGhlIGN1cnJlbnQgdmF1bHQgcGF0aC5cbiAqL1xuZXhwb3J0IHR5cGUgVmF1bHRQYXRoUmVzb2x2ZXIgPSAoKSA9PiBzdHJpbmcgfCB1bmRlZmluZWQ7XG5cbmxldCBzZXR1cEVycm9yUmVzb2x2ZXI6IFNldHVwRXJyb3JSZXNvbHZlciB8IHVuZGVmaW5lZDtcbmxldCB0cmFuc3BvcnRPcHRpb25zUmVzb2x2ZXI6IFRyYW5zcG9ydE9wdGlvbnNSZXNvbHZlciB8IHVuZGVmaW5lZDtcbmxldCB2YXVsdFBhdGhSZXNvbHZlcjogdW5kZWZpbmVkIHwgVmF1bHRQYXRoUmVzb2x2ZXI7XG5cbi8qKlxuICogUmV0dXJucyB0aGUgZmFpbHVyZSBvZiB0aGlzIHByb2plY3QncyBnbG9iYWwgc2V0dXAsIGFzIHB1Ymxpc2hlZCBieSB0aGUgcmVnaXN0ZXJlZFxuICogZnJhbWV3b3JrIGFkYXB0ZXIuIEEgdGVzdCB3b3JrZXIgbXVzdCBmYWlsIHdpdGggdGhpcyByYXRoZXIgdGhhbiBidWlsZCBhIHRyYW5zcG9ydFxuICogb2YgaXRzIG93bjogd2l0aCBubyBvcHRpb25zIHB1Ymxpc2hlZCwgdGhlIGRlZmF1bHQgaXMgdGhlIG93bmVkICoqZGVza3RvcCoqIENEUFxuICogaW5zdGFuY2UsIHdoYXRldmVyIHBsYXRmb3JtIHRoZSBwcm9qZWN0IGFza2VkIGZvci5cbiAqXG4gKiBAcmV0dXJucyBUaGUgc2V0dXAgZmFpbHVyZSwgb3IgYHVuZGVmaW5lZGAgaWYgdGhlIHNldHVwIHN1Y2NlZWRlZCAob3IgbmV2ZXIgcmFuKS5cbiAqL1xuZXhwb3J0IGZ1bmN0aW9uIGdldFNldHVwRXJyb3IoKTogSW50ZWdyYXRpb25TZXR1cEZhaWxlZEVycm9yQ29uc3RydWN0b3JQYXJhbXMgfCB1bmRlZmluZWQge1xuICByZXR1cm4gc2V0dXBFcnJvclJlc29sdmVyPy4oKTtcbn1cblxuLyoqXG4gKiBSZXR1cm5zIHRoZSB0cmFuc3BvcnQgb3B0aW9ucyByZXNvbHZlZCBieSB0aGUgcmVnaXN0ZXJlZCBmcmFtZXdvcmsgYWRhcHRlci5cbiAqXG4gKiBAcmV0dXJucyBUaGUgdHJhbnNwb3J0IG9wdGlvbnMsIG9yIGB1bmRlZmluZWRgIGlmIG5vdCBjb25maWd1cmVkLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0VHJhbnNwb3J0T3B0aW9ucygpOiBPYnNpZGlhblRyYW5zcG9ydE9wdGlvbnMgfCB1bmRlZmluZWQge1xuICByZXR1cm4gdHJhbnNwb3J0T3B0aW9uc1Jlc29sdmVyPy4oKTtcbn1cblxuLyoqXG4gKiBSZXR1cm5zIHRoZSB2YXVsdCBwYXRoIHJlc29sdmVkIGJ5IHRoZSByZWdpc3RlcmVkIGZyYW1ld29yayBhZGFwdGVyLlxuICpcbiAqIEByZXR1cm5zIFRoZSB2YXVsdCBwYXRoLCBvciBgdW5kZWZpbmVkYCBpZiBub3QgY29uZmlndXJlZCAoZmFsbHMgYmFjayB0byBgcHJvY2Vzcy5jd2QoKWApLlxuICovXG5leHBvcnQgZnVuY3Rpb24gZ2V0VmF1bHRQYXRoKCk6IHN0cmluZyB8IHVuZGVmaW5lZCB7XG4gIHJldHVybiB2YXVsdFBhdGhSZXNvbHZlcj8uKCk7XG59XG5cbi8qKlxuICogUmVnaXN0ZXJzIGEgcmVzb2x2ZXIgZnVuY3Rpb24gZm9yIHRoaXMgcHJvamVjdCdzIHNldHVwIGZhaWx1cmUuIENhbGxlZCBieSBmcmFtZXdvcmtcbiAqIGFkYXB0ZXJzIGF0IG1vZHVsZSBsb2FkIHRpbWUgdG8gYnJpZGdlIHRoZWlyIG5hdGl2ZSBpbmplY3Rpb24gbWVjaGFuaXNtcyBcdTIwMTQgbW9zdFxuICogaW1wb3J0YW50bHkgaW4gdGhlICoqcGVyLXdvcmtlcioqIHNldHVwIGZpbGUsIHdoaWNoIGlzIHdoZXJlIHRoZSBmYWlsdXJlIGhhcyB0byBiZVxuICogc2VlbiAoc2VlIGB2aXRlc3Qvc2V0dXAudHNgKS5cbiAqXG4gKiBAcGFyYW0gY2FsbGJhY2sgLSBUaGUgcmVzb2x2ZXIgZnVuY3Rpb24uXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzZXRTZXR1cEVycm9yUmVzb2x2ZXIoY2FsbGJhY2s6IFNldHVwRXJyb3JSZXNvbHZlcik6IHZvaWQge1xuICBzZXR1cEVycm9yUmVzb2x2ZXIgPSBjYWxsYmFjaztcbn1cblxuLyoqXG4gKiBSZWdpc3RlcnMgYSByZXNvbHZlciBmdW5jdGlvbiBmb3IgdHJhbnNwb3J0IG9wdGlvbnMuIENhbGxlZCBieSBmcmFtZXdvcmtcbiAqIGFkYXB0ZXJzIGF0IG1vZHVsZSBsb2FkIHRpbWUgdG8gYnJpZGdlIHRoZWlyIG5hdGl2ZSBpbmplY3Rpb24gbWVjaGFuaXNtcy5cbiAqXG4gKiBAcGFyYW0gY2FsbGJhY2sgLSBUaGUgcmVzb2x2ZXIgZnVuY3Rpb24uXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzZXRUcmFuc3BvcnRPcHRpb25zUmVzb2x2ZXIoY2FsbGJhY2s6IFRyYW5zcG9ydE9wdGlvbnNSZXNvbHZlcik6IHZvaWQge1xuICB0cmFuc3BvcnRPcHRpb25zUmVzb2x2ZXIgPSBjYWxsYmFjaztcbn1cblxuLyoqXG4gKiBSZWdpc3RlcnMgYSByZXNvbHZlciBmdW5jdGlvbiBmb3IgdGhlIHZhdWx0IHBhdGguIENhbGxlZCBieSBmcmFtZXdvcmtcbiAqIGFkYXB0ZXJzIGF0IG1vZHVsZSBsb2FkIHRpbWUgdG8gYnJpZGdlIHRoZWlyIG5hdGl2ZSBpbmplY3Rpb24gbWVjaGFuaXNtcy5cbiAqXG4gKiBAcGFyYW0gY2FsbGJhY2sgLSBUaGUgcmVzb2x2ZXIgZnVuY3Rpb24uXG4gKi9cbmV4cG9ydCBmdW5jdGlvbiBzZXRWYXVsdFBhdGhSZXNvbHZlcihjYWxsYmFjazogVmF1bHRQYXRoUmVzb2x2ZXIpOiB2b2lkIHtcbiAgdmF1bHRQYXRoUmVzb2x2ZXIgPSBjYWxsYmFjaztcbn1cbiJdLAogICJtYXBwaW5ncyI6ICJBQTZCQSxJQUFJO0FBQ0osSUFBSTtBQUNKLElBQUk7QUFVRyxTQUFTLGdCQUEwRTtBQUN4RixTQUFPLHFCQUFxQjtBQUM5QjtBQU9PLFNBQVMsc0JBQTREO0FBQzFFLFNBQU8sMkJBQTJCO0FBQ3BDO0FBT08sU0FBUyxlQUFtQztBQUNqRCxTQUFPLG9CQUFvQjtBQUM3QjtBQVVPLFNBQVMsc0JBQXNCLFVBQW9DO0FBQ3hFLHVCQUFxQjtBQUN2QjtBQVFPLFNBQVMsNEJBQTRCLFVBQTBDO0FBQ3BGLDZCQUEyQjtBQUM3QjtBQVFPLFNBQVMscUJBQXFCLFVBQW1DO0FBQ3RFLHNCQUFvQjtBQUN0QjsiLAogICJuYW1lcyI6IFtdCn0K

package/dist/lib/esm/demo-vault-bootstrap.d.mts

@@ -0,0 +1,113 @@
+/**
+ * @file
+ *
+ * Installs a demo vault's **injected community plugins** headlessly, by downloading
+ * their published GitHub release assets straight into
+ * `demo-vault/.obsidian/plugins/<id>/`.
+ *
+ * `buildDemoVaultPopulate` requires each injected plugin's `main.js` /
+ * `manifest.json` to already be on disk, and throws when they are not. Until this
+ * module existed the only documented remedy was a **GUI step** — open `demo-vault/`
+ * in Obsidian once and let `demo-vault-helper` install the plugin at runtime.
+ * `.obsidian/plugins/*` is gitignored in every fleet plugin repo, so that state
+ * exists on exactly the one machine that did it and is invisible to a fresh clone,
+ * a new machine, or CI. Since a plugin repo's release preflight runs its
+ * integration tests, that made *cutting a release from a clean clone* impossible
+ * without a human opening a GUI.
+ *
+ * Downloading the release assets is the exact headless equivalent: the resulting
+ * folder is what Obsidian itself would have installed, so the shipped
+ * `*-demo-vault-<version>.zip` stays the fleet-standard artifact.
+ *
+ * Two entry points, plus the `bootstrap-demo-vault` CLI subcommand:
+ *
+ * - {@link bootstrapDemoVaultPlugins} — install the missing ones, explicitly.
+ * - {@link buildDemoVaultPopulateAsync} — do that and then build the populate map,
+ *   so a global setup self-heals with no manual step at all.
+ *
+ * The sync `buildDemoVaultPopulate` deliberately keeps throwing: `fetch` has no
+ * synchronous form, so auto-healing can only live on an async sibling. Its message
+ * now names both remedies above instead of the GUI step.
+ */
+import type { BuildDemoVaultPopulateParams, InjectPluginParams } from './demo-vault-populate.mjs';
+import type { PopulateFilesParams } from './temporary-vault.mjs';
+/**
+ * Parameters for {@link bootstrapDemoVaultPlugins}.
+ */
+export interface BootstrapDemoVaultPluginsParams {
+    /**
+    Absolute path to the plugin repo's `demo-vault/` directory.
+     */
+    readonly demoVaultPath: string;
+    /**
+     * The injected plugins to install — the same list passed to `buildDemoVaultPopulate`. Plugins whose
+     * binaries are already present are skipped (unless {@link BootstrapDemoVaultPluginsParams.shouldForce}),
+     * as are plugins carrying an explicit `sourceDirectory`.
+     */
+    readonly injectPlugins: readonly InjectPluginParams[];
+    /**
+     * Whether to re-download plugins that are already installed, replacing them with the current release.
+     * Defaults to `false` — the normal path installs only what is missing, so a warm checkout does no
+     * network I/O at all.
+     */
+    readonly shouldForce?: boolean | undefined;
+}
+/**
+ * The outcome of a {@link bootstrapDemoVaultPlugins} run.
+ */
+export interface BootstrapDemoVaultPluginsResult {
+    /**
+    The plugins that were downloaded and written, in the order they were installed.
+     */
+    readonly installed: readonly InstalledPluginInfo[];
+    /**
+    The ids of plugins left untouched — already installed, or opted out via an explicit `sourceDirectory`.
+     */
+    readonly skippedPluginIds: readonly string[];
+}
+/**
+ * One plugin installed by {@link bootstrapDemoVaultPlugins}.
+ */
+export interface InstalledPluginInfo {
+    /**
+    The asset file names actually written, e.g. `['main.js', 'manifest.json', 'styles.css']`.
+     */
+    readonly assetNames: readonly string[];
+    /**
+    The plugin's id.
+     */
+    readonly pluginId: string;
+    /**
+    The GitHub repository the assets came from, as `owner/name`.
+     */
+    readonly repo: string;
+    /**
+    The release tag downloaded from, or `undefined` when the repository's latest release was used.
+     */
+    readonly version: string | undefined;
+}
+/**
+ * Installs every injected community plugin whose built files are missing from the demo vault, by
+ * downloading its published release assets into `demo-vault/.obsidian/plugins/<id>/`.
+ *
+ * Each plugin's repository comes from its {@link InjectPluginParams.repo} when given, otherwise from
+ * Obsidian's own community plugin registry — the same `id` → `repo` table the in-app community browser
+ * installs from, so no plugin-specific mapping is hardcoded.
+ *
+ * @param params - The {@link BootstrapDemoVaultPluginsParams}.
+ * @returns What was installed and what was skipped.
+ * @throws Error if a plugin's repository cannot be resolved, or a required asset cannot be downloaded.
+ */
+export declare function bootstrapDemoVaultPlugins(params: BootstrapDemoVaultPluginsParams): Promise<BootstrapDemoVaultPluginsResult>;
+/**
+ * The self-healing counterpart of `buildDemoVaultPopulate`: installs any injected community plugin whose
+ * binaries are missing (see {@link bootstrapDemoVaultPlugins}), then builds the populate map exactly as the
+ * synchronous builder does.
+ *
+ * Use this from a global setup's `populate` thunk — both the Vitest and Jest adapters accept a thunk
+ * returning a promise — so a fresh clone, a new machine, or CI needs no manual install step.
+ *
+ * @param params - The same `BuildDemoVaultPopulateParams` the synchronous builder takes.
+ * @returns The populate map, ready to hand to a global setup's `populate` or `TemporaryVault.populate`.
+ */
+export declare function buildDemoVaultPopulateAsync(params: BuildDemoVaultPopulateParams): Promise<PopulateFilesParams>;