dollar-shell 1.0.0

package/LICENSE

@@ -0,0 +1,11 @@
+Copyright 2005-2024 Eugene Lazutkin
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its contributors may be used to endorse or promote products derived from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,206 @@
+# dollar-shell [![NPM version][npm-image]][npm-url]
+
+[npm-image]:      https://img.shields.io/npm/v/dollar-shell.svg
+[npm-url]:        https://npmjs.org/package/dollar-shell
+
+`dollar-shell` is a micro-library for running shell commands and using them in streams with ease in Node, Deno, Bun. It is a tiny, simple, no dependency module with TypeScript typings.
+
+The idea is to run OS/shell commands and/or use them in stream pipelines as sources, sinks,
+and transformation steps using [web streams](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API).
+It can be used together with [stream-chain](https://npmjs.org/package/stream-chain) and
+[stream-json](https://npmjs.org/package/stream-json) to create efficient pipelines.
+It helps using shell commands in utilities written in JavaScript/TypeScript running with
+Node, Deno, or Bun.
+
+Available components:
+
+* `$` — spawn a process using a template string.
+  * `$.from` — spawn a process and use its `stdout` as a source stream.
+  * `$.to` — spawn a process and use its `stdin` as a sink stream.
+  * `$.io` AKA `$.through` — spawn a process and use it as
+  a transformation step in our pipeline.
+* `$sh` — run a shell command using a template string.
+  * `$sh.from` — run a shell command and use its `stdout` as a source stream.
+  * `$sh.to` — run a shell command and use its `stdin` as a sink stream.
+  * `$sh.io` AKA `$sh.through` — run a shell command and use it as
+  a transformation step in our pipeline.
+* Advanced components:
+  * `spawn()` — spawn a process with advanced ways to configure and control it.
+  * `$$` — spawn a process using a template string based on `spawn()`.
+  * `shell()` — a helper to spawn a shell command using a template string based on `spawn()`.
+  * Various helpers for them.
+
+## Introduction
+
+Run a command:
+
+```js
+import $ from 'dollar-shell';
+
+const result = await $`echo hello`;
+console.log(result.code, result.signal, result.killed);
+```
+
+Run a shell command:
+
+```js
+import {$sh} from 'dollar-shell';
+
+const result = await $sh`ls .`;
+console.log(result.code, result.signal, result.killed);
+```
+
+Run a shell command (an alias or a function) and show its result:
+
+```js
+import {$sh} from 'dollar-shell';
+
+// custom alias that prints `stdout` and runs an interactive shell
+const $p = $sh({shellArgs: ['-ic'], stdout: 'inherit'});
+
+const result = await $p`nvm ls`;
+// prints to the console the result of the command
+```
+
+Run a pipeline:
+
+```js
+import $ from 'dollar-shell';
+import chain from 'stream-chain';
+import lines from 'stream-chain/utils/lines.js';
+
+chain([
+  $.from`ls -l .`,
+  $.io`grep LICENSE`,
+  $.io`wc`
+  lines(),
+  line => console.log(line)
+]);
+```
+
+## Installation
+
+```bash
+npm i --save dollar-shell
+```
+
+## Documentation
+
+Below is the documentation for the main components: `spawn()`, `$$`, `$` and `$sh`.
+Additional information can be found in the [wiki](https://github.com/uhop/dollar-shell/wiki).
+
+### `spawn()`
+
+Spawn a process with advanced ways to configure and control it.
+
+The signature: `spawn(command, options)`
+
+Arguments:
+
+* `command` — an array of strings. The first element is the command to run. The rest are its arguments.
+* `options` — an optional object with options to configure the process:
+  * `cwd` — the optional current working directory as a string. Defaults to `process.cwd()`.
+  * `env` — the optional environment variables as an object (key-value pairs). Defaults to `process.env`.
+  * `stdin` — the optional source stream. Defaults to `null`.
+  * `stdout` — the optional destination stream. Defaults to `null`.
+  * `stderr` — the optional destination stream. Defaults to `null`.
+
+`stdin`, `stdout` and `stderr` can be a string (one of `'inherit'`, `'ignore'`, `'pipe'` or `'piped'`)
+or `null`. The latter is equivalent to `'ignore'`. `'piped'` is an alias of `'pipe'`:
+
+* `'inherit'` — inherit streams from the parent process. For output steams (`stdout` and `stderr`),
+it means that they will be piped to the same target, e.g., the console.
+* `'ignore'` — the stream is ignored.
+* `'pipe'` — the stream is available for reading or writing.
+
+Returns a sub-process object with the following properties:
+
+* `command` — the command that was run as an array of strings.
+* `options` — the options that were passed to `spawn()`.
+* `exited` — a promise that resolves to the exit code of the process. It is used to wait for the process to exit.
+* `finished` — a boolean. It is `true` when the process has finished and `false` otherwise.
+* `killed` — a boolean. It is `true` when the process has been killed and `false` otherwise.
+* `exitCode` — the exit code of the process as a number. It is `null` if the process hasn't exited yet.
+* `signalCode` — the signal code of the process as a string. It is `null` if the process hasn't exited yet.
+* `stdin` — the source stream of the process if `options.stdin` was `'pipe'`. It is `null` otherwise.
+* `stdout` — the destination stream of the process if `options.stdout` was `'pipe'`. It is `null` otherwise.
+* `stderr` — the destination stream of the process if `options.stderr` was `'pipe'`. It is `null` otherwise.
+* `kill()` — kills the process. `killed` will be `true` as soon as the process has been killed. It can be used to pipe the input and output. See `spawn()`'s `stdin` and `stdout` above for more details.
+
+**Important:** all streams are exposed as [web streams](https://developer.mozilla.org/en-US/docs/Web/API/Streams_API).
+
+#### Examples
+
+```js
+import {spawn} from 'dollar-shell';
+
+const sp = spawn(['sleep', '5'])
+await new Promise(resolve => setTimeout(resolve, 1000));
+sp.kill();
+await sp.exited;
+
+sp.finished === true;
+sp.killed === true;
+```
+
+### `$$`
+
+The same as `spawn()`, but it returns a tag function that can be used as a template string.
+
+The signatures:
+
+```js
+const sp1 = $$`ls -l ${myFile}`;  // runs a command the defaults
+
+const sp2 = $$(options)`ls -l .`; // runs a command with custom spawn options
+
+const $tag = $$(options);         // returns a tag function
+const sp3 = $tag`ls -l .`;        // runs a command with custom spawn options
+```
+
+This function is effectively a helper for `spawn()`. It parses the template string
+into an array of string arguments. Each inserted value is included
+as a separate argument if it was surrounded by whitespaces.
+
+The second signature is used to run a command with custom spawn options. See `spawn()` above for more details.
+
+The first signature returns a sub-process object. See `spawn()` for more details. The second signature
+returns a tag function that can be used as a template string.
+
+### `$`
+
+This function is similar to `$$` but it uses different default spawn options related to streams and
+different (simpler) return values:
+
+* `$` — all streams are ignored. It returns a promise that resolves to an object with the following properties:
+  * `code` — the exit code of the process. See `spawn()`'s `exitCode` above for more details.
+  * `signal` — the signal code of the process. See `spawn()`'s `signalCode` above for more details.
+  * `killed` — a boolean. It is `true` when the process has been killed and `false` otherwise. See `spawn()`'s `killed` above for more details.
+* `$.from` — sets `stdout` to `pipe` and returns `stdout` of the process. It can be used to process the output. See `spawn()`'s `stdout` above for more details.
+* `$.to` — sets `stdin` to `pipe` and returns `stdin` of the process. It can be used to pipe the input. See `spawn()`'s `stdin` above for more details.
+* `$.io` AKA `$.through` — sets `stdin` and `stdout` to `pipe` and returns `stdin` and `stdout` of the process as a `{readable, writable}` pair. It can be used to create a pipeline where an external process can be used as a transform step.
+
+### `$sh`
+
+This function mirrors `$` but runs the command with the shell. It takes an options object that extends
+the spawn options with the following properties:
+
+* `shellPath` — the path to the shell.
+  * On Unix-like systems it defaults to the value of
+the `SHELL` environment variable if specified. Otherwise it is `'/bin/sh'` or `'/system/bin/sh'` on Android.
+  * On Windows it defaults to the value of the `ComSpec` environment variable if specified.
+Otherwise it is `cmd.exe`.
+* `shellArgs` — an array of strings that are passed to the shell as arguments.
+  * On Unix-like systems it defaults to `['-c']`.
+  * On Windows it defaults to `['/d', '/s', '/c']` for `cmd.exe`
+or `['-e']` for `pwsh.exe` or `powershell.exe`.
+
+The rest is identical to `$`: `$sh`, `$sh.from`, `$sh.to` and `$sh.io`/`$sh.through`.
+
+## License
+
+BSD-3-Clause
+
+## Release History
+
+- 1.0.0 *The initial release.*

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "dollar-shell",
+  "description": "Run shell commands and use them in streams with ease in Node, Deno, Bun. Tiny, simple, no dependency package.",
+  "version": "1.0.0",
+  "type": "module",
+  "main": "./src/index.js",
+  "types": "./src/index.d.ts",
+  "exports": {
+    ".": "./src/index.js",
+    "./*": "./src/*"
+  },
+  "scripts": {
+    "test": "tape6 --flags FO",
+    "ts-test": "tsc --noEmit"
+  },
+  "files": [
+    "/src",
+    "LICENSE",
+    "README.md"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/uhop/list-toolkit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/uhop/list-toolkit/issues"
+  },
+  "homepage": "https://github.com/uhop/list-toolkit#readme",
+  "keywords": [
+    "shell",
+    "spawn",
+    "$",
+    "dollar",
+    "stream"
+  ],
+  "author": "Eugene Lazutkin <eugene.lazutkin@gmail.com> (http://www.lazutkin.com/)",
+  "funding": "https://github.com/sponsors/uhop",
+  "license": "BSD-3-Clause",
+  "devDependencies": {
+    "tape-six": "^0.9.6",
+    "typescript": "^5.5.4"
+  },
+  "tape6": {
+    "tests": [
+      "/tests/test-*.*js"
+    ]
+  }
+}

package/src/bq-shell.js

@@ -0,0 +1,35 @@
+'use strict';
+
+import {isRawValue, getRawValue, verifyStrings} from './utils.js';
+
+const impl =
+  (shellEscape, shell, options) =>
+  (strings, ...args) => {
+    const result = [];
+
+    for (let i = 0; i < strings.length; i++) {
+      // process a string
+      result.push(strings[i]);
+
+      // process an argument
+      if (i >= args.length) continue;
+      if (isRawValue(args[i])) {
+        const arg = String(getRawValue(args[i]));
+        arg && result.push(arg);
+      } else {
+        const arg = String(args[i]);
+        arg && result.push(shellEscape(arg, options, !i && /^\s*$/.test(strings[i])));
+      }
+    }
+
+    return shell(result.join(''), options);
+  };
+
+const bqShell =
+  (shellEscape, shell, options = {}) =>
+  (strings, ...args) => {
+    if (verifyStrings(strings)) return impl(shellEscape, shell, options)(strings, ...args);
+    return bqShell(shellEscape, shell, {...options, ...strings});
+  };
+
+export default bqShell;

package/src/bq-spawn.js

@@ -0,0 +1,65 @@
+'use strict';
+
+import {verifyStrings, isRawValue, getRawValue} from './utils.js';
+
+const impl =
+  (spawn, options) =>
+  (strings, ...args) => {
+    const result = [];
+
+    let previousSpace = true;
+    for (let i = 0; i < strings.length; i++) {
+      // process a string
+
+      let string = strings[i];
+      previousSpace ||= /^\s/.test(string);
+      if (previousSpace) string = string.trimStart();
+      const lastSpace = /\s$/.test(string);
+      if (lastSpace) string = string.trimEnd();
+
+      let parts = string.split(/\s+/g).filter(part => part);
+      if (parts.length) {
+        if (!previousSpace) {
+          if (result.length) {
+            result[result.length - 1] += parts[0];
+          } else {
+            result.push(parts[0]);
+          }
+          parts = parts.slice(1);
+        }
+        result.push(...parts);
+        previousSpace = lastSpace;
+      } else {
+        previousSpace ||= lastSpace;
+      }
+
+      // process an argument
+
+      if (i >= args.length) continue;
+
+      const arg = String(isRawValue(args[i]) ? getRawValue(args[i]) : args[i]);
+      if (!arg) continue;
+
+      if (previousSpace) {
+        result.push(arg);
+      } else {
+        if (result.length) {
+          result[result.length - 1] += arg;
+        } else {
+          result.push(arg);
+        }
+      }
+      previousSpace = false;
+    }
+
+    return spawn(result, options);
+  };
+
+const bqSpawn =
+  (spawn, options = {}) =>
+  (strings, ...args) => {
+    if (verifyStrings(strings)) return impl(spawn, options)(strings, ...args);
+    return bqSpawn(spawn, {...options, ...strings});
+  };
+
+export default bqSpawn;

package/src/index.d.ts

@@ -0,0 +1,88 @@
+export type SpawnStreamState = 'pipe' | 'ignore' | 'inherit' | 'piped' | null;
+
+export interface SpawnOptions {
+  cwd?: string;
+  env?: {[key: string]: string | undefined};
+  stdin?: SpawnStreamState;
+  stdout?: SpawnStreamState;
+  stderr?: SpawnStreamState;
+}
+
+export interface Subprocess<R = string> {
+  readonly command: string[];
+  readonly options: SpawnOptions | undefined;
+  readonly exited: Promise<number>;
+  readonly finished: boolean;
+  readonly killed: boolean;
+  readonly exitCode: number | null;
+  readonly signalCode: string | null;
+  readonly stdin: WritableStream<R> | null;
+  readonly stdout: ReadableStream<R> | null;
+  readonly stderr: ReadableStream<R> | null;
+  kill(): void;
+}
+
+export declare function spawn(command: string[], options?: SpawnOptions): Subprocess;
+
+export declare function cwd(): string;
+export declare function currentExecPath(): string;
+export declare const runFileArgs: string[];
+
+export declare function raw(value: unknown): object;
+export declare function winCmdEscape(value: unknown): object | string;
+
+export interface ShellEscapeOptions {
+  shellPath?: string;
+}
+
+export declare function shellEscape(s: {toString(): string}, options?: ShellEscapeOptions): string;
+
+export declare function currentShellPath(): string;
+export declare function buildShellCommand(shell: string | undefined, args: string[] | undefined, command: string): string[];
+
+type Backticks<R> = (strings: TemplateStringsArray, ...args: unknown[]) => R;
+
+interface Dollar<R, O = SpawnOptions> extends Backticks<R> {
+  (options: O): Dollar<R, O>;
+}
+
+export declare const $$: Dollar<Subprocess>;
+
+export interface DollarResult {
+  code: number | null;
+  signal: string | null;
+  killed: boolean;
+}
+
+interface DuplexPair<R = string> {
+  readable: ReadableStream<R>;
+  writable: WritableStream<R>;
+}
+
+interface DollarImpl<R = string> extends Dollar<Promise<DollarResult>> {
+  from: Dollar<ReadableStream<R>>;
+  to: Dollar<WritableStream<R>>;
+  through: Dollar<DuplexPair<R>>;
+  io: Dollar<DuplexPair<R>>;
+}
+
+export declare const $: DollarImpl;
+
+export interface ShellOptions extends SpawnOptions {
+  shellPath?: string;
+  shellArgs?: string[];
+}
+
+export declare const shell: Dollar<Subprocess, ShellOptions>;
+export declare const sh = shell;
+
+interface ShellImpl<R = string> extends Dollar<Promise<DollarResult>, ShellOptions> {
+  from: Dollar<ReadableStream<R>, ShellOptions>;
+  to: Dollar<WritableStream<R>, ShellOptions>;
+  through: Dollar<DuplexPair<R>, ShellOptions>;
+  io: Dollar<DuplexPair<R>, ShellOptions>;
+}
+
+export declare const $sh: ShellImpl;
+
+export default $;

package/src/index.js

@@ -0,0 +1,89 @@
+// @ts-self-types="./index.d.ts"
+
+'use strict';
+
+// load dependencies
+
+import {isWindows, raw, winCmdEscape} from './utils.js';
+
+import bqSpawn from './bq-spawn.js';
+import bqShell from './bq-shell.js';
+
+export {isWindows, raw, winCmdEscape};
+
+let modSpawn;
+if (typeof Deno !== 'undefined') {
+  modSpawn = await import('./spawn/deno.js');
+} else if (typeof Bun !== 'undefined') {
+  modSpawn = await import('./spawn/bun.js');
+} else {
+  modSpawn = await import('./spawn/node.js');
+}
+export const {spawn, cwd, currentExecPath, runFileArgs} = modSpawn;
+
+let modShell;
+if (isWindows) {
+  modShell = await import('./shell/windows.js');
+} else {
+  modShell = await import('./shell/unix.js');
+}
+export const {shellEscape, currentShellPath, buildShellCommand} = modShell;
+
+// define spawn functions
+
+export const $$ = bqSpawn(spawn);
+
+export const $ = bqSpawn((command, options) => {
+  const sp = spawn(command, options);
+  return sp.exited.then(() => ({code: sp.exitCode, signal: sp.signalCode, killed: sp.killed}));
+});
+
+const fromProcess = bqSpawn((command, options) => {
+  const sp = spawn(command, Object.assign({}, options, {stdout: 'pipe'}));
+  return sp.stdout;
+});
+
+const toProcess = bqSpawn((command, options) => {
+  const sp = spawn(command, Object.assign({}, options, {stdin: 'pipe'}));
+  return sp.stdin;
+});
+
+const throughProcess = bqSpawn((command, options) => {
+  const sp = spawn(command, Object.assign({}, options, {stdin: 'pipe', stdout: 'pipe'}));
+  return {readable: sp.stdout, writable: sp.stdin};
+});
+
+$.from = fromProcess;
+$.to = toProcess;
+$.through = $.io = throughProcess;
+
+// define shell functions
+
+export const shell = bqShell(shellEscape, (command, options) => spawn(buildShellCommand(options?.shellPath, options?.shellArgs, command), options));
+export {shell as sh};
+
+export const $sh = bqShell(shellEscape, (command, options) => {
+  const sp = spawn(buildShellCommand(options?.shellPath, options?.shellArgs, command), options);
+  return sp.exited.then(() => ({code: sp.exitCode, signal: sp.signalCode, killed: sp.killed}));
+});
+
+const fromShell = bqShell(shellEscape, (command, options) => {
+  const sp = spawn(buildShellCommand(options?.shellPath, options?.shellArgs, command), Object.assign({}, options, {stdout: 'pipe'}));
+  return sp.stdout;
+});
+
+const toShell = bqShell(shellEscape, (command, options) => {
+  const sp = spawn(buildShellCommand(options?.shellPath, options?.shellArgs, command), Object.assign({}, options, {stdin: 'pipe'}));
+  return sp.stdin;
+});
+
+const throughShell = bqShell(shellEscape, (command, options) => {
+  const sp = spawn(buildShellCommand(options?.shellPath, options?.shellArgs, command), Object.assign({}, options, {stdin: 'pipe', stdout: 'pipe'}));
+  return {readable: sp.stdout, writable: sp.stdin};
+});
+
+$sh.from = fromShell;
+$sh.to = toShell;
+$sh.through = $sh.io = throughShell;
+
+export default $;

package/src/shell/unix.js

@@ -0,0 +1,10 @@
+'use strict';
+
+import {getEnv, isAndroid} from '../utils.js';
+
+export const shellEscape = s => "'" + String(s).replace(/'/g, "'\\''") + "'";
+
+export const currentShellPath = () => getEnv('SHELL') || (isAndroid ? '/system/bin/sh' : '/bin/sh');
+
+// derived from https://github.com/nodejs/node/blob/43f699d4d2799cfc17cbcad5770e1889075d5dbe/lib/child_process.js#L620
+export const buildShellCommand = (shell, args, command) => [shell || currentShellPath(), ...(args || ['-c']), command];

package/src/shell/windows.js

@@ -0,0 +1,76 @@
+'use strict';
+
+import {getEnv, toBase64} from '../utils.js';
+
+export const currentShellPath = () => getEnv('ComSpec') || 'cmd.exe';
+
+const isCmd = s => /^(?:.*\\)?cmd(?:\.exe)?$/i.test(s);
+const isPwsh = s => /^(?:.*\\)?(?:pwsh|powershell)(?:\.exe)?$/i.test(s);
+
+const mapControls = {
+  '\b': '`b',
+  '\t': '`t',
+  '\r': '`r',
+  '\n': '`n',
+  '\f': '`f',
+  '\x00': '`0',
+  '\x07': '`a',
+  '\x1B': '`e',
+  '\x0B': '`v',
+  '"': '`\\"'
+};
+
+const escapePowerShell = (_, controls, nonAlphas, theRest) => {
+  if (controls) return mapControls[controls] || '';
+  if (nonAlphas) return '`' + nonAlphas;
+  return theRest;
+};
+
+const escapeCmd = (_, doubleQuote, nonAlphas, theRest) => {
+  if (doubleQuote) return '""';
+  if (nonAlphas) return '^' + nonAlphas;
+  return theRest;
+};
+
+export const shellEscape = (s, options, isFirst) => {
+  s = String(s);
+  const shell = options?.shellPath || currentShellPath();
+  if (isCmd(shell)) {
+    // based on https://github.com/nodejs/node/blob/dc74f17f6c37b1bb2d675216066238f33790ed29/deps/uv/src/win/process.c#L449
+    if (!s) return '""';
+    if (!/\s|[\t\"]/.test(s)) return s;
+    if (!/[\"\\]/.test(s)) return `"${s}"`;
+
+    let quoteHit = true;
+    const result =
+      '"' +
+      [...s]
+        .map(c => {
+          if (quoteHit && c === '\\') return '\\\\';
+          if (c === '"') {
+            quoteHit = true;
+            return '\\"';
+          }
+          quoteHit = false;
+          return c;
+        })
+        .join('') +
+      '"';
+    return isFirst ? result.replace(/(0xFF)|([\W])|(\w+)/g, escapeCmd) : result;
+  }
+  if (isPwsh(shell)) return s.replace(/([\t\r\n\f\x00\x1B\x07\x08\x0B\"])|([\W])|(\w+)/g, escapePowerShell);
+  return s;
+};
+
+export const buildShellCommand = (shell, args, command) => {
+  shell ||= currentShellPath();
+  if (isCmd(shell)) {
+    args ||= ['/d', '/s', '/c'];
+  } else if (isPwsh(shell)) {
+    args ||= ['-c'];
+    if (args.includes('-e')) command = toBase64(command);
+  } else {
+    args ||= ['-c'];
+  }
+  return [shell, ...args, command];
+};

package/src/spawn/bun.js

@@ -0,0 +1,69 @@
+'use strict';
+
+const sanitize = (value, defaultValue = 'ignore') => {
+  switch (value) {
+    case 'pipe':
+    case 'ignore':
+    case 'inherit':
+      return value;
+    case 'piped':
+      return 'pipe';
+    case null:
+      return 'ignore';
+  }
+  return defaultValue;
+};
+
+class Subprocess {
+  constructor(command, options) {
+    this.command = command;
+    this.options = options;
+
+    this.killed = false;
+
+    const spawnOptions = {windowsVerbatimArguments: true};
+    options.cwd && (spawnOptions.cwd = options.cwd);
+    options.env && (spawnOptions.env = options.env);
+
+    spawnOptions.stdin = sanitize(options.stdin);
+    spawnOptions.stdout = sanitize(options.stdout);
+    spawnOptions.stderr = sanitize(options.stderr);
+
+    this.spawnOptions = spawnOptions;
+
+    this.childProcess = Bun.spawn(command, spawnOptions);
+
+    this.stdin = this.childProcess.stdin ? new WritableStream(this.childProcess.stdin) : null;
+    this.stdout = this.childProcess.stdout || null;
+    this.stderr = this.childProcess.stderr || null;
+  }
+
+  get exited() {
+    return this.childProcess.exited;
+  }
+
+  get finished() {
+    return this.childProcess.killed;
+  }
+
+  get exitCode() {
+    return this.childProcess.exitCode;
+  }
+
+  get signalCode() {
+    return this.childProcess.signalCode;
+  }
+
+  kill() {
+    this.killed = true;
+    this.childProcess.kill();
+  }
+}
+
+export const currentExecPath = () => process.execPath;
+export const runFileArgs = ['run'];
+
+export const cwd = () => process.cwd();
+
+const bunSpawn = (command, options = {}) => new Subprocess(command, options);
+export {bunSpawn as spawn};

package/src/spawn/deno.js

@@ -0,0 +1,78 @@
+'use strict';
+
+const sanitize = (value, defaultValue = 'null') => {
+  switch (value) {
+    case 'pipe':
+    case 'piped':
+      return 'piped';
+    case 'ignore':
+    case null:
+      return 'null';
+    case 'inherit':
+      return value;
+  }
+  return defaultValue;
+};
+
+class Subprocess {
+  constructor(command, options) {
+    this.command = command;
+    this.options = options;
+
+    this.exitCode = null;
+    this.signalCode = null;
+    this.killed = false;
+    this.finished = false;
+
+    this.controller = new AbortController();
+
+    const spawnOptions = {signal: this.controller.signal, args: command.slice(1), windowsRawArguments: true};
+    options.cwd && (spawnOptions.cwd = options.cwd);
+    options.env && (spawnOptions.env = options.env);
+
+    spawnOptions.stdin = sanitize(options.stdin);
+    spawnOptions.stdout = sanitize(options.stdout);
+    spawnOptions.stderr = sanitize(options.stderr);
+
+    this.spawnOptions = spawnOptions;
+
+    this.childProcess = new Deno.Command(command[0], spawnOptions).spawn();
+
+    this.exited = this.childProcess.status
+      .then(status => {
+        this.finished = true;
+        this.exitCode = status.code;
+        this.signalCode = status.signal;
+        return status.code;
+      })
+      .catch(error => {
+        this.finished = true;
+        return Promise.reject(error);
+      });
+  }
+
+  get stdin() {
+    return this.spawnOptions.stdin === 'piped' ? this.childProcess.stdin : null;
+  }
+
+  get stdout() {
+    return this.spawnOptions.stdout === 'piped' ? this.childProcess.stdout : null;
+  }
+
+  get stderr() {
+    return this.spawnOptions.stderr === 'piped' ? this.childProcess.stderr : null;
+  }
+
+  kill() {
+    this.killed = true;
+    this.controller.abort();
+  }
+}
+
+export const currentExecPath = () => Deno.execPath();
+export const runFileArgs = ['run'];
+
+export const cwd = () => Deno.cwd();
+
+const denoSpawn = (command, options = {}) => new Subprocess(command, options);
+export {denoSpawn as spawn};

package/src/spawn/node.js

@@ -0,0 +1,76 @@
+'use strict';
+
+import {spawn} from 'node:child_process';
+import {Readable, Writable} from 'node:stream';
+
+const setStdio = (stdio, fd, value) => {
+  switch (value) {
+    case 'pipe':
+    case 'ignore':
+    case 'inherit':
+      stdio[fd] = value;
+      break;
+    case 'piped':
+      stdio[fd] = 'pipe';
+      break;
+    case null:
+      stdio[fd] = 'ignore';
+      break;
+  }
+};
+
+class Subprocess {
+  constructor(command, options) {
+    this.command = command;
+    this.options = options;
+
+    this.exitCode = null;
+    this.signalCode = null;
+    this.killed = false;
+    this.finished = false;
+
+    const spawnOptions = {stdio: ['ignore', 'ignore', 'ignore'], windowsVerbatimArguments: true};
+    options.cwd && (spawnOptions.cwd = options.cwd);
+    options.env && (spawnOptions.env = options.env);
+
+    setStdio(spawnOptions.stdio, 0, options.stdin);
+    setStdio(spawnOptions.stdio, 1, options.stdout);
+    setStdio(spawnOptions.stdio, 2, options.stderr);
+
+    this.spawnOptions = spawnOptions;
+
+    this.childProcess = spawn(command[0], command.slice(1), spawnOptions);
+    this.childProcess.on('exit', (code, signal) => {
+      this.finished = true;
+      this.exitCode = code;
+      this.signalCode = signal;
+      this.resolve(code);
+    });
+    this.childProcess.on('error', error => {
+      this.finished = true;
+      this.reject(error);
+    });
+
+    this.exited = new Promise((resolve, reject) => {
+      this.resolve = resolve;
+      this.reject = reject;
+    });
+
+    this.stdin = this.childProcess.stdin && Writable.toWeb(this.childProcess.stdin);
+    this.stdout = this.childProcess.stdout && Readable.toWeb(this.childProcess.stdout);
+    this.stderr = this.childProcess.stderr && Readable.toWeb(this.childProcess.stderr);
+  }
+
+  kill() {
+    this.killed = true;
+    this.childProcess.kill();
+  }
+}
+
+export const currentExecPath = () => process.execPath;
+export const runFileArgs = [];
+
+export const cwd = () => process.cwd();
+
+const nodeSpawn = (command, options = {}) => new Subprocess(command, options);
+export {nodeSpawn as spawn};

package/src/utils.js

@@ -0,0 +1,37 @@
+'use strict';
+
+let getEnv, isWindows, isAndroid;
+if (typeof Deno !== 'undefined') {
+  getEnv = name => Deno.env.get(name);
+  isWindows = Deno.build.os === 'windows';
+  isAndroid = Deno.build.os === 'android';
+} else if (typeof Bun !== 'undefined') {
+  getEnv = name => Bun.env[name];
+  isWindows = process.platform === 'win32';
+  isAndroid = process.platform === 'android';
+} else {
+  getEnv = name => process.env[name];
+  isWindows = process.platform === 'win32';
+  isAndroid = process.platform === 'android';
+}
+export {getEnv, isWindows, isAndroid};
+
+export const verifyStrings = strings => Array.isArray(strings) && strings.every(s => typeof s === 'string');
+
+export const toBase64 = s => {
+  // const buf = new TextEncoder().encode(s),
+  //   bytes = Array.from(buf, b => String.fromCharCode(b >> 8) + String.fromCharCode(b & 0xFF)).join('');
+  const bytes = Array.from(s, c => {
+    const code = c.charCodeAt(0);
+    return String.fromCharCode(code & 0xff) + String.fromCharCode((code >> 8) & 0xff);
+  }).join('');
+  return btoa(bytes);
+};
+
+const rawValueSymbol = Symbol.for('object-stream.raw-value');
+
+export const raw = value => ({[rawValueSymbol]: value});
+export const isRawValue = value => value && typeof value === 'object' && rawValueSymbol in value;
+export const getRawValue = value => value[rawValueSymbol];
+
+export const winCmdEscape = isWindows ? value => raw(String(value).replace(/./g, '^$&')) : value => String(value);