@plugjs/plug 0.3.5 → 0.4.1

package/src/helpers.ts

@@ -7,14 +7,23 @@ import { requireContext } from './async'
 import { Files } from './files'
 import { rm } from './fs'
 import { $p, log } from './logging'
-import { commonPath, getCurrentWorkingDirectory, resolveDirectory, resolveFile } from './paths'
+import {
+  commonPath,
+  getAbsoluteParent,
+  getCurrentWorkingDirectory,
+  resolveDirectory,
+  resolveFile,
+} from './paths'
 import { PipeImpl } from './pipe'
+import { RunBuild } from './plugs/build'
 import { execChild } from './utils/exec'
 import { parseOptions } from './utils/options'
 import { walk } from './utils/walk'
 
+import type { ForkOptions } from './fork'
 import type { Pipe } from './index'
 import type { AbsolutePath } from './paths'
+import type { Context } from './pipe'
 import type { ExecChildOptions } from './utils/exec'
 import type { ParseOptions } from './utils/options'
 import type { WalkOptions } from './utils/walk'
@@ -29,6 +38,11 @@ export interface FindOptions extends WalkOptions {
   directory?: string
 }
 
+/** Return the current execution {@link Context} */
+export function context(): Context {
+  return requireContext()
+}
+
 /** Find files in the current directory using the specified _glob_. */
 export function find(glob: string): Pipe
 /** Find files in the current directory using the specified _globs_. */
@@ -56,6 +70,44 @@ export function find(...args: ParseOptions<FindOptions>): Pipe {
   }))
 }
 
+export type InvokeBuildOptions = ForkOptions & Record<string, string>
+export type InvokeBuildTasks = string | [ string, ...string[] ]
+
+export function invokeBuild(buildFile: string): Promise<void>
+export function invokeBuild(buildFile: string, task: string): Promise<void>
+export function invokeBuild(buildFile: string, task: string, options: InvokeBuildOptions): Promise<void>
+export function invokeBuild(buildFile: string, tasks: [ string, ...string[] ]): Promise<void>
+export function invokeBuild(buildFile: string, tasks: [ string, ...string[] ], options: InvokeBuildOptions): Promise<void>
+export function invokeBuild(buildFile: string, options: InvokeBuildOptions): Promise<void>
+export async function invokeBuild(
+    buildFile: string,
+    tasksOrOptions?: string | [ string, ...string[] ] | InvokeBuildOptions,
+    maybeOptions?: InvokeBuildOptions,
+): Promise<void> {
+  const [ tasks, options = {} ] =
+      typeof tasksOrOptions === 'string' ?
+          [ [ tasksOrOptions ], maybeOptions ] :
+      Array.isArray(tasksOrOptions) ?
+          [ tasksOrOptions, maybeOptions ] :
+      typeof tasksOrOptions === 'object' ?
+          [ [ 'default' ], tasksOrOptions ] :
+      [ [ 'default' ], {} ]
+
+  if (tasks.length === 0) tasks.push('default')
+
+  const { coverageDir, forceModule, ...props } = options
+  const forkOptions = { coverageDir, forceModule }
+
+  const context = requireContext()
+  const file = context.resolve(buildFile)
+  const dir = getAbsoluteParent(file)
+  const files = Files.builder(dir).add(file).build()
+
+  return new RunBuild(tasks, props, forkOptions)
+      .pipe(files, context)
+      .then(() => void 0)
+}
+
 /**
  * Recursively remove the specified directory _**(use with care)**_.
  */
@@ -98,14 +150,14 @@ export function merge(pipes: (Pipe | Files | Promise<Files>)[]): Pipe {
   const context = requireContext()
   return new PipeImpl(context, Promise.resolve().then(async () => {
     // No pipes? Just send off an empty pipe...
-    if (pipes.length === 0) return Files.builder(getCurrentWorkingDirectory()).build()
+    if (pipes.length === 0) return new Files()
 
     // Await for all pipes / files / files promises
     const awaited = await assertPromises<Files>(pipes)
     const results = awaited.filter((result) => result.length)
 
     // No files in anything to be merged? Again send off an empty pipe...
-    if (results.length === 0) return Files.builder(getCurrentWorkingDirectory()).build()
+    if (results.length === 0) return new Files()
 
     // Find the common directory between all the Files instances
     const [ firstDir, ...otherDirs ] = results.map((f) => f.directory)
@@ -132,8 +184,7 @@ export function merge(pipes: (Pipe | Files | Promise<Files>)[]): Pipe {
  */
 export function noop(): Pipe {
   const context = requireContext()
-  const files = new Files(getCurrentWorkingDirectory())
-  return new PipeImpl(context, Promise.resolve(files))
+  return new PipeImpl(context, Promise.resolve(new Files()))
 }
 
 /**

package/src/index.ts

@@ -28,6 +28,7 @@ export interface Pipe extends Promise<Files> {
 
 // Submodule exports (our package.json exports)
 export * as asserts from './asserts'
+export * as async from './async'
 export * as files from './files'
 export * as fork from './fork'
 export * as fs from './fs'
@@ -37,7 +38,7 @@ export * as pipe from './pipe'
 export * as utils from './utils'
 
 // Individual utilities
-export { log, $ms, $p, $t, $blu, $cyn, $grn, $gry, $mgt, $red, $und, $wht, $ylw } from './logging'
+export { banner, log, $ms, $p, $t, $blu, $cyn, $grn, $gry, $mgt, $red, $und, $wht, $ylw } from './logging'
 export { assert, fail, BuildFailure } from './asserts'
 
 // Our minimal exports

package/src/logging/emit.ts

@@ -42,8 +42,8 @@ export type LogEmitter = (options: LogEmitterOptions, args: any[]) => void
 
 /** Emit in full colors! */
 export const emitColor: LogEmitter = (options: LogEmitterOptions, args: any[]): void => {
-  const { taskName, level, prefix, indent } = options
-  const logPrefix = prefix ? prefix : indent ? ''.padStart(indent * _indentSize) : ''
+  const { taskName, level, prefix = '', indent = 0 } = options
+  const logPrefix = ''.padStart(indent * _indentSize) + prefix
 
   /* Prefixes, to prepend at the beginning of each line */
   const prefixes: string[] = []
@@ -85,8 +85,8 @@ export const emitColor: LogEmitter = (options: LogEmitterOptions, args: any[]):
 
 /** Emit in plain text! (no colors) */
 export const emitPlain: LogEmitter = (options: LogEmitterOptions, args: any[]): void => {
-  const { taskName, level, prefix, indent } = options
-  const logPrefix = prefix ? prefix : indent ? ''.padStart(indent * _indentSize) : ''
+  const { taskName, level, prefix = '', indent = 0 } = options
+  const logPrefix = ''.padStart(indent * _indentSize) + prefix
 
   const prefixes: string[] = []
 

package/src/logging/logger.ts

@@ -1,13 +1,17 @@
-import { BuildFailure, isBuildFailure } from '../asserts'
+import { formatWithOptions } from 'node:util'
+
+import { BuildFailure } from '../asserts'
 import { emitColor, emitPlain } from './emit'
 import { DEBUG, ERROR, INFO, NOTICE, TRACE, WARN } from './levels'
 import { logOptions } from './options'
 import { ReportImpl } from './report'
+import { $gry } from './colors'
 
-import type { LogEmitter } from './emit'
+import type { LogEmitter, LogEmitterOptions } from './emit'
 import type { LogLevel } from './levels'
 import type { Report } from './report'
 
+
 /* ========================================================================== */
 
 /* Initial value of log colors, and subscribe to changes */
@@ -26,8 +30,6 @@ logOptions.on('changed', ({ defaultTaskName, colors, level }) => {
 
 /** The basic interface giving access to log facilities. */
 export interface Log {
-  /** The current {@link Logger} */
-  readonly logger: Logger
   /** Log a `TRACE` message */
   trace(...args: [ any, ...any ]): void
   /** Log a `DEBUG` message */
@@ -45,7 +47,7 @@ export interface Log {
 }
 
 /** A {@link Logger} extends the basic {@link Log} adding some state. */
-export interface Logger extends Omit<Log, 'logger'> {
+export interface Logger extends Log {
   /** The current level for logging. */
   level: LogLevel,
 
@@ -95,7 +97,7 @@ class LoggerImpl implements Logger {
 
     // The `BuildFailure` is a bit special case
     const params = args.filter((arg) => {
-      if (isBuildFailure(arg)) {
+      if (arg instanceof BuildFailure) {
         // Filter out any previously logged build failure and mark
         if (_loggedFailures.has(arg)) return false
         _loggedFailures.add(arg)
@@ -198,6 +200,57 @@ class LoggerImpl implements Logger {
   }
 
   report(title: string): Report {
-    return new ReportImpl(title, this._task, this._emitter)
+    const emitter: LogEmitter = (options: LogEmitterOptions, args: any) => {
+      if (this._stack.length) {
+        for (const { message, ...extras } of this._stack) {
+          this._emitter({ ...options, ...extras }, [ message ])
+        }
+        this._stack.splice(0)
+      }
+
+      let { indent = 0, prefix = '' } = options
+      prefix = this._indent ? $gry('| ') + prefix : prefix
+      indent += this._indent
+      this._emitter({ ...options, indent, prefix }, args)
+    }
+    return new ReportImpl(title, this._task, emitter)
+  }
+}
+
+/* ========================================================================== */
+
+/** Pattern to match ANSI expressions */
+const ansiPattern = '[\\u001b\\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]'
+/** Regular expression matching ANSI */
+const ansiRegExp = new RegExp(ansiPattern, 'g')
+
+/** A test logger, writing to a buffer always _without_ colors */
+export class TestLogger extends LoggerImpl {
+  private _lines: string[] = []
+
+  constructor() {
+    super('', (options: LogEmitterOptions, args: any[]): void => {
+      const { prefix = '', indent = 0 } = options
+      const linePrefix = ''.padStart(indent * 2) + prefix
+
+      /* Now for the normal logging of all our parameters */
+      formatWithOptions({ colors: false, breakLength: 120 }, ...args)
+          .split('\n').forEach((line) => {
+            const stripped = line.replaceAll(ansiRegExp, '')
+            this._lines.push(`${linePrefix}${stripped}`)
+          })
+    })
+  }
+
+  /** Return the _current_ buffer for this instance */
+  get buffer(): string {
+    return this._lines.join('\n')
+  }
+
+  /** Reset the buffer and return any previously buffered text */
+  reset(): string {
+    const buffer = this.buffer
+    this._lines = []
+    return buffer
   }
 }

package/src/logging/options.ts

@@ -2,6 +2,7 @@ import { EventEmitter } from 'node:events'
 import { Socket } from 'node:net'
 
 import { getLevelNumber, NOTICE } from './levels'
+import { getSingleton } from '../utils/singleton'
 
 import type { Writable } from 'node:stream'
 import type { InspectOptions } from 'node:util'
@@ -96,7 +97,11 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
      * and consumed by the `Exec` plug (which has no other way of communicating)
      */
     const { fd, ...options } = JSON.parse(process.env.__LOG_OPTIONS || '{}')
-    if (fd) this._output = new Socket({ fd, readable: false, writable: true }).unref()
+    if (fd) {
+      const output = new Socket({ fd, readable: false, writable: true }).unref()
+      process.on('beforeExit', () => this._output.end())
+      this._output = output
+    }
     Object.assign(this, options)
   }
 
@@ -228,18 +233,8 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
   }
 }
 
-/* Unique symbol to share `LogOptions` per process */
-const optionsKey = Symbol.for('plugjs.plug.logging.logOptions')
-
-/** Get the shared _per process_ instance of our {@link LogOptions}. */
-function getLogOptions(): LogOptions {
-  let options: LogOptions = (<any> globalThis)[optionsKey]
-  if (! options) {
-    options = new LogOptionsImpl()
-    ;(<any> globalThis)[optionsKey] = options
-  }
-  return options
-}
+/** Singleton key for {@link LogOptions} instance. */
+const optionsKey = Symbol.for('plugjs:plug:types:LogOptions')
 
 /** Shared instance of our {@link LogOptions}. */
-export const logOptions = getLogOptions()
+export const logOptions = getSingleton(optionsKey, () => new LogOptionsImpl())

package/src/logging.ts

@@ -1,8 +1,9 @@
 import { currentContext } from './async'
+import { $gry, $wht } from './logging/colors'
 import { getLogger } from './logging/logger'
 import { setupSpinner } from './logging/spinner'
 
-import type { Logger, Log } from './logging/logger'
+import type { Log, Logger } from './logging/logger'
 
 export * from './logging/colors'
 export * from './logging/github'
@@ -32,10 +33,6 @@ export const log: LogFunction = ((): LogFunction => {
 
   /* Create a Logger wrapping the current logger */
   const wrapper: Log = {
-    get logger() {
-      return logger()
-    },
-
     trace(...args: [ any, ...any ]): void {
       logger().trace(...args)
     },
@@ -71,3 +68,21 @@ export const log: LogFunction = ((): LogFunction => {
   /* Return our function, with added Logger implementation */
   return Object.assign(log, wrapper)
 })()
+
+/* ========================================================================== *
+ * BANNER                                                                     *
+ * ========================================================================== */
+
+/** Print a nice _banner_ message on the log */
+export function banner(message: string): void {
+  const padMessage = message.length > 60 ? message.length : 60
+  const padLines = padMessage + 2
+
+  log.notice([
+    '',
+    $gry(`\u2554${''.padStart(padLines, '\u2550')}\u2557`),
+    `${$gry('\u2551')} ${$wht(message.padEnd(padMessage, ' '))} ${$gry('\u2551')}`,
+    $gry(`\u255A${''.padStart(padLines, '\u2550')}\u255D`),
+    '',
+  ].join('\n'))
+}

package/src/plugs/build.ts

@@ -0,0 +1,45 @@
+import { $p } from '../logging/colors'
+import { ForkingPlug, type ForkOptions } from '../fork'
+import { requireFilename } from '../paths'
+import { invokeTasks, isBuild } from '../build'
+
+import type { Files } from '../files'
+import type { Context, Plug } from '../pipe'
+
+/** Writes some info about the current {@link Files} being passed around. */
+export class RunBuildInternal implements Plug<void> {
+  constructor(
+      private readonly _tasks: readonly string[],
+      private readonly _props: Readonly<Record<string, string>>,
+  ) {}
+
+  async pipe(files: Files, context: Context): Promise<void> {
+    const tasks = this._tasks.length === 0 ? [ 'default' ] : this._tasks
+
+    for (const file of files.absolutePaths()) {
+      // Import and check build file
+      let maybeBuild = await import(file)
+      while (maybeBuild) {
+        if (isBuild(maybeBuild)) break
+        maybeBuild = maybeBuild.default
+      }
+
+      // We _need_ a build
+      if (! isBuild(maybeBuild)) {
+        context.log.fail(`File ${$p(file)} did not export a proper build`)
+      } else {
+        await invokeTasks(maybeBuild, tasks, this._props)
+      }
+    }
+  }
+}
+
+export class RunBuild extends ForkingPlug {
+  constructor(
+      tasks: readonly string[],
+      props: Readonly<Record<string, string>>,
+      options: ForkOptions,
+  ) {
+    super(requireFilename(__fileurl), [ tasks, props, options ], RunBuildInternal.name)
+  }
+}

package/src/plugs/debug.ts

@@ -1,4 +1,4 @@
-import { $gry, $p, $und, $ylw } from '../logging'
+import { $gry, $und, $ylw } from '../logging'
 import { install } from '../pipe'
 
 import type { Files } from '../files'
@@ -26,14 +26,15 @@ install('debug', class Debug implements Plug<Files> {
 
   async pipe(files: Files, context: Context): Promise<Files> {
     context.log.notice(this._title, `${$gry('(')}${$ylw(files.length)} ${$gry('files)')}`)
-    context.log.notice('-        base dir:', $p(context.resolve('@')))
-    context.log.notice('-  build file dir:', $p(context.resolve('.')))
-    context.log.notice('-       files dir:', $p(files.directory))
-    if (files.length) {
-      const [ path, ...paths ] = files
-      context.log.notice('-  relative paths:', $und($gry(path)))
-      for (const p of paths) context.log.notice('-                :', $und($gry(p)))
-    }
+    context.log.notice('- build file dir:', $gry($und(context.resolve('@'))))
+    context.log.notice('-    current dir:', $gry($und(context.resolve('.'))))
+    context.log.notice('-      files dir:', $gry($und(files.directory)))
+
+    const paths = [ ...files ]
+    const path = paths.shift()
+    context.log.notice('- relative paths:', $und($gry(path)))
+    paths.forEach((p) => context.log.notice('-               :', $und($gry(p))))
+
     return files
   }
 })

package/src/types.ts

@@ -26,6 +26,8 @@ export interface State {
   readonly tasks: Tasks
   /** All _properties_ available in this {@link State} */
   readonly props: Props
+  /** All _tasks_ that have failed in this {@link State} */
+  readonly fails: Set<Task>
 }
 
 /* ========================================================================== *
@@ -36,21 +38,23 @@ export interface State {
  * The {@link Task} interface normalizes a task definition, associating it with
  * its build file, its sibling {@link Task}s and available _properties_.
  */
-export interface Task<T extends Result = Result, P extends Props = Record<string, string>> {
-  /** Simply invoke this task stand alone */
-  (props?: Partial<P>): Promise<T>
+export interface Task<T extends Result = Result> {
+  /** The unique ID of this {@link Task} */
+  readonly id: number,
+  /** The _original_ name of this task */
+  readonly name: string
   /** All _properties_ siblings to this {@link Task} */
   readonly props: Props
   /** All {@link Tasks} sibling to this {@link Task} */
   readonly tasks: Tasks
   /** The absolute file name where this {@link Task} was defined */
   readonly buildFile: AbsolutePath,
-  /** Invoke a task from in the context of a {@link Build} */
-  invoke(state: State, taskName: string): Promise<T>
   /** Other {@link Task}s hooked _before_ this one */
   readonly before: Task[]
   /** Other {@link Task}s hooked _after_ this one */
   readonly after: Task[]
+  /** Invoke a task from in the context of a {@link Build} */
+  invoke(state: State, taskName: string): Promise<T>
 }
 
 /**
@@ -62,6 +66,12 @@ export type TaskResult = Pipe | Files | void | undefined
 /** The {@link TaskDef} type identifies the _definition_ of a task. */
 export type TaskDef<R extends TaskResult = TaskResult> = () => R | Promise<R>
 
+/** A callable, compiled {@link Task} from a {@link TaskDef} */
+export type TaskCall<D extends BuildDef = BuildDef, R extends Result = Result> = {
+  (props?: Partial<Props<D>>): Promise<R>
+  task: Task<R>
+}
+
 /* ========================================================================== *
  * TASKS AND PROPERTIES                                                       *
  * ========================================================================== */
@@ -73,12 +83,12 @@ export type Props<D extends BuildDef = BuildDef> = {
 
 /** A type identifying all _tasks_ in a {@link Build} */
 export type Tasks<D extends BuildDef = BuildDef> = {
-  readonly [ k in string & keyof D as D[k] extends TaskDef | Task ? k : never ] :
+  readonly [ k in string & keyof D as D[k] extends TaskDef | TaskCall ? k : never ] :
     D[k] extends TaskDef<infer R> ?
-      R extends void | undefined ? Task<undefined, Props<D>> :
-      R extends Pipe | Files ? Task<Files, Props<D>> :
+      R extends void | undefined ? TaskCall<D, undefined> :
+      R extends Pipe | Files ? TaskCall<D, Files> :
       never :
-    D[k] extends Task ? D[k] :
+    D[k] extends TaskCall ? D[k] :
     never
 }
 
@@ -91,7 +101,7 @@ export type Tasks<D extends BuildDef = BuildDef> = {
  * all its properties and tasks.
  */
 export interface BuildDef {
-  [ k : string ] : string | TaskDef | Task
+  [ k : string ] : string | TaskDef | TaskCall
 }
 
 /**
@@ -99,24 +109,45 @@ export interface BuildDef {
  * {@link TaskDef | task definitions }.
  */
 export type ThisBuild<D extends BuildDef> = {
-  readonly [ k in keyof D ] :
-    k extends string ?
-      D[k] extends TaskDef<infer R> ?
-        R extends Promise<undefined> | void | undefined ? () => Promise<undefined> :
-        R extends Pipe | Files ? () => Pipe :
-        never :
-      D[k] extends Task<infer R> ?
-        R extends undefined ? () => Promise<undefined> :
-        R extends Files ? () => Pipe :
-        never :
-      D[k] extends string ?
-        string :
+  readonly [ k in keyof D as k extends string ? k : never ] :
+    D[k] extends TaskDef<infer R> ?
+      R extends Promise<undefined> | void | undefined ? () => Promise<undefined> :
+      R extends Pipe | Files ? () => Pipe :
+      never :
+    D[k] extends TaskCall<any, infer R> ?
+      R extends undefined ? () => Promise<undefined> :
+      R extends Files ? () => Pipe :
       never :
+    D[k] extends string ?
+      string :
     never
 }
 
+/**
+ * Symbol indicating that an object is a {@link Build}.
+ *
+ * In a compiled {@link Build} this symbol will be associated with a function
+ * taking an array of strings (task names) and record of props to override
+ */
+export const buildMarker = Symbol.for('plugjs:plug:types:Build')
+
 /**
  * The {@link Build} type represents the collection of {@link Task}s
  * and _properties_ compiled from a {@link BuildDef | build definition}.
  */
-export type Build<D extends BuildDef = BuildDef> = Tasks<D> & Props<D>
+export type Build<D extends BuildDef = BuildDef> = Props<D> & Tasks<D> & {
+  readonly [buildMarker]: (
+    tasks: readonly string[],
+    props?: Record<string, string | undefined>,
+  ) => Promise<void>
+}
+
+/** A type identifying all _task names_ in a {@link Build}. */
+export type BuildTasks<B extends Build> = string & keyof {
+  [ name in keyof B as B[name] extends Function ? name : never ] : any
+}
+
+/** A type identifying a subset of _properties_ for a {@link Build}. */
+export type BuildProps<B extends Build> = {
+  [ name in keyof B as B[name] extends string ? name : never ]? : string
+}

package/src/utils/diff.ts

@@ -3,7 +3,6 @@ import { inspect, isDeepStrictEqual } from 'node:util'
 
 import { assert } from '../asserts'
 import { $grn, $red, logOptions } from '../logging'
-import { getTypeOf } from './types'
 
 import type { InspectOptions } from 'node:util'
 
@@ -326,13 +325,9 @@ export function textDiff(
   let lhsLines: string[]
   let rhsLines: string[]
 
-  // Get the _real_ types of both arguments
-  const lhsType = getTypeOf(lhs)
-  const rhsType = getTypeOf(rhs)
-
   // If _both_ arguments are strings, then just split and compare, otherwise
   // we nuse NodeJS' inspect to prep their string version
-  if ((lhsType === 'string') && (rhsType === 'string')) {
+  if ((typeof lhs === 'string') && (typeof rhs === 'string')) {
     lhsLines = lhs.split('\n')
     rhsLines = rhs.split('\n')
   } else {

package/src/utils/exec.ts

@@ -1,9 +1,9 @@
+import { spawn } from 'node:child_process'
 import path from 'node:path'
 import readline from 'node:readline'
-import { fork as forkProcess, spawn as spawnProcess } from 'node:child_process'
 
 import { assert, BuildFailure } from '../asserts'
-import { $p, logOptions } from '../logging'
+import { $p } from '../logging'
 import { getCurrentWorkingDirectory, resolveDirectory } from '../paths'
 
 import type { SpawnOptions } from 'node:child_process'
@@ -16,8 +16,6 @@ export interface ExecChildOptions {
   coverageDir?: string,
   /** Extra environment variables, or overrides for existing ones */
   env?: Record<string, any>,
-  /** Whether to _fork_ the process (argument is a javascript file) or not */
-  fork?: boolean,
   /** Whether to run the command in a shell (optionally name the shell) */
   shell?: string | boolean,
   /** The current working directory of the process to execute. */
@@ -32,7 +30,6 @@ export async function execChild(
 ): Promise<void> {
   const {
     env = {}, // default empty environment
-    fork = false, // by default do not fork
     shell = false, // by default do not use a shell
     cwd = undefined, // by default use "process.cwd()"
     coverageDir, // default "undefined" (pass throug from env)
@@ -42,9 +39,6 @@ export async function execChild(
   const childCwd = cwd ? context.resolve(cwd) : getCurrentWorkingDirectory()
   assert(resolveDirectory(childCwd), `Current working directory ${$p(childCwd)} does not exist`)
 
-  // Check for wrong fork/shell combination
-  assert(!(fork && shell), 'Options "fork" and "shell" can not coexist')
-
   // Figure out the PATH environment variable
   const childPaths: AbsolutePath[] = []
 
@@ -62,8 +56,7 @@ export async function execChild(
 
   // Build our environment variables record
   const PATH = childPaths.join(path.delimiter)
-  const logForkEnv = logOptions.forkEnv(context.taskName, 4)
-  const childEnv: Record<string, string> = { ...process.env, ...env, ...logForkEnv, PATH }
+  const childEnv: Record<string, string> = { ...process.env, ...env, PATH }
 
   // Instrument coverage directory if needed
   if (coverageDir) childEnv.NODE_V8_COVERAGE = context.resolve(coverageDir)
@@ -71,19 +64,17 @@ export async function execChild(
   // Prepare the options for calling `spawn`
   const childOptions: SpawnOptions = {
     ...extraOptions,
-    stdio: [ 'ignore', 'pipe', 'pipe', 'ipc', 'pipe' ],
+    stdio: [ 'ignore', 'pipe', 'pipe' ],
     cwd: childCwd,
     env: childEnv,
     shell,
   }
 
   // Spawn our subprocess and monitor its stdout/stderr
-  context.log.info(fork ? 'Forking' : 'Executing', [ cmd, ...args ])
+  context.log.info('Executing', [ cmd, ...args ])
   context.log.debug('Child process options', childOptions)
 
-  const child = fork ?
-    forkProcess(cmd, args, childOptions) :
-    spawnProcess(cmd, args, childOptions)
+  const child = spawn(cmd, args, childOptions)
 
   try {
     context.log.info('Child process PID', child.pid)
@@ -99,11 +90,6 @@ export async function execChild(
       const err = readline.createInterface(child.stderr)
       err.on('line', (line) => context.log.warn(line ||'\u00a0'))
     }
-
-    // Log output bypass
-    if (child.stdio[4]) {
-      child.stdio[4].on('data', (data) => logOptions.output.write(data))
-    }
   } catch (error) {
     // If something happens before returning our promise, kill the child...
     child.kill()