obsidian-integration-testing 1.0.0

package/dist/lib/cjs/integration-global-setup.cjs

@@ -0,0 +1,106 @@
+"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 integration_global_setup_exports = {};
+__export(integration_global_setup_exports, {
+  getTempVaultPath: () => getTempVaultPath,
+  setup: () => setup,
+  teardown: () => teardown
+});
+module.exports = __toCommonJS(integration_global_setup_exports);
+var import_node_fs = require("node:fs");
+var import_promises = require("node:fs/promises");
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+var import_vitest = require("vitest");
+var import_obsidian_cli = require("./obsidian-cli.cjs");
+function getTempVaultPath() {
+  return (0, import_vitest.inject)("tempVaultPath");
+}
+const DIST_DEV = "dist/dev";
+const DIST_BUILD = "dist/build";
+const MAIN_JS = "main.js";
+const OBSIDIAN_CONFIG_DIR = ".obsidian";
+const PLUGINS_DIR = "plugins";
+const COMMUNITY_PLUGINS_JSON = "community-plugins.json";
+let tempVaultPath;
+async function setup(project) {
+  const projectRoot = findProjectRoot();
+  const distPath = await resolveDistPath(projectRoot);
+  const manifestJson = JSON.parse(await (0, import_promises.readFile)((0, import_node_path.join)(distPath, "manifest.json"), "utf-8"));
+  const pluginId = manifestJson.id;
+  const mainJs = (0, import_node_path.join)(distPath, MAIN_JS);
+  const buildStat = await (0, import_promises.stat)(mainJs);
+  console.warn(`Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);
+  tempVaultPath = await (0, import_promises.mkdtemp)((0, import_node_path.join)((0, import_node_os.tmpdir)(), `${pluginId}-`));
+  const pluginDir = (0, import_node_path.join)(tempVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);
+  await (0, import_promises.mkdir)(pluginDir, { recursive: true });
+  await (0, import_promises.cp)(distPath, pluginDir, { recursive: true });
+  await (0, import_promises.writeFile)((0, import_node_path.join)(tempVaultPath, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));
+  await (0, import_obsidian_cli.evalInObsidian)({
+    args: { pluginId },
+    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.
+    fn: async ({ app, pluginId: pluginId2 }) => {
+      await app.plugins.enablePluginAndSave(pluginId2);
+    },
+    shouldSkipPreflightChecks: true,
+    vaultPath: tempVaultPath
+  });
+  project.provide("tempVaultPath", tempVaultPath);
+}
+async function teardown() {
+  await (0, import_promises.rm)(tempVaultPath, { recursive: true });
+}
+function findProjectRoot() {
+  let dir = process.cwd();
+  while (true) {
+    if ((0, import_node_fs.existsSync)((0, import_node_path.join)(dir, "package.json"))) {
+      return dir;
+    }
+    const parent = (0, import_node_path.join)(dir, "..");
+    if (parent === dir) {
+      throw new Error("Could not find project root (no package.json found).");
+    }
+    dir = parent;
+  }
+}
+async function resolveDistPath(projectRoot) {
+  const devPath = (0, import_node_path.join)(projectRoot, DIST_DEV);
+  const buildPath = (0, import_node_path.join)(projectRoot, DIST_BUILD);
+  const devMainJs = (0, import_node_path.join)(devPath, MAIN_JS);
+  const buildMainJs = (0, import_node_path.join)(buildPath, MAIN_JS);
+  const devStat = (0, import_node_fs.existsSync)(devMainJs) ? await (0, import_promises.stat)(devMainJs) : null;
+  const buildStat = (0, import_node_fs.existsSync)(buildMainJs) ? await (0, import_promises.stat)(buildMainJs) : null;
+  if (devStat && buildStat) {
+    return devStat.mtime > buildStat.mtime ? devPath : buildPath;
+  }
+  if (devStat) {
+    return devPath;
+  }
+  if (buildStat) {
+    return buildPath;
+  }
+  throw new Error("No build found. Run `npm run build` or `npm run dev` first.");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getTempVaultPath,
+  setup,
+  teardown
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/integration-global-setup.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains the global setup and teardown functions for integration tests.\n */\n\n/* v8 ignore start -- Integration-time setup covered by integration tests, not unit tests. */\n\nimport type { TestProject } from 'vitest/node';\n\nimport { existsSync } from 'node:fs';\nimport {\n  cp,\n  mkdir,\n  mkdtemp,\n  readFile,\n  rm,\n  stat,\n  writeFile\n} from 'node:fs/promises';\nimport { tmpdir } from 'node:os';\nimport { join } from 'node:path';\nimport { inject } from 'vitest';\n\nimport { evalInObsidian } from './obsidian-cli.cjs';\n\ndeclare module 'vitest' {\n  interface ProvidedContext {\n    tempVaultPath: string;\n  }\n}\n\n/**\n * Type representing the manifest file format for Obsidian plugins.\n *\n * {@link https://docs.obsidian.md/Reference/Manifest}\n */\ninterface Manifest {\n  /**\n   * The author's name.\n   */\n  author: string;\n\n  /**\n   * A URL to the author's website.\n   */\n  authorUrl?: string;\n\n  /**\n   * A description of your plugin.\n   */\n  description: string;\n\n  /**\n   * A URL or multiple URLs to where the users can support your project financially.\n   */\n  fundingUrl?: Record<string, string> | string;\n\n  /**\n   * The ID of your plugin. The ID can't contain obsidian.\n   */\n  id: string;\n\n  /**\n   * Whether your plugin uses NodeJS or Electron APIs.\n   */\n  isDesktopOnly: boolean;\n\n  /**\n   * The minimum required Obsidian version.\n   */\n  minAppVersion: string;\n\n  /**\n   * The display name.\n   */\n  name: string;\n\n  /**\n   * The version, using [Semantic Versioning](https://semver.org/) in the format `x.y.z`.\n   */\n  version: string;\n}\n\n/**\n * Returns the temporary vault path provided by the global setup.\n *\n * @returns The absolute path to the temporary vault.\n */\nexport function getTempVaultPath(): string {\n  return inject('tempVaultPath');\n}\n\nconst DIST_DEV = 'dist/dev';\nconst DIST_BUILD = 'dist/build';\nconst MAIN_JS = 'main.js';\nconst OBSIDIAN_CONFIG_DIR = '.obsidian';\nconst PLUGINS_DIR = 'plugins';\nconst COMMUNITY_PLUGINS_JSON = 'community-plugins.json';\n\nlet tempVaultPath: string;\n\n/**\n * Vitest global setup function.\n *\n * Copies the built plugin into a temporary vault, enables it via the Obsidian CLI,\n * and provides `tempVaultPath` to tests.\n *\n * @param project - The Vitest project.\n */\nexport async function setup(project: TestProject): Promise<void> {\n  const projectRoot = findProjectRoot();\n  const distPath = await resolveDistPath(projectRoot);\n  const manifestJson = JSON.parse(await readFile(join(distPath, 'manifest.json'), 'utf-8')) as Manifest;\n  const pluginId = manifestJson.id;\n\n  const mainJs = join(distPath, MAIN_JS);\n  const buildStat = await stat(mainJs);\n\n  console.warn(`Using ${distPath} (${buildStat.mtime.toISOString()}). If outdated, rebuild.`);\n\n  tempVaultPath = await mkdtemp(join(tmpdir(), `${pluginId}-`));\n  const pluginDir = join(tempVaultPath, OBSIDIAN_CONFIG_DIR, PLUGINS_DIR, pluginId);\n  await mkdir(pluginDir, { recursive: true });\n  await cp(distPath, pluginDir, { recursive: true });\n  await writeFile(join(tempVaultPath, OBSIDIAN_CONFIG_DIR, COMMUNITY_PLUGINS_JSON), JSON.stringify([pluginId]));\n\n  await evalInObsidian({\n    args: { pluginId },\n    // eslint-disable-next-line no-shadow -- No actual shadowing as the function is executed externally.\n    fn: async ({ app, pluginId }) => {\n      await app.plugins.enablePluginAndSave(pluginId);\n    },\n    shouldSkipPreflightChecks: true,\n    vaultPath: tempVaultPath\n  });\n\n  project.provide('tempVaultPath', tempVaultPath);\n}\n\n/**\n * Vitest global teardown function.\n *\n * Removes the temporary vault created during setup.\n */\nexport async function teardown(): Promise<void> {\n  await rm(tempVaultPath, { recursive: true });\n}\n\n/**\n * Finds the project root by walking up from `process.cwd()` looking for `package.json`.\n *\n * @returns The absolute path to the project root.\n */\nfunction findProjectRoot(): string {\n  let dir = process.cwd();\n\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- Loop terminates at filesystem root.\n  while (true) {\n    if (existsSync(join(dir, 'package.json'))) {\n      return dir;\n    }\n    const parent = join(dir, '..');\n    if (parent === dir) {\n      throw new Error('Could not find project root (no package.json found).');\n    }\n    dir = parent;\n  }\n}\n\n/**\n * Resolves the dist path to use for integration tests.\n *\n * Picks whichever of `dist/dev` and `dist/build` has a newer `main.js`.\n * If only one exists, that one is used. Throws if neither exists.\n *\n * @param projectRoot - The absolute path to the project root.\n * @returns The absolute path to the chosen dist folder.\n */\nasync function resolveDistPath(projectRoot: string): Promise<string> {\n  const devPath = join(projectRoot, DIST_DEV);\n  const buildPath = join(projectRoot, DIST_BUILD);\n  const devMainJs = join(devPath, MAIN_JS);\n  const buildMainJs = join(buildPath, MAIN_JS);\n  const devStat = existsSync(devMainJs) ? await stat(devMainJs) : null;\n  const buildStat = existsSync(buildMainJs) ? await stat(buildMainJs) : null;\n\n  if (devStat && buildStat) {\n    return devStat.mtime > buildStat.mtime ? devPath : buildPath;\n  }\n\n  if (devStat) {\n    return devPath;\n  }\n\n  if (buildStat) {\n    return buildPath;\n  }\n\n  throw new Error('No build found. Run `npm run build` or `npm run dev` first.');\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAUA,qBAA2B;AAC3B,sBAQO;AACP,qBAAuB;AACvB,uBAAqB;AACrB,oBAAuB;AAEvB,0BAA+B;AAiExB,SAAS,mBAA2B;AACzC,aAAO,sBAAO,eAAe;AAC/B;AAEA,MAAM,WAAW;AACjB,MAAM,aAAa;AACnB,MAAM,UAAU;AAChB,MAAM,sBAAsB;AAC5B,MAAM,cAAc;AACpB,MAAM,yBAAyB;AAE/B,IAAI;AAUJ,eAAsB,MAAM,SAAqC;AAC/D,QAAM,cAAc,gBAAgB;AACpC,QAAM,WAAW,MAAM,gBAAgB,WAAW;AAClD,QAAM,eAAe,KAAK,MAAM,UAAM,8BAAS,uBAAK,UAAU,eAAe,GAAG,OAAO,CAAC;AACxF,QAAM,WAAW,aAAa;AAE9B,QAAM,aAAS,uBAAK,UAAU,OAAO;AACrC,QAAM,YAAY,UAAM,sBAAK,MAAM;AAEnC,UAAQ,KAAK,SAAS,QAAQ,KAAK,UAAU,MAAM,YAAY,CAAC,0BAA0B;AAE1F,kBAAgB,UAAM,6BAAQ,2BAAK,uBAAO,GAAG,GAAG,QAAQ,GAAG,CAAC;AAC5D,QAAM,gBAAY,uBAAK,eAAe,qBAAqB,aAAa,QAAQ;AAChF,YAAM,uBAAM,WAAW,EAAE,WAAW,KAAK,CAAC;AAC1C,YAAM,oBAAG,UAAU,WAAW,EAAE,WAAW,KAAK,CAAC;AACjD,YAAM,+BAAU,uBAAK,eAAe,qBAAqB,sBAAsB,GAAG,KAAK,UAAU,CAAC,QAAQ,CAAC,CAAC;AAE5G,YAAM,oCAAe;AAAA,IACnB,MAAM,EAAE,SAAS;AAAA;AAAA,IAEjB,IAAI,OAAO,EAAE,KAAK,UAAAA,UAAS,MAAM;AAC/B,YAAM,IAAI,QAAQ,oBAAoBA,SAAQ;AAAA,IAChD;AAAA,IACA,2BAA2B;AAAA,IAC3B,WAAW;AAAA,EACb,CAAC;AAED,UAAQ,QAAQ,iBAAiB,aAAa;AAChD;AAOA,eAAsB,WAA0B;AAC9C,YAAM,oBAAG,eAAe,EAAE,WAAW,KAAK,CAAC;AAC7C;AAOA,SAAS,kBAA0B;AACjC,MAAI,MAAM,QAAQ,IAAI;AAGtB,SAAO,MAAM;AACX,YAAI,+BAAW,uBAAK,KAAK,cAAc,CAAC,GAAG;AACzC,aAAO;AAAA,IACT;AACA,UAAM,aAAS,uBAAK,KAAK,IAAI;AAC7B,QAAI,WAAW,KAAK;AAClB,YAAM,IAAI,MAAM,sDAAsD;AAAA,IACxE;AACA,UAAM;AAAA,EACR;AACF;AAWA,eAAe,gBAAgB,aAAsC;AACnE,QAAM,cAAU,uBAAK,aAAa,QAAQ;AAC1C,QAAM,gBAAY,uBAAK,aAAa,UAAU;AAC9C,QAAM,gBAAY,uBAAK,SAAS,OAAO;AACvC,QAAM,kBAAc,uBAAK,WAAW,OAAO;AAC3C,QAAM,cAAU,2BAAW,SAAS,IAAI,UAAM,sBAAK,SAAS,IAAI;AAChE,QAAM,gBAAY,2BAAW,WAAW,IAAI,UAAM,sBAAK,WAAW,IAAI;AAEtE,MAAI,WAAW,WAAW;AACxB,WAAO,QAAQ,QAAQ,UAAU,QAAQ,UAAU;AAAA,EACrD;AAEA,MAAI,SAAS;AACX,WAAO;AAAA,EACT;AAEA,MAAI,WAAW;AACb,WAAO;AAAA,EACT;AAEA,QAAM,IAAI,MAAM,6DAA6D;AAC/E;",
  "names": ["pluginId"]
}


package/dist/lib/cjs/integration-global-setup.d.cts

@@ -0,0 +1,32 @@
+/**
+ * @packageDocumentation
+ *
+ * Contains the global setup and teardown functions for integration tests.
+ */
+import type { TestProject } from 'vitest/node';
+declare module 'vitest' {
+    interface ProvidedContext {
+        tempVaultPath: string;
+    }
+}
+/**
+ * Returns the temporary vault path provided by the global setup.
+ *
+ * @returns The absolute path to the temporary vault.
+ */
+export declare function getTempVaultPath(): string;
+/**
+ * Vitest global setup function.
+ *
+ * Copies the built plugin into a temporary vault, enables it via the Obsidian CLI,
+ * and provides `tempVaultPath` to tests.
+ *
+ * @param project - The Vitest project.
+ */
+export declare function setup(project: TestProject): Promise<void>;
+/**
+ * Vitest global teardown function.
+ *
+ * Removes the temporary vault created during setup.
+ */
+export declare function teardown(): Promise<void>;

package/dist/lib/cjs/json-with-functions.cjs

@@ -0,0 +1,46 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var json_with_functions_exports = {};
+__export(json_with_functions_exports, {
+  jsonWithFunctions: () => jsonWithFunctions
+});
+module.exports = __toCommonJS(json_with_functions_exports);
+var import_function_expression = require("./function-expression.cjs");
+function jsonWithFunctions(value) {
+  const functionMap = /* @__PURE__ */ new Map();
+  const JSON_INDENT = 2;
+  const json = JSON.stringify(value, (_key, val) => {
+    if (typeof val === "function") {
+      const placeholder = `__fn_${String(functionMap.size)}__`;
+      functionMap.set(placeholder, (0, import_function_expression.getFunctionExpressionString)(val));
+      return placeholder;
+    }
+    return val;
+  }, JSON_INDENT);
+  let result = json;
+  for (const [placeholder, fnSource] of functionMap) {
+    result = result.replace(`"${placeholder}"`, fnSource);
+  }
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  jsonWithFunctions
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/json-with-functions.d.cts

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ *
+ * Serializes a value to JSON, preserving function bodies as raw source text.
+ */
+/**
+ * Serializes a value to JSON with function bodies included as raw source text.
+ *
+ * Standard `JSON.stringify` omits functions entirely. This helper replaces
+ * each function value with a unique placeholder during stringification,
+ * then substitutes the placeholders with the real `toString()` output.
+ *
+ * @param value - The value to serialize.
+ * @returns A JSON-like string where functions appear as their source text.
+ */
+export declare function jsonWithFunctions(value: unknown): string;

package/dist/lib/cjs/obsidian-cli.cjs

@@ -0,0 +1,191 @@
+"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 obsidian_cli_exports = {};
+__export(obsidian_cli_exports, {
+  evalInObsidian: () => evalInObsidian
+});
+module.exports = __toCommonJS(obsidian_cli_exports);
+var import_node_fs = require("node:fs");
+var import_node_process = __toESM(require("node:process"), 1);
+var import_exec = require("./exec.cjs");
+var import_function_expression = require("./function-expression.cjs");
+var import_json_with_functions = require("./json-with-functions.cjs");
+var import_obsidian_config = require("./obsidian-config.cjs");
+const NO_OUTPUT = "(no output)";
+const UNABLE_TO_FIND_OBSIDIAN = "unable to find Obsidian";
+const AUTO_START_POLL_INTERVAL_MS = 2e3;
+const AUTO_START_TIMEOUT_MS = 3e4;
+async function evalInObsidian(params) {
+  const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, vaultPath } = params;
+  const cwd = vaultPath ?? import_node_process.default.cwd();
+  if (vaultPath !== void 0 && !(0, import_node_fs.existsSync)(vaultPath)) {
+    throw new Error(`Vault path does not exist: ${vaultPath}`);
+  }
+  if (!shouldSkipPreflightChecks) {
+    if (!(0, import_obsidian_config.isVaultRegistered)(cwd)) {
+      throw new Error(
+        `Vault is not registered in Obsidian: ${cwd}. Register the vault first with registerVault() or TempVault.register().`
+      );
+    }
+    if (!(0, import_obsidian_config.isCliEnabled)()) {
+      throw new Error("Obsidian CLI is disabled. Enable it in Obsidian Settings \u2192 General \u2192 CLI.");
+    }
+    await assertObsidianCliAvailable();
+  }
+  const SLICE_START = 2;
+  const randomSuffix = String(Math.random()).slice(SLICE_START);
+  const contextExpr = contextId ? `((window.__obsidianContexts__ ??= {})["${String(contextId)}"] ??= {})` : "{}";
+  const expression = `
+(async () => {
+  const fn${randomSuffix} = ${(0, import_function_expression.getFunctionExpressionString)(fn)};
+  const obsidianModule${randomSuffix} = await (async () => {
+    if (!app.workspace.app.workspace.layoutReady) {
+      await new Promise((resolve) => app.workspace.onLayoutReady(resolve));
+    }
+    if (!app.plugins.isEnabled()) {
+      await app.plugins.setEnable(true);
+    }
+    ${(0, import_function_expression.getFunctionExpressionString)(getObsidianModulePluginFn)}
+    ${(0, import_function_expression.getFunctionExpressionString)(getObsidianModule)}
+    return await getObsidianModule();
+  })();
+  const args${randomSuffix} = ${(0, import_json_with_functions.jsonWithFunctions)(args)};
+  const context${randomSuffix} = ${contextExpr};
+  const fullArgs${randomSuffix} = Object.assign(args${randomSuffix}, { app, obsidianModule: obsidianModule${randomSuffix}, context: context${randomSuffix} });
+  return JSON.stringify(await fn${randomSuffix}(fullArgs${randomSuffix}));
+})()`;
+  const command = ["obsidian", "eval", `code=${expression}`];
+  let resultStr;
+  try {
+    resultStr = await (0, import_exec.exec)(command, { cwd, isQuiet: true });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    if (message.includes(UNABLE_TO_FIND_OBSIDIAN)) {
+      resultStr = await ensureObsidianRunning({ command, cwd });
+    } else {
+      throw error;
+    }
+  }
+  if (resultStr === "" || resultStr === "Vault not found.") {
+    throw new Error(`Unexpected empty response from Obsidian CLI for path: ${cwd}`);
+  }
+  const resultJson = resultStr.startsWith("=> ") ? resultStr.slice("=> ".length) : resultStr;
+  if (resultJson === NO_OUTPUT) {
+    return void 0;
+  }
+  try {
+    return JSON.parse(resultJson);
+  } catch {
+    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);
+  }
+}
+async function assertObsidianCliAvailable() {
+  const command = import_node_process.default.platform === "win32" ? "where.exe obsidian.com" : "which obsidian";
+  try {
+    await (0, import_exec.exec)(command, { isQuiet: true });
+  } catch {
+    throw new Error("Obsidian CLI is not available. Ensure Obsidian is installed and its CLI is in your PATH.");
+  }
+}
+async function ensureObsidianRunning(params) {
+  console.warn("Obsidian is not running. Starting Obsidian...");
+  const vaultId = (0, import_obsidian_config.getVaultId)(params.cwd);
+  const uri = vaultId ? `obsidian://open?vault=${vaultId}` : "obsidian://open";
+  try {
+    await (0, import_exec.exec)(getOpenUriCommand(uri), { isQuiet: true });
+  } catch {
+  }
+  const deadline = Date.now() + AUTO_START_TIMEOUT_MS;
+  while (Date.now() < deadline) {
+    await new Promise((r) => {
+      setTimeout(r, AUTO_START_POLL_INTERVAL_MS);
+    });
+    try {
+      return await (0, import_exec.exec)(params.command, { cwd: params.cwd, isQuiet: true });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      if (!message.includes(UNABLE_TO_FIND_OBSIDIAN)) {
+        throw error;
+      }
+    }
+  }
+  throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_MS)}ms.`);
+}
+async function getObsidianModule() {
+  const app = window.app;
+  const obsidianModuleHolder = app;
+  if (obsidianModuleHolder.obsidianModule) {
+    return obsidianModuleHolder.obsidianModule;
+  }
+  const SLICE_START = 2;
+  const randomSuffix = String(Math.random()).slice(SLICE_START);
+  const tempModuleName = `get-obsidian-module-${randomSuffix}`;
+  const dir = `${app.vault.configDir}/plugins/${tempModuleName}`;
+  app.plugins.manifests[tempModuleName] = {
+    author: "",
+    description: "",
+    dir,
+    id: tempModuleName,
+    isDesktopOnly: true,
+    minAppVersion: "",
+    name: tempModuleName,
+    version: ""
+  };
+  await app.vault.adapter.mkdir(dir);
+  await app.vault.adapter.write(`${dir}/main.js`, `(${String(getObsidianModulePluginFn)})();`);
+  await app.plugins.loadPlugin(tempModuleName);
+  await app.plugins.uninstallPlugin(tempModuleName);
+  if (obsidianModuleHolder.obsidianModule) {
+    return obsidianModuleHolder.obsidianModule;
+  }
+  throw new Error("Failed to load obsidian module");
+}
+function getObsidianModulePluginFn() {
+  const app = window.app;
+  const obsidianModuleHolder = app;
+  const pluginRequire = require;
+  const pluginExports = exports;
+  const obsidianModule = pluginRequire("obsidian");
+  obsidianModuleHolder.obsidianModule = obsidianModule;
+  pluginExports.default = obsidianModule.Plugin;
+}
+function getOpenUriCommand(uri) {
+  if (import_node_process.default.platform === "win32") {
+    return `start "" "${uri}"`;
+  }
+  if (import_node_process.default.platform === "darwin") {
+    return `open "${uri}"`;
+  }
+  return `xdg-open "${uri}"`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  evalInObsidian
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-cli.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Evaluates a function inside a running Obsidian instance via the Obsidian CLI.\n */\n\nimport type { App } from 'obsidian';\n// eslint-disable-next-line import-x/no-namespace -- We need to reference `obsidian` module.\nimport type * as obsidian from 'obsidian';\nimport type { Promisable } from 'type-fest';\n\nimport { existsSync } from 'node:fs';\nimport process from 'node:process';\n\nimport type {\n  ContextArgs,\n  ContextId\n} from './context-id.cjs';\n\nimport { exec } from './exec.cjs';\nimport { getFunctionExpressionString } from './function-expression.cjs';\nimport { jsonWithFunctions } from './json-with-functions.cjs';\nimport {\n  getVaultId,\n  isCliEnabled,\n  isVaultRegistered\n} from './obsidian-config.cjs';\n\nconst NO_OUTPUT = '(no output)';\nconst UNABLE_TO_FIND_OBSIDIAN = 'unable to find Obsidian';\nconst AUTO_START_POLL_INTERVAL_MS = 2000;\nconst AUTO_START_TIMEOUT_MS = 30000;\n\n/**\n * Common arguments automatically provided to every {@link evalInObsidian} callback.\n */\nexport interface CommonArgs {\n  /**\n   * The Obsidian {@link App} instance.\n   */\n  app: App;\n\n  /**\n   * The `obsidian` module, resolved at runtime inside the Obsidian process.\n   */\n  obsidianModule: typeof obsidian;\n}\n\n/**\n * Parameters for {@link evalInObsidian}.\n */\nexport interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {\n  /**\n   * Additional arguments to pass to the function. Values may include functions \u2014\n   * they are serialized via `toString()`.\n   */\n  args?: Args;\n\n  /**\n   * A {@link ContextId} linking this call to a persistent store on `window`\n   * in the Obsidian process. The callback receives a typed `context` object\n   * that survives across calls sharing the same ID.\n   *\n   * When omitted, `context` is a fresh empty object each call.\n   */\n  contextId?: TContextId;\n\n  /**\n   * The function to evaluate in the Obsidian context.\n   */\n  fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;\n\n  /**\n   * Skips pre-flight checks (vault registration, CLI availability).\n   * Used internally by vault registration functions.\n   *\n   * @internal\n   */\n  shouldSkipPreflightChecks?: boolean;\n\n  /**\n   * The path to the Obsidian vault. Defaults to `process.cwd()`.\n   */\n  vaultPath?: string;\n}\n\n/**\n * A plain object with string keys.\n */\nexport type GenericObject = Record<string, unknown>;\n\n/**\n * Evaluates a function inside the running Obsidian instance\n * via the Obsidian CLI and returns the parsed result.\n *\n * The function receives an args object that includes `app`, `obsidianModule`,\n * `context`, and any additional `args` passed by the caller.\n * It is serialized via `toString()` and invoked as an IIFE.\n * The function must be self-contained \u2014 closures over local variables will not work.\n * Pass any needed values as `args` \u2014 they are JSON-serialized and deserialized on the Obsidian side.\n *\n * The result is `JSON.stringify`'d on the Obsidian side and parsed back.\n *\n * @param params - The parameters for the function to evaluate.\n * @returns A {@link Promise} that resolves to the return value of `fn`.\n */\nexport async function evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: EvalInObsidianParams<Args, Result, TContextId>\n): Promise<Result> {\n  // eslint-disable-next-line @typescript-eslint/unbound-method -- `fn` can be unbound.\n  const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, vaultPath } = params;\n  const cwd = vaultPath ?? process.cwd();\n\n  // Check 1: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  if (!shouldSkipPreflightChecks) {\n    // Check 2: Vault is registered in Obsidian.\n    if (!isVaultRegistered(cwd)) {\n      throw new Error(\n        `Vault is not registered in Obsidian: ${cwd}. Register the vault first with registerVault() or TempVault.register().`\n      );\n    }\n\n    // Check 3: CLI is enabled in Obsidian settings.\n    if (!isCliEnabled()) {\n      throw new Error('Obsidian CLI is disabled. Enable it in Obsidian Settings \\u2192 General \\u2192 CLI.');\n    }\n\n    // Check 4: Obsidian CLI binary is in PATH.\n    await assertObsidianCliAvailable();\n  }\n\n  const SLICE_START = 2;\n  const randomSuffix = String(Math.random()).slice(SLICE_START);\n  const contextExpr = contextId\n    ? `((window.__obsidianContexts__ ??= {})[\"${String(contextId)}\"] ??= {})`\n    : '{}';\n  const expression = `\n(async () => {\n  const fn${randomSuffix} = ${getFunctionExpressionString(fn)};\n  const obsidianModule${randomSuffix} = await (async () => {\n    if (!app.workspace.app.workspace.layoutReady) {\n      await new Promise((resolve) => app.workspace.onLayoutReady(resolve));\n    }\n    if (!app.plugins.isEnabled()) {\n      await app.plugins.setEnable(true);\n    }\n    ${getFunctionExpressionString(getObsidianModulePluginFn)}\n    ${getFunctionExpressionString(getObsidianModule)}\n    return await getObsidianModule();\n  })();\n  const args${randomSuffix} = ${jsonWithFunctions(args)};\n  const context${randomSuffix} = ${contextExpr};\n  const fullArgs${randomSuffix} = Object.assign(args${randomSuffix}, { app, obsidianModule: obsidianModule${randomSuffix}, context: context${randomSuffix} });\n  return JSON.stringify(await fn${randomSuffix}(fullArgs${randomSuffix}));\n})()`;\n\n  const command = ['obsidian', 'eval', `code=${expression}`];\n\n  let resultStr: string;\n  try {\n    resultStr = await exec(command, { cwd, isQuiet: true });\n  } catch (error) {\n    const message = error instanceof Error ? error.message : String(error);\n    if (message.includes(UNABLE_TO_FIND_OBSIDIAN)) {\n      // Check 5: Obsidian is not running \u2014 auto-start it.\n      resultStr = await ensureObsidianRunning({ command, cwd });\n    } else {\n      throw error;\n    }\n  }\n\n  if (resultStr === '' || resultStr === 'Vault not found.') {\n    throw new Error(`Unexpected empty response from Obsidian CLI for path: ${cwd}`);\n  }\n\n  const resultJson = resultStr.startsWith('=> ') ? resultStr.slice('=> '.length) : resultStr;\n  if (resultJson === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  try {\n    return JSON.parse(resultJson) as Result;\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);\n  }\n}\n\n/**\n * Checks whether the Obsidian CLI binary is available in the system PATH.\n *\n * @throws If the CLI binary is not found.\n */\nasync function assertObsidianCliAvailable(): Promise<void> {\n  const command = process.platform === 'win32' ? 'where.exe obsidian.com' : 'which obsidian';\n  try {\n    await exec(command, { isQuiet: true });\n  } catch {\n    throw new Error('Obsidian CLI is not available. Ensure Obsidian is installed and its CLI is in your PATH.');\n  }\n}\n\n/**\n * Launches Obsidian via the `obsidian://` URI protocol and retries the eval\n * until Obsidian becomes available.\n *\n * @param params - The exec parameters for the eval command.\n * @param params.command - The CLI command array to retry.\n * @param params.cwd - The working directory for the eval command.\n * @returns The result string from the successful eval.\n */\nasync function ensureObsidianRunning(params: { command: string[]; cwd: string }): Promise<string> {\n  console.warn('Obsidian is not running. Starting Obsidian...');\n\n  const vaultId = getVaultId(params.cwd);\n  const uri = vaultId ? `obsidian://open?vault=${vaultId}` : 'obsidian://open';\n\n  try {\n    await exec(getOpenUriCommand(uri), { isQuiet: true });\n  } catch {\n    // The open command may fail on some systems \u2014 we'll still try polling.\n  }\n\n  const deadline = Date.now() + AUTO_START_TIMEOUT_MS;\n  while (Date.now() < deadline) {\n    await new Promise((r) => {\n      setTimeout(r, AUTO_START_POLL_INTERVAL_MS);\n    });\n    try {\n      return await exec(params.command, { cwd: params.cwd, isQuiet: true });\n    } catch (error) {\n      const message = error instanceof Error ? error.message : String(error);\n      if (!message.includes(UNABLE_TO_FIND_OBSIDIAN)) {\n        throw error;\n      }\n    }\n  }\n\n  throw new Error(`Obsidian did not start within ${String(AUTO_START_TIMEOUT_MS)}ms.`);\n}\n\n/* v8 ignore start -- Serialized via toString() and executed inside the Obsidian process, not in Node. Covered by integration tests. */\n\n/**\n * Injected into the Obsidian process to resolve the `obsidian` module.\n * Uses a cached value on `app` if available, otherwise installs a temporary\n * plugin that calls `require('obsidian')` and caches the result.\n *\n * Must NOT reference any outer scope \u2014 it is serialized via `toString()`.\n * `getObsidianModulePluginFn` must be defined in the same scope\n * (the generated IIFE handles this).\n *\n * @returns The `obsidian` module.\n */\nasync function getObsidianModule(): Promise<typeof obsidian> {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- We need global `app` variable.\n  const app = window.app;\n  interface ObsidianModuleHolder {\n    obsidianModule: typeof obsidian;\n  }\n  const obsidianModuleHolder = app as Partial<ObsidianModuleHolder>;\n  if (obsidianModuleHolder.obsidianModule) {\n    return obsidianModuleHolder.obsidianModule;\n  }\n  const SLICE_START = 2;\n  const randomSuffix = String(Math.random()).slice(SLICE_START);\n  const tempModuleName = `get-obsidian-module-${randomSuffix}`;\n  const dir = `${app.vault.configDir}/plugins/${tempModuleName}`;\n  app.plugins.manifests[tempModuleName] = {\n    author: '',\n    description: '',\n    dir,\n    id: tempModuleName,\n    isDesktopOnly: true,\n    minAppVersion: '',\n    name: tempModuleName,\n    version: ''\n  };\n  await app.vault.adapter.mkdir(dir);\n  await app.vault.adapter.write(`${dir}/main.js`, `(${String(getObsidianModulePluginFn)})();`);\n  await app.plugins.loadPlugin(tempModuleName);\n  await app.plugins.uninstallPlugin(tempModuleName);\n  // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition -- It will be initialized within `loadPlugin`.\n  if (obsidianModuleHolder.obsidianModule) {\n    return obsidianModuleHolder.obsidianModule;\n  }\n  throw new Error('Failed to load obsidian module');\n}\n\n/**\n * The body of the temporary plugin that extracts the `obsidian` module.\n * Serialized via `toString()` and written to `main.js` by {@link getObsidianModule}.\n * Must NOT reference any outer scope.\n */\nfunction getObsidianModulePluginFn(): void {\n  // eslint-disable-next-line @typescript-eslint/no-deprecated -- We need global `app` variable.\n  const app = window.app;\n  interface ObsidianModuleHolder {\n    obsidianModule: typeof obsidian;\n  }\n  const obsidianModuleHolder = app as Partial<ObsidianModuleHolder>;\n\n  const pluginRequire = require;\n  const pluginExports = exports as {\n    default: unknown;\n  };\n\n  const obsidianModule = pluginRequire('obsidian') as typeof obsidian;\n  obsidianModuleHolder.obsidianModule = obsidianModule;\n  pluginExports.default = obsidianModule.Plugin;\n}\n\n/* v8 ignore stop */\n\n/**\n * Returns the platform-specific command to open a URI.\n *\n * @param uri - The URI to open.\n * @returns The shell command string.\n */\nfunction getOpenUriCommand(uri: string): string {\n  if (process.platform === 'win32') {\n    return `start \"\" \"${uri}\"`;\n  }\n\n  if (process.platform === 'darwin') {\n    return `open \"${uri}\"`;\n  }\n\n  return `xdg-open \"${uri}\"`;\n}\n"],
  "mappings": "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",
  "names": ["process"]
}


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

@@ -0,0 +1,75 @@
+/**
+ * @packageDocumentation
+ *
+ * Evaluates a function inside a running Obsidian instance via the Obsidian CLI.
+ */
+import type { App } from 'obsidian';
+import type * as obsidian from 'obsidian';
+import type { Promisable } from 'type-fest';
+import type { ContextArgs, ContextId } from './context-id.cjs';
+/**
+ * Common arguments automatically provided to every {@link evalInObsidian} callback.
+ */
+export interface CommonArgs {
+    /**
+     * The Obsidian {@link App} instance.
+     */
+    app: App;
+    /**
+     * The `obsidian` module, resolved at runtime inside the Obsidian process.
+     */
+    obsidianModule: typeof obsidian;
+}
+/**
+ * Parameters for {@link evalInObsidian}.
+ */
+export interface EvalInObsidianParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> {
+    /**
+     * Additional arguments to pass to the function. Values may include functions —
+     * they are serialized via `toString()`.
+     */
+    args?: Args;
+    /**
+     * A {@link ContextId} linking this call to a persistent store on `window`
+     * in the Obsidian process. The callback receives a typed `context` object
+     * that survives across calls sharing the same ID.
+     *
+     * When omitted, `context` is a fresh empty object each call.
+     */
+    contextId?: TContextId;
+    /**
+     * The function to evaluate in the Obsidian context.
+     */
+    fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;
+    /**
+     * Skips pre-flight checks (vault registration, CLI availability).
+     * Used internally by vault registration functions.
+     *
+     * @internal
+     */
+    shouldSkipPreflightChecks?: boolean;
+    /**
+     * The path to the Obsidian vault. Defaults to `process.cwd()`.
+     */
+    vaultPath?: string;
+}
+/**
+ * A plain object with string keys.
+ */
+export type GenericObject = Record<string, unknown>;
+/**
+ * Evaluates a function inside the running Obsidian instance
+ * via the Obsidian CLI and returns the parsed result.
+ *
+ * The function receives an args object that includes `app`, `obsidianModule`,
+ * `context`, and any additional `args` passed by the caller.
+ * It is serialized via `toString()` and invoked as an IIFE.
+ * The function must be self-contained — closures over local variables will not work.
+ * Pass any needed values as `args` — they are JSON-serialized and deserialized on the Obsidian side.
+ *
+ * The result is `JSON.stringify`'d on the Obsidian side and parsed back.
+ *
+ * @param params - The parameters for the function to evaluate.
+ * @returns A {@link Promise} that resolves to the return value of `fn`.
+ */
+export declare function evalInObsidian<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(params: EvalInObsidianParams<Args, Result, TContextId>): Promise<Result>;

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

@@ -0,0 +1,91 @@
+"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 obsidian_config_exports = {};
+__export(obsidian_config_exports, {
+  getVaultId: () => getVaultId,
+  isCliEnabled: () => isCliEnabled,
+  isVaultRegistered: () => isVaultRegistered
+});
+module.exports = __toCommonJS(obsidian_config_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);
+function getVaultId(vaultPath) {
+  const config = readObsidianJson();
+  if (!config) {
+    return void 0;
+  }
+  const normalizedTarget = normalizePath(vaultPath);
+  for (const [id, entry] of Object.entries(config.vaults)) {
+    if (normalizePath(entry.path) === normalizedTarget) {
+      return id;
+    }
+  }
+  return void 0;
+}
+function isCliEnabled() {
+  const config = readObsidianJson();
+  return config?.cli === true;
+}
+function isVaultRegistered(vaultPath) {
+  return getVaultId(vaultPath) !== void 0;
+}
+function getObsidianConfigDir() {
+  if (import_node_process.default.platform === "win32") {
+    const appData = import_node_process.default.env["APPDATA"];
+    if (appData) {
+      return (0, import_node_path.join)(appData, "obsidian");
+    }
+  }
+  if (import_node_process.default.platform === "darwin") {
+    return (0, import_node_path.join)((0, import_node_os.homedir)(), "Library", "Application Support", "obsidian");
+  }
+  return (0, import_node_path.join)(import_node_process.default.env["XDG_CONFIG_HOME"] ?? (0, import_node_path.join)((0, import_node_os.homedir)(), ".config"), "obsidian");
+}
+function normalizePath(vaultPath) {
+  const resolved = (0, import_node_path.resolve)(vaultPath);
+  return import_node_process.default.platform === "win32" ? resolved.toLowerCase() : resolved;
+}
+function readObsidianJson() {
+  const configPath = (0, import_node_path.join)(getObsidianConfigDir(), "obsidian.json");
+  try {
+    const content = (0, import_node_fs.readFileSync)(configPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return void 0;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getVaultId,
+  isCliEnabled,
+  isVaultRegistered
+});
+//# sourceMappingURL=data:application/json;base64,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