obsidian-integration-testing 2.6.1 → 2.7.1

package/dist/lib/cjs/eval-in-obsidian.cjs

@@ -34,11 +34,9 @@ module.exports = __toCommonJS(eval_in_obsidian_exports);
 var import_node_fs = require("node:fs");
 var import_node_process = __toESM(require("node:process"), 1);
 var import_context_provider = require("./context-provider.cjs");
-var import_function_expression = require("./function-expression.cjs");
-var import_json_with_functions = require("./json-with-functions.cjs");
+var import_generate_function_call = require("./generate-function-call.cjs");
 var import_serialize_error = require("./serialize-error.cjs");
 var import_transport_factory = require("./transport-factory.cjs");
-const EVAL_ERROR_MARKER = "__obsidianEvalError__";
 const NO_OUTPUT = "(no output)";
 async function evalInObsidian(params) {
   const { args = {}, contextId, fn, shouldSkipPreflightChecks = false, transport: transportOverride, vaultPath } = params;
@@ -50,57 +48,56 @@ async function evalInObsidian(params) {
   if (!shouldSkipPreflightChecks) {
     await transport.preflightCheck(cwd);
   }
-  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();
-  })();
-  ${(0, import_function_expression.getFunctionExpressionString)(import_serialize_error.serializeError)}
-  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} });
-  try {
-    const result${randomSuffix} = await fn${randomSuffix}(fullArgs${randomSuffix});
-    if (result${randomSuffix} === undefined) {
-      return "";
-    }
-    return JSON.stringify(result${randomSuffix});
-  } catch (evalError${randomSuffix}) {
-    return JSON.stringify({ ${EVAL_ERROR_MARKER}: serializeError(evalError${randomSuffix}) });
-  }
-})()`;
+  const expression = (0, import_generate_function_call.generateFunctionCall)(evalWrapper, {
+    args,
+    contextId,
+    ensureLayoutReady: import_generate_function_call.ensureLayoutReady,
+    fn,
+    getObsidianModule,
+    serializeError: import_serialize_error.serializeError
+  });
   const resultStr = await transport.evaluate(expression, { cwd });
   if (resultStr === "" || resultStr === NO_OUTPUT) {
     return void 0;
   }
-  let parsed;
+  let envelope;
   try {
-    parsed = JSON.parse(resultStr);
+    envelope = JSON.parse(resultStr);
   } catch {
     throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);
   }
-  if (parsed !== null && typeof parsed === "object" && EVAL_ERROR_MARKER in parsed) {
-    const errorDetail = String(parsed[EVAL_ERROR_MARKER]);
-    const sanitizedDetail = errorDetail.replace(/\(https?:\/\/localhost\/:(?<line>\d)/g, "(obsidian-webview:$<line>");
-    throw new Error(`evalInObsidian: Error inside Obsidian:
+  if ("type" in envelope) {
+    if (envelope.type === "error") {
+      const sanitizedDetail = envelope.value.replace(/\(https?:\/\/localhost\/:(?<line>\d)/g, "(obsidian-webview:$<line>");
+      throw new Error(`evalInObsidian: Error inside Obsidian:
 ${sanitizedDetail}`);
+    }
+    return void 0;
   }
-  return parsed;
+  return envelope.value;
 }
-async function getObsidianModule() {
-  const app = window.app;
+async function evalWrapper(params) {
+  const app = params.app;
+  if (!app.plugins.isEnabled()) {
+    await app.plugins.setEnable(true);
+  }
+  const obsidianModule = await params.getObsidianModule(params);
+  const contextHolder = window;
+  const contextRaw = params.contextId ? (contextHolder.__obsidianContexts__ ??= {})[String(params.contextId)] ??= {} : {};
+  const context = contextRaw;
+  const fullArgs = { ...params.args, app, context, obsidianModule };
+  try {
+    const result = await params.fn(fullArgs);
+    if (result === void 0) {
+      return JSON.stringify({ type: "undefined" });
+    }
+    return JSON.stringify({ value: result });
+  } catch (evalError) {
+    return JSON.stringify({ type: "error", value: params.serializeError(evalError) });
+  }
+}
+async function getObsidianModule(params) {
+  const app = params.app;
   const obsidianModuleHolder = app;
   if (obsidianModuleHolder.obsidianModule) {
     return obsidianModuleHolder.obsidianModule;
@@ -127,18 +124,18 @@ async function getObsidianModule() {
     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 getObsidianModulePluginFn() {
+    const app2 = window.app;
+    const obsidianModuleHolder2 = app2;
+    const pluginRequire = require;
+    const pluginExports = exports;
+    const obsidianModule = pluginRequire("obsidian");
+    obsidianModuleHolder2.obsidianModule = obsidianModule;
+    pluginExports.default = obsidianModule.Plugin;
+  }
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   evalInObsidian
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Evaluates a function inside a running Obsidian instance via a pluggable transport.\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';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { getTransportOptions } from './context-provider.cjs';\nimport { getFunctionExpressionString } from './function-expression.cjs';\nimport { jsonWithFunctions } from './json-with-functions.cjs';\nimport { serializeError } from './serialize-error.cjs';\nimport { getOrCreateTransport } from './transport-factory.cjs';\n\nconst EVAL_ERROR_MARKER = '__obsidianEvalError__';\n\ninterface ExportsWithDefault {\n  default: unknown;\n}\n\nconst NO_OUTPUT = '(no output)';\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   * Override the transport for this call. When omitted, uses the transport\n   * configured via the context provider (set by the framework adapter's global setup).\n   */\n  transport?: ObsidianTransport;\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 active transport 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, transport: transportOverride, vaultPath } = params;\n  const cwd = vaultPath ?? process.cwd();\n\n  // Check: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!shouldSkipPreflightChecks) {\n    await transport.preflightCheck(cwd);\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  ${getFunctionExpressionString(serializeError)}\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  try {\n    const result${randomSuffix} = await fn${randomSuffix}(fullArgs${randomSuffix});\n    if (result${randomSuffix} === undefined) {\n      return \"\";\n    }\n    return JSON.stringify(result${randomSuffix});\n  } catch (evalError${randomSuffix}) {\n    return JSON.stringify({ ${EVAL_ERROR_MARKER}: serializeError(evalError${randomSuffix}) });\n  }\n})()`;\n\n  const resultStr = await transport.evaluate(expression, { cwd });\n\n  if (resultStr === '' || resultStr === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(resultStr);\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);\n  }\n\n  if (parsed !== null && typeof parsed === 'object' && EVAL_ERROR_MARKER in parsed) {\n    const errorDetail = String((parsed as Record<string, unknown>)[EVAL_ERROR_MARKER]);\n    // Rewrite bare-origin localhost stack frames like \"(http://localhost/:915:32)\"\n    // So Vitest's source-map resolver won't extract \"/\" as the file path and crash\n    // With EISDIR when it tries to readFileSync on the root directory.\n    const sanitizedDetail = errorDetail\n      .replace(/\\(https?:\\/\\/localhost\\/:(?<line>\\d)/g, '(obsidian-webview:$<line>');\n    throw new Error(`evalInObsidian: Error inside Obsidian:\\n${sanitizedDetail}`);\n  }\n\n  return parsed as Result;\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: false,\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 ExportsWithDefault;\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"],
  "mappings": "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",
  "names": ["process"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/eval-in-obsidian.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Evaluates a function inside a running Obsidian instance via a pluggable transport.\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  ContextOf\n} from './context-id.cjs';\nimport type {\n  EnsureLayoutReadyParams,\n  GenerateFunctionCallParams\n} from './generate-function-call.cjs';\nimport type { ObsidianTransport } from './transport.cjs';\n\nimport { getTransportOptions } from './context-provider.cjs';\nimport {\n  ensureLayoutReady,\n  generateFunctionCall\n} from './generate-function-call.cjs';\nimport { serializeError } from './serialize-error.cjs';\nimport { getOrCreateTransport } from './transport-factory.cjs';\n\n/**\n * Discriminated envelope returned by {@link evalWrapper} from inside the Obsidian process.\n *\n * - `{ type: 'error', value: string }` \u2014 `fn` threw; `value` is the serialized error.\n * - `{ type: 'undefined' }` \u2014 `fn` returned `undefined`.\n * - `{ value: unknown }` \u2014 `fn` returned a JSON-serializable value.\n */\ntype EvalResultEnvelope =\n  | { type: 'error'; value: string }\n  | { type: 'undefined' }\n  | { value: unknown };\n\ninterface ExportsWithDefault {\n  default: unknown;\n}\n\nconst NO_OUTPUT = '(no output)';\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   * Override the transport for this call. When omitted, uses the transport\n   * configured via the context provider (set by the framework adapter's global setup).\n   */\n  transport?: ObsidianTransport;\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\ninterface EvalWrapperParams<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined> extends EnsureLayoutReadyParams {\n  args: Args;\n  contextId: TContextId;\n  fn(args: Args & CommonArgs & ContextArgs<TContextId>): Promisable<Result>;\n  getObsidianModule(params: GenerateFunctionCallParams): Promise<typeof obsidian>;\n  serializeError(error: unknown): string;\n}\n\ninterface ObsidianModuleHolder {\n  obsidianModule: typeof obsidian;\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 * Evaluates a function inside the running Obsidian instance\n * via the active transport 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, transport: transportOverride, vaultPath } = params;\n  const cwd = vaultPath ?? process.cwd();\n\n  // Check: Vault path exists on disk.\n  if (vaultPath !== undefined && !existsSync(vaultPath)) {\n    throw new Error(`Vault path does not exist: ${vaultPath}`);\n  }\n\n  const transport = transportOverride ?? await getOrCreateTransport(getTransportOptions());\n\n  if (!shouldSkipPreflightChecks) {\n    await transport.preflightCheck(cwd);\n  }\n\n  const expression = generateFunctionCall(evalWrapper, {\n    args,\n    contextId,\n    ensureLayoutReady,\n    fn,\n    getObsidianModule,\n    serializeError\n  });\n\n  const resultStr = await transport.evaluate(expression, { cwd });\n\n  if (resultStr === '' || resultStr === NO_OUTPUT) {\n    return undefined as Result;\n  }\n\n  let envelope: EvalResultEnvelope;\n  try {\n    envelope = JSON.parse(resultStr) as EvalResultEnvelope;\n  } catch {\n    throw new Error(`evalInObsidian: Obsidian returned non-JSON output: ${resultStr}`);\n  }\n\n  if ('type' in envelope) {\n    if (envelope.type === 'error') {\n      // Rewrite bare-origin localhost stack frames like \"(http://localhost/:915:32)\"\n      // So Vitest's source-map resolver won't extract \"/\" as the file path and crash\n      // With EISDIR when it tries to readFileSync on the root directory.\n      const sanitizedDetail = envelope.value\n        .replace(/\\(https?:\\/\\/localhost\\/:(?<line>\\d)/g, '(obsidian-webview:$<line>');\n      throw new Error(`evalInObsidian: Error inside Obsidian:\\n${sanitizedDetail}`);\n    }\n\n    return undefined as Result;\n  }\n\n  return envelope.value as Result;\n}\n\n/**\n * The top-level wrapper that is serialized and invoked inside the Obsidian\n * process via {@link generateFunctionCall}. It wires up the obsidian module,\n * context, and error handling, then delegates to the caller-supplied `fn`.\n *\n * Must NOT reference any outer scope \u2014 it is serialized via `toString()`.\n *\n * @param params - The parameters for the wrapper.\n * @param params.args - The user-supplied arguments to pass to `fn`.\n * @param params.contextId - The context identifier for persistent storage.\n * @param params.fn - The user function to evaluate.\n * @param params.resolveObsidianModule - Resolves the `obsidian` module at runtime.\n * @param params.stringifyError - Serializes an error into a human-readable string.\n * @returns A JSON-stringified {@link EvalResultEnvelope}.\n */\nasync function evalWrapper<Args extends GenericObject, Result, TContextId extends ContextId<unknown> | undefined = undefined>(\n  params: GenerateFunctionCallParams<EvalWrapperParams<Args, Result, TContextId>>\n): Promise<string> {\n  const app = params.app;\n  if (!app.plugins.isEnabled()) {\n    await app.plugins.setEnable(true);\n  }\n  const obsidianModule = await params.getObsidianModule(params);\n  interface ContextHolder {\n    __obsidianContexts__: Record<string, Record<string, unknown>>;\n  }\n  const contextHolder = window as Partial<ContextHolder>;\n  const contextRaw = params.contextId\n    ? ((contextHolder.__obsidianContexts__ ??= {})[String(params.contextId)] ??= {})\n    : {};\n  const context = contextRaw as ContextOf<TContextId>;\n  const fullArgs = ({ ...params.args, app, context, obsidianModule }) as Args & CommonArgs & ContextArgs<TContextId>;\n  try {\n    const result = await params.fn(fullArgs) as Result | undefined;\n    if (result === undefined) {\n      return JSON.stringify({ type: 'undefined' });\n    }\n    return JSON.stringify({ value: result });\n  } catch (evalError) {\n    return JSON.stringify({ type: 'error', value: params.serializeError(evalError) });\n  }\n}\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 * @param params - The parameters, including the `app` instance.\n * @returns The `obsidian` module.\n */\nasync function getObsidianModule(params: GenerateFunctionCallParams): Promise<typeof obsidian> {\n  const app = params.app;\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: false,\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   * 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   */\n  function getObsidianModulePluginFn(): void {\n    // eslint-disable-next-line @typescript-eslint/no-deprecated, no-shadow -- We need global `app` variable. Intentional redeclaration \u2014 self-contained serialized function.\n    const app = window.app;\n\n    const obsidianModuleHolder2 = app as Partial<ObsidianModuleHolder>;\n\n    const pluginRequire = require;\n    const pluginExports = exports as ExportsWithDefault;\n\n    const obsidianModule = pluginRequire('obsidian') as typeof obsidian;\n    obsidianModuleHolder2.obsidianModule = obsidianModule;\n    pluginExports.default = obsidianModule.Plugin;\n  }\n}\n\n/* v8 ignore stop */\n"],
  "mappings": "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",
  "names": ["process", "app"]
}


package/dist/lib/cjs/generate-function-call.cjs

@@ -0,0 +1,42 @@
+"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 generate_function_call_exports = {};
+__export(generate_function_call_exports, {
+  ensureLayoutReady: () => ensureLayoutReady,
+  generateFunctionCall: () => generateFunctionCall
+});
+module.exports = __toCommonJS(generate_function_call_exports);
+var import_function_expression = require("./function-expression.cjs");
+var import_json_with_functions = require("./json-with-functions.cjs");
+async function ensureLayoutReady(params) {
+  await new Promise((resolve) => {
+    params.app.workspace.onLayoutReady(resolve);
+  });
+}
+function generateFunctionCall(fn, params) {
+  const fnExpr = (0, import_function_expression.getFunctionExpressionString)(fn);
+  const serializedParams = (0, import_json_with_functions.jsonWithFunctions)(params);
+  return `(${fnExpr})(Object.assign(${serializedParams}, { app: window.app }))`;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ensureLayoutReady,
+  generateFunctionCall
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/generate-function-call.d.cts

@@ -0,0 +1,57 @@
+/**
+ * @file
+ *
+ * Generates a JavaScript expression that calls a serialized function with serialized arguments.
+ */
+import type { App } from 'obsidian';
+import type { Promisable } from 'type-fest';
+/**
+ * Parameters with `ensureLayoutReady` function.
+ */
+export interface EnsureLayoutReadyParams {
+    /**
+     * Waits for the Obsidian workspace layout to be ready.
+     *
+     * @param params - Parameters including the `app` instance.
+     * @returns A promise that resolves when the layout is ready.
+     */
+    ensureLayoutReady(params: GenerateFunctionCallParams): Promise<void>;
+}
+/**
+ * Parameters for `generateFunctionCall`.
+ *
+ * @typeParam Params - The type of the additional parameters to pass to the function being called.
+ */
+export type GenerateFunctionCallParams<Params = unknown> = AppParams & Params;
+interface AppParams {
+    app: App;
+}
+/**
+ * Waits for the Obsidian workspace layout to be ready.
+ *
+ * @param params - The parameters, including the `app` instance.
+ * @returns A promise that resolves when the layout is ready.
+ */
+export declare function ensureLayoutReady(params: GenerateFunctionCallParams): Promise<void>;
+/**
+ * Generates a JavaScript expression string that immediately invokes the given
+ * function with the given arguments.
+ *
+ * The function is serialized via {@link getFunctionExpressionString} and the
+ * arguments are serialized via {@link jsonWithFunctions}, producing a
+ * self-contained IIFE of the form `(fnExpr)(argsExpr)`.
+ *
+ * @param fn - The function to call.
+ * @param params - The arguments to pass. When omitted, the function is called with no arguments.
+ * @returns A JavaScript expression string.
+ */
+/**
+ * Generates a JavaScript expression string that immediately invokes the given
+ * function with the given arguments.
+ *
+ * @param fn - The function to call.
+ * @param params - The arguments to pass.
+ * @returns A JavaScript expression string.
+ */
+export declare function generateFunctionCall<Params>(fn: (params: GenerateFunctionCallParams<Params>) => Promisable<unknown>, params: Params): string;
+export {};

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

@@ -28,16 +28,25 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var obsidian_config_exports = {};
 __export(obsidian_config_exports, {
+  enableCliInConfig: () => enableCliInConfig,
   getAnyRegisteredVaultPath: () => getAnyRegisteredVaultPath,
   getVaultId: () => getVaultId,
   isCliEnabled: () => isCliEnabled,
-  isVaultRegistered: () => isVaultRegistered
+  isVaultRegistered: () => isVaultRegistered,
+  registerVaultInConfig: () => registerVaultInConfig,
+  removeVaultFromConfig: () => removeVaultFromConfig
 });
 module.exports = __toCommonJS(obsidian_config_exports);
+var import_node_crypto = require("node:crypto");
 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 enableCliInConfig() {
+  const config = readObsidianJson() ?? { vaults: {} };
+  config.cli = true;
+  writeObsidianJson(config);
+}
 function getAnyRegisteredVaultPath() {
   const config = readObsidianJson();
   if (!config) {
@@ -66,6 +75,33 @@ function isCliEnabled() {
 function isVaultRegistered(vaultPath) {
   return getVaultId(vaultPath) !== void 0;
 }
+function registerVaultInConfig(vaultPath) {
+  const config = readObsidianJson() ?? { vaults: {} };
+  const VAULT_ID_BYTE_LENGTH = 8;
+  const id = (0, import_node_crypto.randomBytes)(VAULT_ID_BYTE_LENGTH).toString("hex");
+  config.vaults[id] = { path: vaultPath, ts: Date.now() };
+  config.cli = true;
+  writeObsidianJson(config);
+}
+function removeVaultFromConfig(vaultPath) {
+  const config = readObsidianJson();
+  if (!config) {
+    return false;
+  }
+  const normalizedTarget = normalizePath(vaultPath);
+  let wasFound = false;
+  for (const [id, entry] of Object.entries(config.vaults)) {
+    if (normalizePath(entry.path) === normalizedTarget) {
+      delete config.vaults[id];
+      wasFound = true;
+      break;
+    }
+  }
+  if (wasFound) {
+    writeObsidianJson(config);
+  }
+  return wasFound;
+}
 function getObsidianConfigDir() {
   if (import_node_process.default.platform === "win32") {
     const appData = import_node_process.default.env["APPDATA"];
@@ -91,11 +127,18 @@ function readObsidianJson() {
     return void 0;
   }
 }
+function writeObsidianJson(config) {
+  const configPath = (0, import_node_path.join)(getObsidianConfigDir(), "obsidian.json");
+  (0, import_node_fs.writeFileSync)(configPath, JSON.stringify(config));
+}
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
+  enableCliInConfig,
   getAnyRegisteredVaultPath,
   getVaultId,
   isCliEnabled,
-  isVaultRegistered
+  isVaultRegistered,
+  registerVaultInConfig,
+  removeVaultFromConfig
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/obsidian-config.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Reads and queries Obsidian's local configuration (`obsidian.json`).\n */\n\nimport { randomBytes } from 'node:crypto';\nimport {\n  readFileSync,\n  writeFileSync\n} from 'node:fs';\nimport { homedir } from 'node:os';\nimport {\n  join,\n  resolve\n} from 'node:path';\nimport process from 'node:process';\n\n/**\n * The top-level structure of Obsidian's `obsidian.json` config file.\n */\ninterface ObsidianJson {\n  /**\n   * Whether the CLI is enabled in Obsidian settings.\n   */\n  cli?: boolean;\n\n  /**\n   * Map of vault IDs to vault entries.\n   */\n  vaults: Record<string, ObsidianVaultEntry>;\n}\n\n/**\n * A single vault entry in `obsidian.json`.\n */\ninterface ObsidianVaultEntry {\n  /**\n   * Whether the vault is currently open.\n   */\n  open?: boolean;\n\n  /**\n   * The absolute path to the vault folder.\n   */\n  path: string;\n\n  /**\n   * Timestamp of the last access.\n   */\n  ts: number;\n}\n\n/**\n * Enables the CLI in Obsidian's `obsidian.json` config file.\n *\n * Sets `cli: true` so that Obsidian starts its CLI server on next launch.\n * If the config file doesn't exist, creates it with an empty vaults object.\n */\nexport function enableCliInConfig(): void {\n  const config = readObsidianJson() ?? { vaults: {} };\n  config.cli = true;\n  writeObsidianJson(config);\n}\n\n/**\n * Returns the path of any vault that is currently registered in Obsidian's registry.\n *\n * This is useful when an `obsidian eval` call must run inside an existing vault\n * window (e.g., to issue IPC commands that register or remove other vaults).\n *\n * @returns The absolute path to a registered vault, or `undefined` if no vaults are registered.\n */\nexport function getAnyRegisteredVaultPath(): string | undefined {\n  const config = readObsidianJson();\n  if (!config) {\n    return undefined;\n  }\n\n  const firstEntry = Object.values(config.vaults)[0];\n  return firstEntry?.path;\n}\n\n/**\n * Returns the hex vault ID for a given vault path from Obsidian's registry.\n *\n * @param vaultPath - The absolute path to the vault folder.\n * @returns The vault ID, or `undefined` if the vault is not registered.\n */\nexport function getVaultId(vaultPath: string): string | undefined {\n  const config = readObsidianJson();\n  if (!config) {\n    return undefined;\n  }\n\n  const normalizedTarget = normalizePath(vaultPath);\n\n  for (const [id, entry] of Object.entries(config.vaults)) {\n    if (normalizePath(entry.path) === normalizedTarget) {\n      return id;\n    }\n  }\n\n  return undefined;\n}\n\n/**\n * Checks whether the Obsidian CLI is enabled in Obsidian's settings.\n *\n * @returns `true` if the CLI is enabled, `false` otherwise.\n */\nexport function isCliEnabled(): boolean {\n  const config = readObsidianJson();\n  return config?.cli === true;\n}\n\n/**\n * Checks whether a vault path is registered in Obsidian's vault registry.\n *\n * @param vaultPath - The absolute path to the vault folder.\n * @returns `true` if the vault is registered, `false` otherwise.\n */\nexport function isVaultRegistered(vaultPath: string): boolean {\n  return getVaultId(vaultPath) !== undefined;\n}\n\n/**\n * Registers a vault directly in Obsidian's `obsidian.json` config file.\n *\n * This writes a new vault entry with a random hex ID. Used when no existing\n * vault is available to send IPC commands through \u2014 the vault is registered\n * \"offline\" so Obsidian will open it on next launch.\n *\n * @param vaultPath - The absolute path to the vault folder.\n */\nexport function registerVaultInConfig(vaultPath: string): void {\n  const config = readObsidianJson() ?? { vaults: {} };\n  const VAULT_ID_BYTE_LENGTH = 8;\n  const id = randomBytes(VAULT_ID_BYTE_LENGTH).toString('hex');\n  config.vaults[id] = { path: vaultPath, ts: Date.now() };\n  config.cli = true;\n  writeObsidianJson(config);\n}\n\n/**\n * Removes a vault entry from Obsidian's `obsidian.json` config file.\n *\n * @param vaultPath - The absolute path to the vault folder.\n * @returns `true` if the vault was found and removed, `false` otherwise.\n */\nexport function removeVaultFromConfig(vaultPath: string): boolean {\n  const config = readObsidianJson();\n  if (!config) {\n    return false;\n  }\n\n  const normalizedTarget = normalizePath(vaultPath);\n  let wasFound = false;\n\n  for (const [id, entry] of Object.entries(config.vaults)) {\n    if (normalizePath(entry.path) === normalizedTarget) {\n      // eslint-disable-next-line @typescript-eslint/no-dynamic-delete -- Removing a vault entry by its dynamic key.\n      delete config.vaults[id];\n      wasFound = true;\n      break;\n    }\n  }\n\n  if (wasFound) {\n    writeObsidianJson(config);\n  }\n\n  return wasFound;\n}\n\n/**\n * Returns the platform-specific path to Obsidian's config directory.\n *\n * @returns The absolute path to the `obsidian/` config directory.\n */\nfunction getObsidianConfigDir(): string {\n  if (process.platform === 'win32') {\n    const appData = process.env['APPDATA'];\n    if (appData) {\n      return join(appData, 'obsidian');\n    }\n  }\n\n  if (process.platform === 'darwin') {\n    return join(homedir(), 'Library', 'Application Support', 'obsidian');\n  }\n\n  return join(process.env['XDG_CONFIG_HOME'] ?? join(homedir(), '.config'), 'obsidian');\n}\n\n/**\n * Normalizes a vault path for comparison.\n * On Windows, paths are case-insensitive and separators may vary.\n *\n * @param vaultPath - The path to normalize.\n * @returns The normalized path.\n */\nfunction normalizePath(vaultPath: string): string {\n  const resolved = resolve(vaultPath);\n  return process.platform === 'win32' ? resolved.toLowerCase() : resolved;\n}\n\n/**\n * Reads and parses Obsidian's `obsidian.json` config file.\n *\n * @returns The parsed config, or `undefined` if the file doesn't exist or can't be parsed.\n */\nfunction readObsidianJson(): ObsidianJson | undefined {\n  const configPath = join(getObsidianConfigDir(), 'obsidian.json');\n  try {\n    const content = readFileSync(configPath, 'utf-8');\n    return JSON.parse(content) as ObsidianJson;\n  } catch {\n    return undefined;\n  }\n}\n\n/**\n * Writes the given config object to Obsidian's `obsidian.json` file.\n *\n * @param config - The config to write.\n */\nfunction writeObsidianJson(config: ObsidianJson): void {\n  const configPath = join(getObsidianConfigDir(), 'obsidian.json');\n  writeFileSync(configPath, JSON.stringify(config));\n}\n"],
  "mappings": "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",
  "names": ["process"]
}


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

@@ -3,6 +3,13 @@
  *
  * Reads and queries Obsidian's local configuration (`obsidian.json`).
  */
+/**
+ * Enables the CLI in Obsidian's `obsidian.json` config file.
+ *
+ * Sets `cli: true` so that Obsidian starts its CLI server on next launch.
+ * If the config file doesn't exist, creates it with an empty vaults object.
+ */
+export declare function enableCliInConfig(): void;
 /**
  * Returns the path of any vault that is currently registered in Obsidian's registry.
  *
@@ -32,3 +39,20 @@ export declare function isCliEnabled(): boolean;
  * @returns `true` if the vault is registered, `false` otherwise.
  */
 export declare function isVaultRegistered(vaultPath: string): boolean;
+/**
+ * Registers a vault directly in Obsidian's `obsidian.json` config file.
+ *
+ * This writes a new vault entry with a random hex ID. Used when no existing
+ * vault is available to send IPC commands through — the vault is registered
+ * "offline" so Obsidian will open it on next launch.
+ *
+ * @param vaultPath - The absolute path to the vault folder.
+ */
+export declare function registerVaultInConfig(vaultPath: string): void;
+/**
+ * Removes a vault entry from Obsidian's `obsidian.json` config file.
+ *
+ * @param vaultPath - The absolute path to the vault folder.
+ * @returns `true` if the vault was found and removed, `false` otherwise.
+ */
+export declare function removeVaultFromConfig(vaultPath: string): boolean;