obsidian-integration-testing 1.1.2 → 1.2.0

package/README.md

@@ -6,11 +6,7 @@
 [![GitHub release](https://img.shields.io/github/v/release/mnaoumov/obsidian-integration-testing)](https://github.com/mnaoumov/obsidian-integration-testing/releases)
 [![Coverage: 100%](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/mnaoumov/obsidian-integration-testing)
 
-A set of helpers that simplify integration testing of [Obsidian](https://obsidian.md/) plugins against a running Obsidian instance via the [Obsidian CLI](https://obsidian.md/help/cli/).
-
-## Prerequisites
-
-- [Obsidian](https://obsidian.md/) should have CLI enabled.
+A set of helpers that simplify integration testing of [Obsidian](https://obsidian.md/) plugins against a running Obsidian instance.
 
 ## Installation
 
@@ -18,23 +14,23 @@ A set of helpers that simplify integration testing of [Obsidian](https://obsidia
 npm install --save-dev obsidian-integration-testing
 ```
 
-## Usage
-
-### Plugin Vitest setup
+## Quick start
 
-> **This entry point is designed for Obsidian plugin repos only.** It expects your built plugin in `dist/dev` or `dist/build` (whichever has a newer `main.js`), with a `manifest.json` at the root of the chosen folder. The setup creates a temporary vault, copies the build into it, and enables the plugin via the Obsidian CLI.
-
-Add it as a Vitest global setup:
+Add the global setup to your Vitest config. It expects your built plugin in `dist/dev` or `dist/build` (whichever has a newer `main.js`), with a `manifest.json` at the root of the chosen folder. The setup creates a temporary vault, copies the build into it, and enables the plugin.
 
 ```ts
 // vitest.config.ts
+import { defineConfig } from 'vitest/config';
+
 export default defineConfig({
   test: {
-    globalSetup: ['obsidian-integration-testing/obsidian-plugin-vitest-setup']
-  }
+    globalSetup: ['obsidian-integration-testing/obsidian-plugin-vitest-setup'],
+  },
 });
 ```
 
+By default this uses the **`CLI` transport** (requires `CLI` enabled in Obsidian settings). See [Transport modes](#transport-modes) for alternatives.
+
 ### Write integration tests
 
 Use `evalInObsidian()` to run code inside the Obsidian process. The `vaultPath` is optional — it defaults to `process.cwd()`:
@@ -239,7 +235,7 @@ describe('my-plugin', () => {
 >
 > **Parallelism:**
 >
-> The Obsidian CLI does not support executing multiple commands concurrently. If your test runner launches tests in parallel, CLI calls may collide and produce flaky failures. Disable file-level parallelism in your Vitest config:
+> The Obsidian `CLI` does not support executing multiple commands concurrently. If your test runner launches tests in parallel, `CLI` calls may collide and produce flaky failures. Disable file-level parallelism in your Vitest config:
 >
 > ```ts
 > // vitest.config.ts
@@ -302,6 +298,234 @@ const title2 = await evalInObsidian({
 });
 ```
 
+### Transport modes
+
+The transport determines how the library communicates with Obsidian. Configure it via `environmentOptions.obsidianTransport` in your vitest project config:
+
+| Type                       | Platform | Mechanism                                                   |
+|----------------------------|----------|-------------------------------------------------------------|
+| `obsidian-cli` (default)   | Desktop  | Obsidian `Command Line Interface` (`CLI`) (`obsidian eval`) |
+| `obsidian-cdp`             | Desktop  | Obsidian `Chrome DevTools Protocol` (`CDP`)                 |
+| `obsidian-android-appium`  | Mobile   | Obsidian Android Appium WebView JS injection                |
+
+#### `CLI` transport (default)
+
+Shells out to the Obsidian `Command Line Interface` (`CLI`) binary for each eval call. This is the default when no `obsidianTransport` is configured.
+
+**Setup:**
+
+1. [Install the Obsidian `CLI`](https://obsidian.md/help/cli#Install+Obsidian+CLI).
+2. Enable `CLI` in Obsidian: `Settings → General → Developer tools → Enable CLI`.
+
+No additional vitest configuration needed — `CLI` is the default transport.
+
+#### `CDP` transport
+
+Connects via WebSocket to Obsidian `Chrome DevTools Protocol` (`CDP`) endpoint. No `CLI` binary needed, no `CLI enabled` setting required, and lower overhead per eval.
+
+**Setup:**
+
+1. Launch Obsidian with the `--remote-debugging-port` flag:
+
+   ```powershell
+   # Windows (PowerShell)
+   & "$env:LOCALAPPDATA\Programs\Obsidian\Obsidian.exe" --remote-debugging-port=8315
+   ```
+
+   ```cmd
+   # Windows (CMD)
+   "%LOCALAPPDATA%\Programs\Obsidian\Obsidian.exe" --remote-debugging-port=8315
+   ```
+
+   ```bash
+   # macOS
+   /Applications/Obsidian.app/Contents/MacOS/Obsidian --remote-debugging-port=8315
+
+   # Linux
+   obsidian --remote-debugging-port=8315
+   ```
+
+2. Ensure [`Node.js`](https://nodejs.org/) 22+ is installed (uses built-in `WebSocket` and `fetch` globals).
+3. Configure vitest:
+
+   ```ts
+   // vitest.config.ts
+   export default defineConfig({
+     test: {
+       fileParallelism: false,
+       globalSetup: ['obsidian-integration-testing/obsidian-plugin-vitest-setup'],
+       environmentOptions: {
+         obsidianTransport: { type: 'obsidian-cdp' },
+       },
+     },
+   });
+   ```
+
+   Optional configuration:
+
+   ```ts
+   environmentOptions: {
+     obsidianTransport: {
+       type: 'obsidian-cdp',
+
+       // default values can be omitted
+       host: 'localhost',
+       port: 8315,
+       commandTimeoutInMilliseconds: 30000
+     },
+   }
+   ```
+
+#### Obsidian Android Appium transport
+
+Runs tests against Obsidian Mobile on an Android emulator or real device via Appium WebView injection.
+
+**Setup:**
+
+1. Install [Android Studio](https://developer.android.com/studio), which includes the Android SDK and `adb` command-line tools
+
+2. Set up a device — either an emulator or a real device:
+
+   **Emulator:**
+
+   - Open Android Studio → Device Manager → Create Virtual Device
+   - Select a phone profile (e.g. Pixel 7) and a system image (e.g. API 34)
+   - Start the emulator
+
+   **Real device:**
+
+   - Enable Developer Options: Settings → About phone → tap "Build number" 7 times
+   - Enable USB Debugging: Settings → Developer options → USB debugging
+   - Connect via USB and accept the debugging prompt on the device
+   - Verify the device is detected:
+
+     ```bash
+     adb devices
+     ```
+
+3. Install [Obsidian](https://obsidian.md/download) on the device (via Play Store or APK sideload) and grant storage permission — either via the app's permission prompt or via `adb`:
+
+   ```bash
+   adb shell appops set md.obsidian MANAGE_EXTERNAL_STORAGE allow
+   ```
+
+4. Install [Appium](https://appium.io/) and the [UiAutomator2 driver](https://github.com/appium/appium-uiautomator2-driver):
+
+   ```bash
+   npm install -g appium
+   appium driver install uiautomator2
+   ```
+
+5. Start the Appium server:
+
+   ```bash
+   appium
+   ```
+
+6. Find the device ID (use the value from the `adb devices` output):
+
+   ```bash
+   adb devices
+   # Example output:
+   # emulator-5554   device
+   # R5CR1234567     device   ← real device
+   ```
+
+7. Configure vitest:
+
+   ```ts
+   // vitest.config.ts
+   export default defineConfig({
+     test: {
+       fileParallelism: false,
+       globalSetup: ['obsidian-integration-testing/obsidian-plugin-vitest-setup'],
+       environmentOptions: {
+         obsidianTransport: {
+           type: 'obsidian-android-appium',
+           appiumUrl: 'http://localhost:4723',
+           deviceId: 'emulator-5554',
+         },
+       },
+     },
+   });
+   ```
+
+> [!NOTE]
+>
+> Plugins with `isDesktopOnly: true` in `manifest.json` automatically reject Android tests.
+
+### Running multiple platforms
+
+Use vitest projects to run the same tests on multiple platforms:
+
+```ts
+// vitest.config.ts
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    projects: [
+      {
+        test: {
+          name: 'integration-tests-desktop-cli',
+          fileParallelism: false,
+          globalSetup: ['obsidian-integration-testing/obsidian-plugin-vitest-setup'],
+          include: ['src/**/*.integration.test.ts'],
+          exclude: ['src/**/*.android.integration.test.ts'],
+          // default, can be omitted
+          environmentOptions: {
+            obsidianTransport: { type: 'obsidian-cdp' },
+          },
+        },
+      },
+      {
+        test: {
+          name: 'integration-tests-desktop-cdp',
+          fileParallelism: false,
+          globalSetup: ['obsidian-integration-testing/obsidian-plugin-vitest-setup'],
+          include: ['src/**/*.integration.test.ts'],
+          exclude: ['src/**/*.android.integration.test.ts'],
+          environmentOptions: {
+            obsidianTransport: { type: 'obsidian-cdp' },
+          },
+        },
+      },
+      {
+        test: {
+          name: 'integration-tests-android-appium',
+          fileParallelism: false,
+          globalSetup: ['obsidian-integration-testing/obsidian-plugin-vitest-setup'],
+          include: ['src/**/*.android.integration.test.ts'],
+          environmentOptions: {
+            obsidianTransport: {
+              type: 'obsidian-android-appium',
+              appiumUrl: 'http://localhost:4723',
+              deviceId: 'emulator-5554',
+            },
+          },
+        },
+      },
+    ],
+  },
+});
+```
+
+Run specific platforms:
+
+```bash
+# All platforms
+npx vitest run
+
+# Desktop CLI only
+npx vitest run --project integration-tests-desktop-cli
+
+# Desktop CDP only
+npx vitest run --project integration-tests-desktop-cdp
+
+# Android only (requires Appium + emulator running)
+npx vitest run --project integration-tests-android-appium
+```
+
 ## Support
 
 <!-- markdownlint-disable MD033 -->

package/dist/lib/cjs/context-id.cjs

@@ -80,4 +80,4 @@ class ContextId {
 0 && (module.exports = {
   ContextId
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/context-id.d.cts

@@ -1,5 +1,5 @@
 /**
- * @packageDocumentation
+ * @file
  *
  * Typed context identifiers for persisting non-serializable values
  * across {@link evalInObsidian} calls.

package/dist/lib/cjs/enable-plugin.cjs

@@ -0,0 +1,54 @@
+"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 enable_plugin_exports = {};
+__export(enable_plugin_exports, {
+  enablePluginWithErrorCapture: () => enablePluginWithErrorCapture
+});
+module.exports = __toCommonJS(enable_plugin_exports);
+async function enablePluginWithErrorCapture({ app, pluginId }) {
+  if (!app.plugins.isEnabled()) {
+    await app.plugins.setEnable(true);
+  }
+  let errorMessage;
+  const origLoadPlugin = app.plugins.loadPlugin;
+  app.plugins.loadPlugin = async function loadPlugin(id, isUserEnabled) {
+    try {
+      const result = await origLoadPlugin.call(this, id, isUserEnabled);
+      errorMessage = void 0;
+      return result;
+    } catch (error) {
+      errorMessage = error instanceof Error ? error.message : String(error);
+      throw error;
+    }
+  };
+  try {
+    await app.plugins.enablePluginAndSave(pluginId);
+  } finally {
+    app.plugins.loadPlugin = origLoadPlugin;
+  }
+  return {
+    errorMessage,
+    isEnabled: app.plugins.enabledPlugins.has(pluginId)
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  enablePluginWithErrorCapture
+});
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/cjs/enable-plugin.d.cts

@@ -0,0 +1,44 @@
+/**
+ * @file
+ *
+ * Shared helper for enabling an Obsidian plugin with error capture.
+ * Used by both the global setup and integration tests.
+ */
+import type { CommonArgs } from './obsidian-cli.cjs';
+/**
+ * Parameters for {@link enablePluginWithErrorCapture}.
+ */
+export interface EnablePluginParams {
+    /**
+     * The ID of the plugin to enable.
+     */
+    pluginId: string;
+}
+/**
+ * Result of enabling a plugin with error capture.
+ */
+export interface EnablePluginResult {
+    /**
+     * The error message if the plugin failed to load, or `undefined` if it loaded successfully.
+     */
+    errorMessage: string | undefined;
+    /**
+     * Whether the plugin is in the enabled set after the enable attempt.
+     */
+    isEnabled: boolean;
+}
+/**
+ * Enables a plugin inside Obsidian and captures any load error.
+ *
+ * Monkey-patches `app.plugins.loadPlugin` to intercept errors before
+ * Obsidian's `enablePlugin` try-catch swallows them. The original method
+ * is always restored in a `finally` block.
+ *
+ * Designed to be passed as the `fn` argument to {@link evalInObsidian}.
+ *
+ * @param args - The common args plus the plugin ID.
+ * @param args.app - The Obsidian app instance.
+ * @param args.pluginId - The ID of the plugin to enable.
+ * @returns The enable result with error message and enabled status.
+ */
+export declare function enablePluginWithErrorCapture({ app, pluginId }: CommonArgs & EnablePluginParams): Promise<EnablePluginResult>;

package/dist/lib/cjs/exec.cjs

@@ -67,7 +67,7 @@ function execString(command, options = {}, rawArgs) {
     cwd = import_node_process.default.cwd(),
     isQuiet: quiet = false,
     shouldIgnoreExitCode: ignoreExitCode = false,
-    shouldIncludeDetails: withDetails = false,
+    shouldIncludeDetails = false,
     stdin = ""
   } = options;
   return new Promise((resolve, reject) => {
@@ -100,7 +100,7 @@ function execString(command, options = {}, rawArgs) {
 ${stderr}`));
         return;
       }
-      if (!withDetails) {
+      if (!shouldIncludeDetails) {
         resolve(stdout);
         return;
       }
@@ -116,7 +116,7 @@ ${stderr}`));
         reject(err);
         return;
       }
-      if (!withDetails) {
+      if (!shouldIncludeDetails) {
         resolve(stdout);
         return;
       }
@@ -264,4 +264,4 @@ function trimEnd(str, suffix) {
   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"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/exec.ts"],
  "sourcesContent": ["/**\n * @file\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  readonly batchedArgs: readonly 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  readonly shouldIncludeDetails: 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  readonly 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  readonly exitSignal: NodeJS.Signals | null;\n\n  /**\n   * A standard error output from the command.\n   */\n  readonly stderr: string;\n\n  /**\n   * A standard output from the command.\n   */\n  readonly 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  readonly shouldIncludeDetails?: 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 = 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 (!shouldIncludeDetails) {\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 (!shouldIncludeDetails) {\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

@@ -1,5 +1,5 @@
 /**
- * @packageDocumentation
+ * @file
  *
  * Contains utility functions for executing commands.
  */
@@ -16,7 +16,7 @@ export interface ExecArg {
     /**
      * The arguments to batch.
      */
-    batchedArgs: string[];
+    readonly batchedArgs: readonly string[];
 }
 /**
  * Options for {@link exec} that return detailed results.
@@ -25,7 +25,7 @@ export interface ExecDetailedOptions extends ExecOption {
     /**
      * Must be `true` to receive detailed results.
      */
-    withDetails: true;
+    readonly shouldIncludeDetails: true;
 }
 /**
  * Options for executing a command.
@@ -59,19 +59,19 @@ export interface ExecResult {
     /**
      * An exit code of the command. A value of `null` indicates that the process did not exit normally.
      */
-    exitCode: null | number;
+    readonly 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;
+    readonly exitSignal: NodeJS.Signals | null;
     /**
      * A standard error output from the command.
      */
-    stderr: string;
+    readonly stderr: string;
     /**
      * A standard output from the command.
      */
-    stdout: string;
+    readonly stdout: string;
 }
 /**
  * Options for {@link exec} that return only stdout.
@@ -80,7 +80,7 @@ export interface ExecSimpleOptions extends ExecOption {
     /**
      * Must be `false` or omitted to receive only stdout.
      */
-    withDetails?: false;
+    readonly shouldIncludeDetails?: false;
 }
 /**
  * Executes a command.

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

@@ -38,4 +38,4 @@ const ASYNC_KEYWORD_RE = /^async\b\s*/;
 0 && (module.exports = {
   getFunctionExpressionString
 });
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,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