obsidian-integration-testing 1.0.0

package/dist/lib/cjs/exec.cjs

@@ -0,0 +1,267 @@
+"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 exec_exports = {};
+__export(exec_exports, {
+  exec: () => exec,
+  toCommandLine: () => toCommandLine
+});
+module.exports = __toCommonJS(exec_exports);
+var import_node_child_process = require("node:child_process");
+var import_node_process = __toESM(require("node:process"), 1);
+function exec(command, options = {}) {
+  if (Array.isArray(command)) {
+    const batchResult = handleBatchedCommand(command, options);
+    if (batchResult) {
+      return batchResult;
+    }
+    const args = command.filter((part) => typeof part === "string");
+    const commandLine = toCommandLine(args);
+    const maxCommandLength2 = getMaxCommandLength();
+    if (commandLine.length > maxCommandLength2) {
+      return Promise.reject(
+        new Error(
+          `Command line is too long (${String(commandLine.length)} chars, max ${String(maxCommandLength2)} on ${import_node_process.default.platform}). Consider using ExecArg with batchedArgs.`
+        )
+      );
+    }
+    return execString(commandLine, options, args);
+  }
+  const maxCommandLength = getMaxCommandLength();
+  if (command.length > maxCommandLength) {
+    return Promise.reject(
+      new Error(
+        `Command line is too long (${String(command.length)} chars, max ${String(maxCommandLength)} on ${import_node_process.default.platform}). Consider using ExecArg with batchedArgs.`
+      )
+    );
+  }
+  return execString(command, options);
+}
+function execString(command, options = {}, rawArgs) {
+  const {
+    cwd = import_node_process.default.cwd(),
+    isQuiet: quiet = false,
+    shouldIgnoreExitCode: ignoreExitCode = false,
+    shouldIncludeDetails: withDetails = false,
+    stdin = ""
+  } = options;
+  return new Promise((resolve, reject) => {
+    const child = spawnViaShell(command, cwd, rawArgs);
+    let stdout = "";
+    let stderr = "";
+    child.stdin.write(stdin);
+    child.stdin.end();
+    child.stdout.on("data", (data) => {
+      if (!quiet) {
+        import_node_process.default.stdout.write(data);
+      }
+      stdout += data.toString("utf-8");
+    });
+    child.stdout.on("end", () => {
+      stdout = trimEnd(stdout, "\n");
+    });
+    child.stderr.on("data", (data) => {
+      if (!quiet) {
+        import_node_process.default.stderr.write(data);
+      }
+      stderr += data.toString("utf-8");
+    });
+    child.stderr.on("end", () => {
+      stderr = trimEnd(stderr, "\n");
+    });
+    child.on("close", (exitCode, exitSignal) => {
+      if (exitCode !== 0 && !ignoreExitCode) {
+        reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : "(null)"}
+${stderr}`));
+        return;
+      }
+      if (!withDetails) {
+        resolve(stdout);
+        return;
+      }
+      resolve({
+        exitCode,
+        exitSignal,
+        stderr,
+        stdout
+      });
+    });
+    child.on("error", (err) => {
+      if (!ignoreExitCode) {
+        reject(err);
+        return;
+      }
+      if (!withDetails) {
+        resolve(stdout);
+        return;
+      }
+      resolve({
+        exitCode: null,
+        exitSignal: null,
+        stderr,
+        stdout
+      });
+    });
+  });
+}
+const CHILD_ENV = {
+  DEBUG_COLORS: "1",
+  ...import_node_process.default.env
+};
+const CMD_META_RE = /[()%!^"<>&|]/g;
+function toCommandLine(args) {
+  return args.map((arg) => argvQuote(arg)).join(" ");
+}
+function argvQuote(arg) {
+  if (arg.length > 0 && !/[\s\t\n\v"]/.test(arg)) {
+    return arg;
+  }
+  const BACKSLASH_ESCAPE_FACTOR = 2;
+  let result = '"';
+  for (let i = 0; i < arg.length; i++) {
+    let numBackslashes = 0;
+    while (i < arg.length && arg[i] === "\\") {
+      i++;
+      numBackslashes++;
+    }
+    if (i === arg.length) {
+      result += "\\".repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR);
+      break;
+    }
+    const ch = arg.charAt(i);
+    if (ch === '"') {
+      result += `${"\\".repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR + 1)}"`;
+    } else {
+      result += "\\".repeat(numBackslashes) + ch;
+    }
+  }
+  result += '"';
+  return result;
+}
+function cmdEscapeCommandLine(commandLine) {
+  return commandLine.replace(CMD_META_RE, "^$&");
+}
+async function executeBatches(baseCommand, batches, options) {
+  const results = [];
+  for (const batch of batches) {
+    const batchCommand = `${baseCommand} ${batch.join(" ")}`;
+    const result = await execString(batchCommand, options);
+    if (typeof result === "string") {
+      results.push(result);
+    }
+  }
+  if (options.shouldIncludeDetails) {
+    return { exitCode: 0, exitSignal: null, stderr: "", stdout: results.join("\n") };
+  }
+  return results.join("\n");
+}
+function getMaxCommandLength() {
+  const WINDOWS_MAX_COMMAND_LENGTH = 8191;
+  const UNIX_MAX_COMMAND_LENGTH = 131072;
+  return import_node_process.default.platform === "win32" ? WINDOWS_MAX_COMMAND_LENGTH : UNIX_MAX_COMMAND_LENGTH;
+}
+function handleBatchedCommand(parts, options) {
+  const execArgs = parts.filter(isExecArg);
+  if (execArgs.length === 0) {
+    return void 0;
+  }
+  if (execArgs.length > 1) {
+    return Promise.reject(new Error("Only one ExecArg with batchedArgs is allowed per command"));
+  }
+  const execArg = execArgs[0];
+  if (!execArg) {
+    return void 0;
+  }
+  const staticParts = parts.filter((part) => typeof part === "string");
+  const baseCommand = toCommandLine(staticParts);
+  const maxCommandLength = getMaxCommandLength();
+  const fullCommand = `${baseCommand} ${execArg.batchedArgs.join(" ")}`;
+  if (fullCommand.length <= maxCommandLength) {
+    return execString(fullCommand, options);
+  }
+  const batches = [];
+  let currentBatch = [];
+  for (const arg of execArg.batchedArgs) {
+    const tentative = `${baseCommand} ${[...currentBatch, arg].join(" ")}`;
+    if (tentative.length > maxCommandLength) {
+      if (currentBatch.length === 0) {
+        return Promise.reject(
+          new Error(
+            `Cannot split command into batches: a single argument (${String(arg.length)} chars) plus the base command (${String(baseCommand.length)} chars) exceeds the max command length (${String(maxCommandLength)}).`
+          )
+        );
+      }
+      batches.push(currentBatch);
+      currentBatch = [arg];
+    } else {
+      currentBatch.push(arg);
+    }
+  }
+  if (currentBatch.length > 0) {
+    batches.push(currentBatch);
+  }
+  return executeBatches(baseCommand, batches, options);
+}
+function isExecArg(part) {
+  return typeof part === "object" && "batchedArgs" in part;
+}
+function spawnViaShell(command, cwd, rawArgs) {
+  if (import_node_process.default.platform === "win32" && command.includes("\n")) {
+    if (!rawArgs) {
+      throw new Error("Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.");
+    }
+    const [program, ...args] = rawArgs;
+    if (!program) {
+      throw new Error("Command array must not be empty");
+    }
+    return (0, import_node_child_process.spawn)(program, args, {
+      cwd,
+      env: CHILD_ENV,
+      stdio: "pipe"
+    });
+  }
+  const shellCommand = import_node_process.default.platform === "win32" ? cmdEscapeCommandLine(command) : command;
+  return (0, import_node_child_process.spawn)(shellCommand, [], {
+    cwd,
+    env: CHILD_ENV,
+    shell: true,
+    stdio: "pipe"
+  });
+}
+function trimEnd(str, suffix) {
+  if (str.endsWith(suffix)) {
+    return str.slice(0, -suffix.length);
+  }
+  return str;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  exec,
+  toCommandLine
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/exec.ts"],
  "sourcesContent": ["/**\n * @packageDocumentation\n *\n * Contains utility functions for executing commands.\n */\n\nimport type { ChildProcessWithoutNullStreams } from 'node:child_process';\n\nimport { spawn } from 'node:child_process';\nimport process from 'node:process';\n\n/**\n * A command part: either a plain string or an {@link ExecArg} with batched arguments.\n */\nexport type CommandPart = ExecArg | string;\n\n/**\n * A command argument that contains a list of args to be batched.\n * If the expanded command exceeds the platform's max command length,\n * the batched args are split into sequential executions.\n */\nexport interface ExecArg {\n  /**\n   * The arguments to batch.\n   */\n  batchedArgs: string[];\n}\n\n/**\n * Options for {@link exec} that return detailed results.\n */\nexport interface ExecDetailedOptions extends ExecOption {\n  /**\n   * Must be `true` to receive detailed results.\n   */\n  withDetails: true;\n}\n\n/**\n * Options for executing a command.\n */\nexport interface ExecOption {\n  /**\n   * A current working folder for the command execution.\n   */\n  readonly cwd?: string;\n\n  /**\n   * If `true`, suppresses the output of the command.\n   */\n  readonly isQuiet?: boolean;\n\n  /**\n   * If `true`, ignores the exit code of the command.\n   */\n  readonly shouldIgnoreExitCode?: boolean;\n\n  /**\n   * If `true`, returns detailed results.\n   */\n  readonly shouldIncludeDetails?: boolean;\n\n  /**\n   * An input to be passed to the command.\n   */\n  readonly stdin?: string;\n}\n\n/**\n * A result of {@link exec}.\n */\nexport interface ExecResult {\n  /**\n   * An exit code of the command. A value of `null` indicates that the process did not exit normally.\n   */\n  exitCode: null | number;\n\n  /**\n   * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.\n   */\n  exitSignal: NodeJS.Signals | null;\n\n  /**\n   * A standard error output from the command.\n   */\n  stderr: string;\n\n  /**\n   * A standard output from the command.\n   */\n  stdout: string;\n}\n\n/**\n * Options for {@link exec} that return only stdout.\n */\nexport interface ExecSimpleOptions extends ExecOption {\n  /**\n   * Must be `false` or omitted to receive only stdout.\n   */\n  withDetails?: false;\n}\n\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command.\n */\nexport async function exec(command: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with ExecResult object.\n */\nexport function exec(command: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;\n/**\n * Executes a command.\n *\n * @param command - The command to execute. It can be a string or an array of strings.\n * @param options - The options for the execution.\n * @returns A {@link Promise} that resolves with the output of the command or an ExecResult object.\n */\nexport function exec(command: CommandPart[] | string, options: ExecOption = {}): Promise<ExecResult | string> {\n  if (Array.isArray(command)) {\n    const batchResult = handleBatchedCommand(command, options);\n    if (batchResult) {\n      return batchResult;\n    }\n    const args = command.filter((part): part is string => typeof part === 'string');\n    const commandLine = toCommandLine(args);\n\n    const maxCommandLength = getMaxCommandLength();\n    if (commandLine.length > maxCommandLength) {\n      return Promise.reject(\n        new Error(\n          `Command line is too long (${String(commandLine.length)} chars, max ${\n            String(maxCommandLength)\n          } on ${process.platform}). Consider using ExecArg with batchedArgs.`\n        )\n      );\n    }\n\n    return execString(commandLine, options, args);\n  }\n\n  const maxCommandLength = getMaxCommandLength();\n  if (command.length > maxCommandLength) {\n    return Promise.reject(\n      new Error(\n        `Command line is too long (${String(command.length)} chars, max ${\n          String(maxCommandLength)\n        } on ${process.platform}). Consider using ExecArg with batchedArgs.`\n      )\n    );\n  }\n\n  return execString(command, options);\n}\n\n/**\n * Executes a single string command.\n *\n * @param command - The command string.\n * @param options - The exec options.\n * @param rawArgs - The original argument array (if available), used by the\n *   direct-spawn fallback on Windows when the command contains newlines.\n * @returns A Promise resolving to the result.\n */\nfunction execString(command: string, options: ExecOption = {}, rawArgs?: string[]): Promise<ExecResult | string> {\n  const {\n    cwd = process.cwd(),\n    isQuiet: quiet = false,\n    shouldIgnoreExitCode: ignoreExitCode = false,\n    shouldIncludeDetails: withDetails = false,\n    stdin = ''\n  } = options;\n\n  return new Promise((resolve, reject) => {\n    const child = spawnViaShell(command, cwd, rawArgs);\n\n    let stdout = '';\n    let stderr = '';\n\n    child.stdin.write(stdin);\n    child.stdin.end();\n\n    child.stdout.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stdout.write(data);\n      }\n      stdout += data.toString('utf-8');\n    });\n\n    child.stdout.on('end', () => {\n      stdout = trimEnd(stdout, '\\n');\n    });\n\n    child.stderr.on('data', (data: Buffer) => {\n      if (!quiet) {\n        process.stderr.write(data);\n      }\n      stderr += data.toString('utf-8');\n    });\n\n    child.stderr.on('end', () => {\n      stderr = trimEnd(stderr, '\\n');\n    });\n\n    child.on('close', (exitCode, exitSignal) => {\n      if (exitCode !== 0 && !ignoreExitCode) {\n        reject(new Error(`Command failed with exit code ${exitCode ? String(exitCode) : '(null)'}\\n${stderr}`));\n        return;\n      }\n\n      if (!withDetails) {\n        resolve(stdout);\n        return;\n      }\n      resolve({\n        exitCode,\n        exitSignal,\n        stderr,\n        stdout\n      });\n    });\n\n    child.on('error', (err) => {\n      if (!ignoreExitCode) {\n        reject(err);\n        return;\n      }\n\n      if (!withDetails) {\n        resolve(stdout);\n        return;\n      }\n\n      resolve({\n        exitCode: null,\n        exitSignal: null,\n        stderr,\n        stdout\n      });\n    });\n  });\n}\n\n/**\n * Default environment variables passed to child processes.\n */\nconst CHILD_ENV = {\n  DEBUG_COLORS: '1',\n  ...process.env\n};\n\n/**\n * Matches `cmd.exe` metacharacters that must be `^`-escaped.\n */\nconst CMD_META_RE = /[()%!^\"<>&|]/g;\n\n/**\n * Converts an array of command-line arguments into a single command-line string\n * using the `CommandLineToArgvW` convention.\n *\n * @param args - The array of command-line arguments to convert.\n * @returns A string representing the command-line invocation.\n */\nexport function toCommandLine(args: string[]): string {\n  return args.map((arg) => argvQuote(arg)).join(' ');\n}\n\n/**\n * Quotes a single argument so that `CommandLineToArgvW` will decode it\n * unchanged.\n *\n * @param arg - The raw argument string.\n * @returns The quoted argument string.\n */\nfunction argvQuote(arg: string): string {\n  if (arg.length > 0 && !/[\\s\\t\\n\\v\"]/.test(arg)) {\n    return arg;\n  }\n\n  const BACKSLASH_ESCAPE_FACTOR = 2;\n  let result = '\"';\n  for (let i = 0; i < arg.length; i++) {\n    let numBackslashes = 0;\n    while (i < arg.length && arg[i] === '\\\\') {\n      i++;\n      numBackslashes++;\n    }\n\n    if (i === arg.length) {\n      result += '\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR);\n      break;\n    }\n\n    const ch = arg.charAt(i);\n    if (ch === '\"') {\n      result += `${'\\\\'.repeat(numBackslashes * BACKSLASH_ESCAPE_FACTOR + 1)}\"`;\n    } else {\n      result += '\\\\'.repeat(numBackslashes) + ch;\n    }\n  }\n\n  result += '\"';\n  return result;\n}\n\n/**\n * Escapes `cmd.exe` metacharacters with `^` so that `cmd.exe` passes them\n * through literally.\n *\n * @param commandLine - The already-quoted command line string.\n * @returns The string with all cmd metacharacters `^`-escaped.\n */\nfunction cmdEscapeCommandLine(commandLine: string): string {\n  return commandLine.replace(CMD_META_RE, '^$&');\n}\n\n/**\n * Executes batched commands sequentially and concatenates stdout.\n *\n * @param baseCommand - The base command without batched args.\n * @param batches - The batches of args.\n * @param options - The exec options.\n * @returns A Promise resolving to the concatenated result.\n */\nasync function executeBatches(baseCommand: string, batches: string[][], options: ExecOption): Promise<ExecResult | string> {\n  const results: string[] = [];\n\n  for (const batch of batches) {\n    const batchCommand = `${baseCommand} ${batch.join(' ')}`;\n    const result = await execString(batchCommand, options);\n    if (typeof result === 'string') {\n      results.push(result);\n    }\n  }\n\n  if (options.shouldIncludeDetails) {\n    return { exitCode: 0, exitSignal: null, stderr: '', stdout: results.join('\\n') };\n  }\n\n  return results.join('\\n');\n}\n\n/**\n * Returns the platform-specific max command line length.\n *\n * @returns The max command length in characters.\n */\nfunction getMaxCommandLength(): number {\n  const WINDOWS_MAX_COMMAND_LENGTH = 8191;\n  const UNIX_MAX_COMMAND_LENGTH = 131072;\n  return process.platform === 'win32' ? WINDOWS_MAX_COMMAND_LENGTH : UNIX_MAX_COMMAND_LENGTH;\n}\n\n/**\n * Handles a command array that may contain an {@link ExecArg}.\n * Returns a Promise if batching is needed, or `undefined` if the command\n * has no ExecArg and should be processed normally.\n *\n * @param parts - The command parts.\n * @param options - The exec options.\n * @returns A Promise if batching is handled, or `undefined`.\n */\nfunction handleBatchedCommand(parts: CommandPart[], options: ExecOption): Promise<ExecResult | string> | undefined {\n  const execArgs = parts.filter(isExecArg);\n  if (execArgs.length === 0) {\n    return undefined;\n  }\n  if (execArgs.length > 1) {\n    return Promise.reject(new Error('Only one ExecArg with batchedArgs is allowed per command'));\n  }\n\n  const execArg = execArgs[0];\n  /* v8 ignore start -- Always truthy after the length check above. */\n  if (!execArg) {\n    return undefined;\n  }\n  /* v8 ignore stop */\n\n  const staticParts = parts.filter((part): part is string => typeof part === 'string');\n  const baseCommand = toCommandLine(staticParts);\n  const maxCommandLength = getMaxCommandLength();\n\n  const fullCommand = `${baseCommand} ${execArg.batchedArgs.join(' ')}`;\n  if (fullCommand.length <= maxCommandLength) {\n    return execString(fullCommand, options);\n  }\n\n  const batches: string[][] = [];\n  let currentBatch: string[] = [];\n\n  for (const arg of execArg.batchedArgs) {\n    const tentative = `${baseCommand} ${[...currentBatch, arg].join(' ')}`;\n    if (tentative.length > maxCommandLength) {\n      if (currentBatch.length === 0) {\n        return Promise.reject(\n          new Error(\n            `Cannot split command into batches: a single argument (${String(arg.length)} chars) plus the base command (${\n              String(baseCommand.length)\n            } chars) exceeds the max command length (${String(maxCommandLength)}).`\n          )\n        );\n      }\n      batches.push(currentBatch);\n      currentBatch = [arg];\n    } else {\n      currentBatch.push(arg);\n    }\n  }\n  /* v8 ignore start -- Always true after the loop; batchedArgs is non-empty at this point. */\n  if (currentBatch.length > 0) {\n    /* v8 ignore stop */\n    batches.push(currentBatch);\n  }\n\n  return executeBatches(baseCommand, batches, options);\n}\n\n/**\n * Checks if a command part is an {@link ExecArg}.\n *\n * @param part - The command part to check.\n * @returns Whether the part is an ExecArg.\n */\nfunction isExecArg(part: CommandPart): part is ExecArg {\n  return typeof part === 'object' && 'batchedArgs' in part;\n}\n\n/**\n * Spawns a child process via the appropriate shell.\n *\n * On Windows, if the command contains newlines (which `cmd.exe` cannot handle)\n * and the raw args array is available, spawns the process directly without\n * any shell \u2014 passing args via `CreateProcess`, which avoids all quoting issues.\n *\n * On Windows (cmd.exe path), applies `^`-escaping for cmd metacharacters.\n *\n * @param command - The command string to execute.\n * @param cwd - The working directory.\n * @param rawArgs - The original argument array (if available).\n * @returns The spawned child process.\n */\nfunction spawnViaShell(command: string, cwd: string, rawArgs?: string[]): ChildProcessWithoutNullStreams {\n  if (process.platform === 'win32' && command.includes('\\n')) {\n    if (!rawArgs) {\n      throw new Error('Commands containing newlines cannot be executed through cmd.exe on Windows. Pass an argument array instead of a string.');\n    }\n    const [program, ...args] = rawArgs;\n    /* v8 ignore start -- Always truthy; rawArgs comes from the array path which has at least one element. */\n    if (!program) {\n      throw new Error('Command array must not be empty');\n    }\n    /* v8 ignore stop */\n    return spawn(program, args, {\n      cwd,\n      env: CHILD_ENV,\n      stdio: 'pipe'\n    });\n  }\n\n  const shellCommand = process.platform === 'win32' ? cmdEscapeCommandLine(command) : command;\n  return spawn(shellCommand, [], {\n    cwd,\n    env: CHILD_ENV,\n    shell: true,\n    stdio: 'pipe'\n  });\n}\n\n/**\n * Removes a suffix from the end of a string if present.\n *\n * @param str - The string to trim.\n * @param suffix - The suffix to remove.\n * @returns The trimmed string.\n */\nfunction trimEnd(str: string, suffix: string): string {\n  if (str.endsWith(suffix)) {\n    return str.slice(0, -suffix.length);\n  }\n  return str;\n}\n"],
  "mappings": "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",
  "names": ["maxCommandLength", "process"]
}


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

@@ -0,0 +1,108 @@
+/**
+ * @packageDocumentation
+ *
+ * Contains utility functions for executing commands.
+ */
+/**
+ * A command part: either a plain string or an {@link ExecArg} with batched arguments.
+ */
+export type CommandPart = ExecArg | string;
+/**
+ * A command argument that contains a list of args to be batched.
+ * If the expanded command exceeds the platform's max command length,
+ * the batched args are split into sequential executions.
+ */
+export interface ExecArg {
+    /**
+     * The arguments to batch.
+     */
+    batchedArgs: string[];
+}
+/**
+ * Options for {@link exec} that return detailed results.
+ */
+export interface ExecDetailedOptions extends ExecOption {
+    /**
+     * Must be `true` to receive detailed results.
+     */
+    withDetails: true;
+}
+/**
+ * Options for executing a command.
+ */
+export interface ExecOption {
+    /**
+     * A current working folder for the command execution.
+     */
+    readonly cwd?: string;
+    /**
+     * If `true`, suppresses the output of the command.
+     */
+    readonly isQuiet?: boolean;
+    /**
+     * If `true`, ignores the exit code of the command.
+     */
+    readonly shouldIgnoreExitCode?: boolean;
+    /**
+     * If `true`, returns detailed results.
+     */
+    readonly shouldIncludeDetails?: boolean;
+    /**
+     * An input to be passed to the command.
+     */
+    readonly stdin?: string;
+}
+/**
+ * A result of {@link exec}.
+ */
+export interface ExecResult {
+    /**
+     * An exit code of the command. A value of `null` indicates that the process did not exit normally.
+     */
+    exitCode: null | number;
+    /**
+     * A signal that caused the process to be terminated. A value of `null` indicates that no signal was received.
+     */
+    exitSignal: NodeJS.Signals | null;
+    /**
+     * A standard error output from the command.
+     */
+    stderr: string;
+    /**
+     * A standard output from the command.
+     */
+    stdout: string;
+}
+/**
+ * Options for {@link exec} that return only stdout.
+ */
+export interface ExecSimpleOptions extends ExecOption {
+    /**
+     * Must be `false` or omitted to receive only stdout.
+     */
+    withDetails?: false;
+}
+/**
+ * Executes a command.
+ *
+ * @param command - The command to execute. It can be a string or an array of strings.
+ * @param options - The options for the execution.
+ * @returns A {@link Promise} that resolves with the output of the command.
+ */
+export declare function exec(command: CommandPart[] | string, options?: ExecSimpleOptions): Promise<string>;
+/**
+ * Executes a command.
+ *
+ * @param command - The command to execute. It can be a string or an array of strings.
+ * @param options - The options for the execution.
+ * @returns A {@link Promise} that resolves with ExecResult object.
+ */
+export declare function exec(command: CommandPart[] | string, options: ExecDetailedOptions): Promise<ExecResult>;
+/**
+ * Converts an array of command-line arguments into a single command-line string
+ * using the `CommandLineToArgvW` convention.
+ *
+ * @param args - The array of command-line arguments to convert.
+ * @returns A string representing the command-line invocation.
+ */
+export declare function toCommandLine(args: string[]): string;

package/dist/lib/cjs/function-expression.cjs

@@ -0,0 +1,41 @@
+"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 function_expression_exports = {};
+__export(function_expression_exports, {
+  getFunctionExpressionString: () => getFunctionExpressionString
+});
+module.exports = __toCommonJS(function_expression_exports);
+function getFunctionExpressionString(fn) {
+  const fnString = fn.toString();
+  if (FUNCTION_EXPRESSION_RE.test(fnString)) {
+    return fnString;
+  }
+  const asyncMatch = ASYNC_KEYWORD_RE.exec(fnString);
+  if (asyncMatch) {
+    return `async function ${fnString.slice(asyncMatch[0].length)}`;
+  }
+  return `function ${fnString}`;
+}
+const FUNCTION_EXPRESSION_RE = /^(?:function\b|async\b\s*(?:function\b|\()|\()/;
+const ASYNC_KEYWORD_RE = /^async\b\s*/;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getFunctionExpressionString
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/function-expression.d.cts

@@ -0,0 +1,16 @@
+/**
+ * @packageDocumentation
+ *
+ * Converts a function into a string that is a valid function expression.
+ */
+/**
+ * Converts a function into a string that is a valid function expression.
+ *
+ * `Function.prototype.toString()` on a shorthand method like `{ fn() {} }`
+ * returns `"fn() {}"`, which is not a valid expression.
+ * This helper detects that form and prefixes it with `function `.
+ *
+ * @param fn - The function to convert.
+ * @returns A string that is a valid function expression.
+ */
+export declare function getFunctionExpressionString(fn: Function): string;

package/dist/lib/cjs/index.cjs

@@ -0,0 +1,40 @@
+"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 index_exports = {};
+__export(index_exports, {
+  ContextId: () => import_context_id.ContextId,
+  TempVault: () => import_temp_vault.TempVault,
+  evalInObsidian: () => import_obsidian_cli.evalInObsidian,
+  registerVault: () => import_vault_registry.registerVault,
+  unregisterVault: () => import_vault_registry.unregisterVault
+});
+module.exports = __toCommonJS(index_exports);
+var import_context_id = require("./context-id.cjs");
+var import_obsidian_cli = require("./obsidian-cli.cjs");
+var import_temp_vault = require("./temp-vault.cjs");
+var import_vault_registry = require("./vault-registry.cjs");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ContextId,
+  TempVault,
+  evalInObsidian,
+  registerVault,
+  unregisterVault
+});
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vc3JjL2luZGV4LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBwYWNrYWdlRG9jdW1lbnRhdGlvblxuICpcbiAqIENvbnRhaW5zIHRoZSBlbnRyeSBwb2ludCBmb3IgdGhlIGludGVncmF0aW9uIHRlc3RpbmcgbW9kdWxlLlxuICovXG5cbmV4cG9ydCB7IENvbnRleHRJZCB9IGZyb20gJy4vY29udGV4dC1pZC5janMnO1xuZXhwb3J0IHR5cGUgeyBFdmFsSW5PYnNpZGlhblBhcmFtcyB9IGZyb20gJy4vb2JzaWRpYW4tY2xpLmNqcyc7XG5leHBvcnQgeyBldmFsSW5PYnNpZGlhbiB9IGZyb20gJy4vb2JzaWRpYW4tY2xpLmNqcyc7XG5leHBvcnQgdHlwZSB7IFRlbXBWYXVsdFBhcmFtcyB9IGZyb20gJy4vdGVtcC12YXVsdC5janMnO1xuZXhwb3J0IHsgVGVtcFZhdWx0IH0gZnJvbSAnLi90ZW1wLXZhdWx0LmNqcyc7XG5leHBvcnQge1xuICByZWdpc3RlclZhdWx0LFxuICB1bnJlZ2lzdGVyVmF1bHRcbn0gZnJvbSAnLi92YXVsdC1yZWdpc3RyeS5janMnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7O0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBQUE7QUFBQTtBQUFBO0FBTUEsd0JBQTBCO0FBRTFCLDBCQUErQjtBQUUvQix3QkFBMEI7QUFDMUIsNEJBR087IiwKICAibmFtZXMiOiBbXQp9Cg==

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

@@ -0,0 +1,11 @@
+/**
+ * @packageDocumentation
+ *
+ * Contains the entry point for the integration testing module.
+ */
+export { ContextId } from './context-id.cjs';
+export type { EvalInObsidianParams } from './obsidian-cli.cjs';
+export { evalInObsidian } from './obsidian-cli.cjs';
+export type { TempVaultParams } from './temp-vault.cjs';
+export { TempVault } from './temp-vault.cjs';
+export { registerVault, unregisterVault } from './vault-registry.cjs';