@sandro-sikic/maker 1.0.10 → 1.0.11

package/docs/API.md

@@ -21,13 +21,17 @@ Exits with code 1 if not running in an interactive terminal (TTY).
 Execute shell commands with streaming output.
 
 ```javascript
-const result = await run('npm install', { maxLines: 10000 });
+const result = await run('npm install', {
+	maxLines: 10000,
+	cwd: process.cwd(),
+});
 ```
 
 **Parameters:**
 
 - `command` - Shell command string (required)
-- `opts.maxLines` - Max output lines to capture (default: 10000)
+- `opts.maxLines` - Max output lines to capture (default: 10000). This option is used only for capturing output and is not forwarded to the spawned process.
+- `opts` (other properties) - Any additional top-level properties are forwarded directly to `child_process.spawn` (e.g. `cwd`, `env`, `stdio`).
 
 **Returns:**
 

package/index.d.ts

@@ -11,7 +11,7 @@ export type RunResult = {
 
 export function run(
 	command: string,
-	opts?: { maxLines?: number },
+	opts?: Partial<import('child_process').SpawnOptions> & { maxLines?: number },
 ): Promise<RunResult>;
 
 export function onExit(cb: () => void | Promise<void>): () => void;

package/index.js

@@ -18,9 +18,10 @@ function init() {
  * task; if you `await run(...)` (use inside an async function) the caller will wait for completion
  * and the call behaves like a foreground task.
  *
- * @param {string} command - Shell command to execute (will be run with `shell: true`).
+ * @param {string} command - Shell command to execute.
  * @param {Object} [opts]
- * @param {number} [opts.maxLines=10000] - Maximum number of lines to retain in captured output.
+ * @param {number} [opts.maxLines=10000] - Maximum number of lines to retain in captured output. (capture-only; not forwarded to the spawned process)
+ * @param {Object} [opts] - Options forwarded directly to `child_process.spawn` (e.g. `cwd`, `env`, `stdio`).
  * @returns {Promise<{output:string, stdout:string, stderr:string, code:number|null, isError:boolean, error:Error|null}>}
  */
 async function run(command, opts = {}) {
@@ -28,10 +29,19 @@ async function run(command, opts = {}) {
 		throw new TypeError('run() requires a non-empty string command');
 	}
 
-	const { maxLines = 10000 } = opts;
+	// extract maxLines (used for capturing) and forward the rest of opts directly to spawn
+	const { maxLines = 10000, ...forwardedOpts } = opts;
+
 	// import spawn at runtime so test mocks (vi.mock) take effect per-test
 	const { spawn } = await import('child_process');
 
+	// Merge defaults with the caller-provided options. Caller options are forwarded
+	// directly to spawn; `maxLines` is used only for output capture (not forwarded).
+	const spawnOpts = Object.assign(
+		{ shell: true, stdio: 'pipe' },
+		forwardedOpts,
+	);
+
 	function trimToLastNLines(s, n) {
 		if (!s) return s;
 		// remove trailing newlines for accurate line counting
@@ -44,7 +54,7 @@ async function run(command, opts = {}) {
 	}
 
 	return new Promise((resolve) => {
-		const child = spawn(command, { shell: true, stdio: 'pipe' });
+		const child = spawn(command, spawnOpts);
 
 		let stdout = '';
 		let stderr = '';

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@sandro-sikic/maker",
-	"version": "1.0.10",
+	"version": "1.0.11",
 	"type": "module",
 	"description": "A lightweight library for building interactive command-line tools with prompts, command execution, spinners, and graceful shutdown handling",
 	"main": "index.js",

package/test/index.test.js

@@ -405,6 +405,63 @@ describe('run() - additional edge cases', () => {
 		vi.resetModules();
 	});
 
+	it('forwards opts directly to spawn (no alias)', async () => {
+		vi.resetModules();
+		let captured;
+		vi.doMock('child_process', () => ({
+			spawn: (cmd, spawnOpts) => {
+				captured = spawnOpts;
+				const child = {
+					stdout: { on: () => {} },
+					stderr: { on: () => {} },
+					on: (ev, cb) => {
+						if (ev === 'close') cb(0);
+					},
+				};
+				return child;
+			},
+		}));
+		const { run: mockedRun } = await import('../index.js');
+		const res = await mockedRun('anything', {
+			cwd: '/tmp',
+			env: { FOO: 'bar' },
+		});
+		expect(captured.cwd).toBe('/tmp');
+		expect(captured.env).toEqual(expect.objectContaining({ FOO: 'bar' }));
+		expect(captured.shell).toBe(true);
+		expect(captured.stdio).toBe('pipe');
+		expect(res.code).toBe(0);
+		vi.resetModules();
+	});
+
+	it('forwards top-level spawn options (maxLines is capture-only)', async () => {
+		vi.resetModules();
+		let captured;
+		vi.doMock('child_process', () => ({
+			spawn: (cmd, spawnOpts) => {
+				captured = spawnOpts;
+				const child = {
+					stdout: { on: () => {} },
+					stderr: { on: () => {} },
+					on: (ev, cb) => {
+						if (ev === 'close') cb(0);
+					},
+				};
+				return child;
+			},
+		}));
+		const { run: mockedRun } = await import('../index.js');
+		const res = await mockedRun('anything', {
+			cwd: '/cwd',
+			maxLines: 5,
+			shell: false,
+		});
+		expect(captured.cwd).toBe('/cwd');
+		expect(captured.maxLines).toBeUndefined();
+		expect(captured.shell).toBe(false);
+		expect(res.code).toBe(0);
+		vi.resetModules();
+	});
 	it('handles multiple data chunks correctly', async () => {
 		vi.resetModules();
 		vi.doMock('child_process', () => ({