obsidian-integration-testing 11.0.0 → 12.0.0

package/dist/lib/cjs/appium-server-marker.cjs

@@ -0,0 +1,115 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+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 __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var appium_server_marker_exports = {};
+__export(appium_server_marker_exports, {
+  checkIsHarnessOwnedAppiumServer: () => checkIsHarnessOwnedAppiumServer,
+  clearAppiumServerMarker: () => clearAppiumServerMarker,
+  readAppiumServerMarker: () => readAppiumServerMarker,
+  writeAppiumServerMarker: () => writeAppiumServerMarker
+});
+module.exports = __toCommonJS(appium_server_marker_exports);
+var import_node_fs = require("node:fs");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_node_process = __toESM(require("node:process"), 1);
+var import_log = require("./log.cjs");
+const MARKER_DIR_NAME = "obsidian-integration-testing";
+const MARKER_FILE_SUFFIX = ".appium-server.json";
+const PROCESS_EXISTENCE_PROBE_SIGNAL = 0;
+function checkIsHarnessOwnedAppiumServer(marker) {
+  if (!marker) {
+    return false;
+  }
+  try {
+    import_node_process.default.kill(marker.pid, PROCESS_EXISTENCE_PROBE_SIGNAL);
+    return true;
+  } catch (error) {
+    return getErrorCode(error) === "EPERM";
+  }
+}
+function clearAppiumServerMarker(port) {
+  try {
+    (0, import_node_fs.rmSync)(getMarkerFilePath(port), { force: true });
+  } catch (error) {
+    (0, import_log.log)(`[appium-server-marker] Could not remove the marker for port ${String(port)}: ${getErrorMessage(error)}`);
+  }
+}
+function readAppiumServerMarker(port) {
+  let parsed;
+  try {
+    parsed = JSON.parse((0, import_node_fs.readFileSync)(getMarkerFilePath(port), "utf-8"));
+  } catch {
+    return void 0;
+  }
+  return parseMarker(parsed, port);
+}
+function writeAppiumServerMarker(params) {
+  const marker = {
+    pid: params.pid,
+    port: params.port,
+    startedAtInMilliseconds: Date.now()
+  };
+  try {
+    (0, import_node_fs.mkdirSync)(getMarkerDirectory(), { recursive: true });
+    (0, import_node_fs.writeFileSync)(getMarkerFilePath(params.port), JSON.stringify(marker));
+  } catch (error) {
+    (0, import_log.log)(`[appium-server-marker] Could not record the server on port ${String(params.port)}: ${getErrorMessage(error)}`);
+  }
+}
+function getErrorCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function getErrorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function getMarkerDirectory() {
+  return (0, import_node_path.join)((0, import_node_os.tmpdir)(), MARKER_DIR_NAME);
+}
+function getMarkerFilePath(port) {
+  return (0, import_node_path.join)(getMarkerDirectory(), `${String(port)}${MARKER_FILE_SUFFIX}`);
+}
+function parseMarker(parsed, port) {
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const record = parsed;
+  const { pid, port: markedPort, startedAtInMilliseconds } = record;
+  if (typeof pid !== "number" || typeof startedAtInMilliseconds !== "number" || markedPort !== port) {
+    return void 0;
+  }
+  return { pid, port, startedAtInMilliseconds };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  checkIsHarnessOwnedAppiumServer,
+  clearAppiumServerMarker,
+  readAppiumServerMarker,
+  writeAppiumServerMarker
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/appium-server-marker.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Records which Appium server on a port this harness started, so a later run\n * that finds a server already listening can tell **provenance**: one of our own\n * servers left over from an earlier run, or a foreign one the user manages.\n *\n * The preflight adopts any server that answers `/status`, and adoption is the\n * right default \u2014 starting a second server on an occupied port cannot work. But\n * adopting silently means a wedged leftover (see `wedged-appium-server.ts`) is\n * indistinguishable from a healthy server, and the harness has no basis on which\n * to decide whether restarting it is its call to make. The marker supplies that\n * basis: a server we started may be restarted, a foreign one is only ever\n * reported.\n *\n * The marker is a small JSON sentinel next to the setup lock (`setup-lock.ts`),\n * keyed by port, and is deliberately tolerant \u2014 a missing, unreadable, or\n * mismatched marker simply reads as \"not ours\".\n */\n\nimport {\n  mkdirSync,\n  readFileSync,\n  rmSync,\n  writeFileSync\n} from 'node:fs';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport process from 'node:process';\n\nimport { log } from './log.cjs';\n\nconst MARKER_DIR_NAME = 'obsidian-integration-testing';\nconst MARKER_FILE_SUFFIX = '.appium-server.json';\nconst PROCESS_EXISTENCE_PROBE_SIGNAL = 0;\n\n/**\n * Identifies the Appium server this harness started on a port.\n */\nexport interface AppiumServerMarker {\n  /**\n  PID of the spawned server process (the shell wrapper that owns the server's process tree).\n   */\n  readonly pid: number;\n\n  /**\n  The port the server was started on.\n   */\n  readonly port: number;\n\n  /**\n  When the server was started (`Date.now()` epoch milliseconds).\n   */\n  readonly startedAtInMilliseconds: number;\n}\n\n/**\n * Parameters for {@link writeAppiumServerMarker}.\n */\nexport interface WriteAppiumServerMarkerParams {\n  /**\n  PID of the spawned server process.\n   */\n  readonly pid: number;\n\n  /**\n  The port the server was started on.\n   */\n  readonly port: number;\n}\n\n/**\n * Checks whether the marked server is still running, which is what makes an\n * adopted server ours to restart.\n *\n * A dead PID means the marker outlived its server, so whatever answers on that\n * port now is somebody else's \u2014 the marker proves nothing about it.\n *\n * @param marker - The marker read for the port, or `undefined` when there is none.\n * @returns `true` when an earlier run of this harness started the server now listening.\n */\nexport function checkIsHarnessOwnedAppiumServer(marker: AppiumServerMarker | undefined): boolean {\n  if (!marker) {\n    return false;\n  }\n\n  try {\n    process.kill(marker.pid, PROCESS_EXISTENCE_PROBE_SIGNAL);\n    return true;\n  } catch (error: unknown) {\n    // `EPERM` means the process exists but is owned by another user \u2014 still alive.\n    return getErrorCode(error) === 'EPERM';\n  }\n}\n\n/**\n * Removes the marker for a port. Called once the marked server has been stopped,\n * so a later run does not mistake a recycled PID for our server.\n *\n * @param port - The Appium server port.\n */\nexport function clearAppiumServerMarker(port: number): void {\n  try {\n    rmSync(getMarkerFilePath(port), { force: true });\n  } catch (error: unknown) {\n    log(`[appium-server-marker] Could not remove the marker for port ${String(port)}: ${getErrorMessage(error)}`);\n  }\n}\n\n/**\n * Reads the marker for a port.\n *\n * @param port - The Appium server port.\n * @returns The marker, or `undefined` when there is none, it is unreadable, or it does not describe this port.\n */\nexport function readAppiumServerMarker(port: number): AppiumServerMarker | undefined {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(readFileSync(getMarkerFilePath(port), 'utf-8'));\n  } catch {\n    return undefined;\n  }\n\n  return parseMarker(parsed, port);\n}\n\n/**\n * Records the server this run just started, stamping it with the current time so\n * a later run can report how long it has been up.\n *\n * @param params - The started server's PID and port.\n */\nexport function writeAppiumServerMarker(params: WriteAppiumServerMarkerParams): void {\n  const marker: AppiumServerMarker = {\n    pid: params.pid,\n    port: params.port,\n    startedAtInMilliseconds: Date.now()\n  };\n\n  try {\n    mkdirSync(getMarkerDirectory(), { recursive: true });\n    writeFileSync(getMarkerFilePath(params.port), JSON.stringify(marker));\n  } catch (error: unknown) {\n    log(`[appium-server-marker] Could not record the server on port ${String(params.port)}: ${getErrorMessage(error)}`);\n  }\n}\n\nfunction getErrorCode(error: unknown): string | undefined {\n  return typeof error === 'object' && error !== null && 'code' in error ? String(error.code) : undefined;\n}\n\nfunction getErrorMessage(error: unknown): string {\n  return error instanceof Error ? error.message : String(error);\n}\n\nfunction getMarkerDirectory(): string {\n  return join(tmpdir(), MARKER_DIR_NAME);\n}\n\nfunction getMarkerFilePath(port: number): string {\n  return join(getMarkerDirectory(), `${String(port)}${MARKER_FILE_SUFFIX}`);\n}\n\nfunction parseMarker(parsed: unknown, port: number): AppiumServerMarker | undefined {\n  if (typeof parsed !== 'object' || parsed === null) {\n    return undefined;\n  }\n\n  const record = parsed as Record<string, unknown>;\n  const { pid, port: markedPort, startedAtInMilliseconds } = record;\n\n  if (typeof pid !== 'number' || typeof startedAtInMilliseconds !== 'number' || markedPort !== port) {\n    return undefined;\n  }\n\n  return { pid, port, startedAtInMilliseconds };\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAoBA,qBAKO;AACP,qBAAuB;AACvB,uBAAqB;AACrB,0BAAoB;AAEpB,iBAAoB;AAEpB,MAAM,kBAAkB;AACxB,MAAM,qBAAqB;AAC3B,MAAM,iCAAiC;AA+ChC,SAAS,gCAAgC,QAAiD;AAC/F,MAAI,CAAC,QAAQ;AACX,WAAO;AAAA,EACT;AAEA,MAAI;AACF,wBAAAA,QAAQ,KAAK,OAAO,KAAK,8BAA8B;AACvD,WAAO;AAAA,EACT,SAAS,OAAgB;AAEvB,WAAO,aAAa,KAAK,MAAM;AAAA,EACjC;AACF;AAQO,SAAS,wBAAwB,MAAoB;AAC1D,MAAI;AACF,+BAAO,kBAAkB,IAAI,GAAG,EAAE,OAAO,KAAK,CAAC;AAAA,EACjD,SAAS,OAAgB;AACvB,wBAAI,+DAA+D,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EAC9G;AACF;AAQO,SAAS,uBAAuB,MAA8C;AACnF,MAAI;AACJ,MAAI;AACF,aAAS,KAAK,UAAM,6BAAa,kBAAkB,IAAI,GAAG,OAAO,CAAC;AAAA,EACpE,QAAQ;AACN,WAAO;AAAA,EACT;AAEA,SAAO,YAAY,QAAQ,IAAI;AACjC;AAQO,SAAS,wBAAwB,QAA6C;AACnF,QAAM,SAA6B;AAAA,IACjC,KAAK,OAAO;AAAA,IACZ,MAAM,OAAO;AAAA,IACb,yBAAyB,KAAK,IAAI;AAAA,EACpC;AAEA,MAAI;AACF,kCAAU,mBAAmB,GAAG,EAAE,WAAW,KAAK,CAAC;AACnD,sCAAc,kBAAkB,OAAO,IAAI,GAAG,KAAK,UAAU,MAAM,CAAC;AAAA,EACtE,SAAS,OAAgB;AACvB,wBAAI,8DAA8D,OAAO,OAAO,IAAI,CAAC,KAAK,gBAAgB,KAAK,CAAC,EAAE;AAAA,EACpH;AACF;AAEA,SAAS,aAAa,OAAoC;AACxD,SAAO,OAAO,UAAU,YAAY,UAAU,QAAQ,UAAU,QAAQ,OAAO,MAAM,IAAI,IAAI;AAC/F;AAEA,SAAS,gBAAgB,OAAwB;AAC/C,SAAO,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK;AAC9D;AAEA,SAAS,qBAA6B;AACpC,aAAO,2BAAK,uBAAO,GAAG,eAAe;AACvC;AAEA,SAAS,kBAAkB,MAAsB;AAC/C,aAAO,uBAAK,mBAAmB,GAAG,GAAG,OAAO,IAAI,CAAC,GAAG,kBAAkB,EAAE;AAC1E;AAEA,SAAS,YAAY,QAAiB,MAA8C;AAClF,MAAI,OAAO,WAAW,YAAY,WAAW,MAAM;AACjD,WAAO;AAAA,EACT;AAEA,QAAM,SAAS;AACf,QAAM,EAAE,KAAK,MAAM,YAAY,wBAAwB,IAAI;AAE3D,MAAI,OAAO,QAAQ,YAAY,OAAO,4BAA4B,YAAY,eAAe,MAAM;AACjG,WAAO;AAAA,EACT;AAEA,SAAO,EAAE,KAAK,MAAM,wBAAwB;AAC9C;",
  "names": ["process"]
}


package/dist/lib/cjs/appium-server-marker.d.cts

@@ -0,0 +1,81 @@
+/**
+ * @file
+ *
+ * Records which Appium server on a port this harness started, so a later run
+ * that finds a server already listening can tell **provenance**: one of our own
+ * servers left over from an earlier run, or a foreign one the user manages.
+ *
+ * The preflight adopts any server that answers `/status`, and adoption is the
+ * right default — starting a second server on an occupied port cannot work. But
+ * adopting silently means a wedged leftover (see `wedged-appium-server.ts`) is
+ * indistinguishable from a healthy server, and the harness has no basis on which
+ * to decide whether restarting it is its call to make. The marker supplies that
+ * basis: a server we started may be restarted, a foreign one is only ever
+ * reported.
+ *
+ * The marker is a small JSON sentinel next to the setup lock (`setup-lock.ts`),
+ * keyed by port, and is deliberately tolerant — a missing, unreadable, or
+ * mismatched marker simply reads as "not ours".
+ */
+/**
+ * Identifies the Appium server this harness started on a port.
+ */
+export interface AppiumServerMarker {
+    /**
+    PID of the spawned server process (the shell wrapper that owns the server's process tree).
+     */
+    readonly pid: number;
+    /**
+    The port the server was started on.
+     */
+    readonly port: number;
+    /**
+    When the server was started (`Date.now()` epoch milliseconds).
+     */
+    readonly startedAtInMilliseconds: number;
+}
+/**
+ * Parameters for {@link writeAppiumServerMarker}.
+ */
+export interface WriteAppiumServerMarkerParams {
+    /**
+    PID of the spawned server process.
+     */
+    readonly pid: number;
+    /**
+    The port the server was started on.
+     */
+    readonly port: number;
+}
+/**
+ * Checks whether the marked server is still running, which is what makes an
+ * adopted server ours to restart.
+ *
+ * A dead PID means the marker outlived its server, so whatever answers on that
+ * port now is somebody else's — the marker proves nothing about it.
+ *
+ * @param marker - The marker read for the port, or `undefined` when there is none.
+ * @returns `true` when an earlier run of this harness started the server now listening.
+ */
+export declare function checkIsHarnessOwnedAppiumServer(marker: AppiumServerMarker | undefined): boolean;
+/**
+ * Removes the marker for a port. Called once the marked server has been stopped,
+ * so a later run does not mistake a recycled PID for our server.
+ *
+ * @param port - The Appium server port.
+ */
+export declare function clearAppiumServerMarker(port: number): void;
+/**
+ * Reads the marker for a port.
+ *
+ * @param port - The Appium server port.
+ * @returns The marker, or `undefined` when there is none, it is unreadable, or it does not describe this port.
+ */
+export declare function readAppiumServerMarker(port: number): AppiumServerMarker | undefined;
+/**
+ * Records the server this run just started, stamping it with the current time so
+ * a later run can report how long it has been up.
+ *
+ * @param params - The started server's PID and port.
+ */
+export declare function writeAppiumServerMarker(params: WriteAppiumServerMarkerParams): void;

package/dist/lib/cjs/cli.cjs

@@ -31,10 +31,113 @@ __export(cli_exports, {
   main: () => main
 });
 module.exports = __toCommonJS(cli_exports);
+var import_node_fs = require("node:fs");
+var import_node_path = require("node:path");
 var import_node_process = __toESM(require("node:process"), 1);
 var import_node_util = require("node:util");
 var import_connect_to_cdp = require("./connect-to-cdp.cjs");
+var import_demo_vault_bootstrap = require("./demo-vault-bootstrap.cjs");
+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] = import_node_process.default.argv;
+  if (firstArgument !== void 0 && HELP_FLAGS.has(firstArgument)) {
+    import_node_process.default.stdout.write(USAGE);
+    return;
+  }
+  if (firstArgument === BOOTSTRAP_DEMO_VAULT_COMMAND) {
+    await runBootstrapDemoVaultCommand(import_node_process.default.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 = (0, import_node_path.join)(demoVaultPath, ".obsidian", "plugins");
+  if (!(0, import_node_fs.existsSync)(pluginsDirectory)) {
+    return [];
+  }
+  return (0, import_node_fs.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 } = (0, import_node_util.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 = (0, import_node_path.resolve)(values["demo-vault"] ?? (0, import_node_path.join)(import_node_process.default.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 (0, import_demo_vault_bootstrap.bootstrapDemoVaultPlugins)({
+    demoVaultPath,
+    injectPlugins,
+    shouldForce: values.force === true
+  });
+  for (const info of result.installed) {
+    import_node_process.default.stdout.write(`Installed ${info.pluginId} from ${info.repo}@${info.version ?? "latest"}: ${info.assetNames.join(", ")}
+`);
+  }
+  if (result.skippedPluginIds.length > 0) {
+    import_node_process.default.stdout.write(`Already installed (use --force to re-download): ${result.skippedPluginIds.join(", ")}
+`);
+  }
+  if (result.installed.length === 0) {
+    import_node_process.default.stdout.write("Nothing to install.\n");
+  }
+}
+async function runConnectCommand() {
   const { values } = (0, import_node_util.parseArgs)({
     options: {
       "command-timeout": { type: "string" },
@@ -60,24 +163,6 @@ Press Ctrl+C to stop.
   import_node_process.default.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) => {
@@ -113,4 +198,4 @@ function waitForShutdownOrInstanceClose(cdpUrl) {
 0 && (module.exports = {
   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.cjs';\n\nimport { connectToCdp } from './connect-to-cdp.cjs';\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": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAWA,0BAAoB;AACpB,uBAA0B;AAI1B,4BAA6B;AAsB7B,eAAsB,OAAsB;AAC1C,QAAM,EAAE,OAAO,QAAI,4BAAU;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,UAAM,oCAAa,aAAa,MAAM,CAAC;AAE1D,sBAAAA,QAAQ,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,sBAAAA,QAAQ,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,wBAAAA,QAAQ,KAAK,UAAU,MAAM;AAC7B,wBAAAA,QAAQ,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": ["process"]
}

+//# 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.cjs';\nimport type { InjectPluginParams } from './demo-vault-populate.cjs';\n\nimport { connectToCdp } from './connect-to-cdp.cjs';\nimport { bootstrapDemoVaultPlugins } from './demo-vault-bootstrap.cjs';\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": ["process", "resolvePath"]
}


package/dist/lib/cjs/cli.d.cts

@@ -1,16 +1,24 @@
 /**
  * @file
  *
- * Thin CLI over {@link connectToCdp}: launches (or attaches to) a CDP-enabled
- * Obsidian instance with the runtime helper namespace bootstrapped, prints the
- * chosen CDP port/URL, and stays alive until interrupted so an external tool
- * (raw CDP `ws`, DevTools, …) can attach.
+ * The package's CLI. Two commands:
+ *
+ * - The **default** (no subcommand) — a thin CLI over {@link connectToCdp}: launches
+ *   (or attaches to) a CDP-enabled Obsidian instance with the runtime helper
+ *   namespace bootstrapped, prints the chosen CDP port/URL, and stays alive until
+ *   interrupted so an external tool (raw CDP `ws`, DevTools, …) can attach.
+ * - **`bootstrap-demo-vault`** — installs a demo vault's injected community plugins
+ *   headlessly (see `demo-vault-bootstrap.ts`). This is the copy-pasteable remedy
+ *   `buildDemoVaultPopulate`'s throw names, replacing the GUI-only "open
+ *   `demo-vault/` in Obsidian once" step that a fresh clone or CI cannot perform.
+ *
+ * Anything that is not a recognized subcommand falls through to the default
+ * command, so `obsidian-integration-testing --vault …` keeps working unchanged.
  */
 /**
- * Parses CLI arguments, opens the connection, prints its endpoint, and blocks
- * until `SIGINT`/`SIGTERM` or the owned Obsidian window is closed, disposing the
- * connection on shutdown.
+ * Dispatches to the requested subcommand, falling through to the default CDP
+ * command for anything that is not one.
  *
- * @returns A {@link Promise} that resolves once the connection has been disposed.
+ * @returns A {@link Promise} that resolves once the chosen command has finished.
  */
 export declare function main(): Promise<void>;

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
+ * 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;