@plugjs/plug 0.4.35 → 0.5.0

package/src/cli.mts

@@ -7,13 +7,16 @@ import _fs from 'node:fs'
 import { main, yargsParser } from '@plugjs/tsrun'
 
 import { BuildFailure } from './asserts'
+import { runAsync } from './async'
 import { invokeTasks, isBuild } from './build'
 import { $blu, $gry, $p, $red, $t, $und, $wht } from './logging/colors'
 import { logLevels } from './logging/levels'
 import { logOptions } from './logging/options'
 import { getCurrentWorkingDirectory, resolveAbsolutePath, resolveDirectory, resolveFile } from './paths'
+import { Context } from './pipe'
 
 import type { AbsolutePath } from './paths'
+import type { Build } from './types'
 
 /* Log levels */
 const { TRACE, DEBUG, INFO, NOTICE, WARN, ERROR, OFF } = logLevels
@@ -258,11 +261,14 @@ main(import.meta.url, async (args: string[]): Promise<void> => {
   if (tasks.length === 0) tasks.push('default')
 
   // Import and check build file
-  let maybeBuild = await import(buildFile)
-  while (maybeBuild) {
-    if (isBuild(maybeBuild)) break
-    maybeBuild = maybeBuild.default
-  }
+  const initialContext = new Context(buildFile, '')
+  const maybeBuild = await runAsync(initialContext, async (): Promise<Build | void> => {
+    let maybeBuild = await import(buildFile)
+    while (maybeBuild) {
+      if (isBuild(maybeBuild)) return maybeBuild
+      maybeBuild = maybeBuild.default
+    }
+  })
 
   // We _need_ a build
   if (! isBuild(maybeBuild)) {

package/src/fork.ts

@@ -4,9 +4,11 @@ import { assert, BuildFailure } from './asserts'
 import { runAsync } from './async'
 import { Files } from './files'
 import { $gry, $p, $red, logOptions } from './logging'
+import { emit, emitForked } from './logging/emit'
 import { requireFilename, resolveFile } from './paths'
 import { Context, install } from './pipe'
 
+import type { ForkedLogMessage } from './logging/emit'
 import type { AbsolutePath } from './paths'
 import type { Plug, PlugName, PlugResult } from './pipe'
 
@@ -37,6 +39,7 @@ export interface ForkData {
   filesDir: AbsolutePath,
   /** All files to pipe */
   filesList: AbsolutePath[],
+  logIndent: number,
 }
 
 /** Fork result, from child to parent process */
@@ -69,6 +72,7 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
       buildFile: context.buildFile,
       filesDir: files.directory,
       filesList: [ ...files.absolutePaths() ],
+      logIndent: context.log.indent,
     }
 
     /* Get _this_ filename to spawn */
@@ -76,7 +80,7 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
     context.log.debug('About to fork plug from', $p(this._scriptFile))
 
     /* Environment variables */
-    const env = { ...process.env, ...logOptions.forkEnv(context.taskName, 4) }
+    const env = { ...process.env, ...logOptions.forkEnv(context.taskName) }
 
     /* Check our args (reversed) to see if the last specifies `coverageDir` */
     for (let i = this._arguments.length - 1; i >= 0; i --) {
@@ -95,15 +99,11 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
 
     /* Run our script in a _separate_ process */
     const child = fork(script, {
-      stdio: [ 'ignore', 'inherit', 'inherit', 'ipc', 'pipe' ],
+      stdio: [ 'ignore', 'inherit', 'inherit', 'ipc' ],
       env,
     })
 
-    /* Pipe child logs directly to the writer */
-    if (child.stdio[4]) {
-      child.stdio[4].on('data', (data) => logOptions.output.write(data))
-    }
-
+    /* Do some logging... */
     context.log.info('Running', $p(script), $gry(`(pid=${child.pid})`))
 
     /* Return a promise from the child process events */
@@ -116,9 +116,18 @@ export abstract class ForkingPlug implements Plug<PlugResult> {
         return done || reject(BuildFailure.fail())
       })
 
-      child.on('message', (message: ForkResult) => {
-        context.log.debug('Message from forked plug process with PID', child.pid, message)
-        response = message
+      child.on('message', (message: ForkResult | ForkedLogMessage) => {
+        if ('logLevel' in message) {
+          const { logLevel, taskName, lines } = message
+          lines.forEach((line) => {
+            // this is _a hack_, as we want to reuse the indent and prefix of
+            // the current log, but the task name from the forked plug!!!
+            (context.log as any)._emit(logLevel, [ line ], taskName)
+          })
+        } else {
+          context.log.debug('Message from forked plug process with PID', child.pid, message)
+          response = message
+        }
       })
 
       child.on('exit', (code, signal) => {
@@ -204,10 +213,15 @@ if ((process.argv[1] === requireFilename(__fileurl)) && (process.send)) {
       buildFile,
       filesDir,
       filesList,
+      logIndent,
     } = message
 
+    /* Before anything else, capture logs! */
+    emit.emitter = emitForked // replace the log emitter...
+
     /* First of all, our plug context */
     const context = new Context(buildFile, taskName)
+    context.log.indent = logIndent
     context.log.debug('Message from parent process for PID', process.pid, message)
 
     /* Contextualize this run, and go! */
@@ -260,11 +274,8 @@ if ((process.argv[1] === requireFilename(__fileurl)) && (process.send)) {
       console.error('\n\nError sending message back to parent process', error)
       process.exitCode = 1
     }).finally(() => {
-      /* Flush and end our log output */
-      logOptions.output.end(() => {
-        process.disconnect()
-        process.exit(process.exitCode)
-      })
+      process.disconnect()
+      process.exit(process.exitCode)
     })
   })
 }

package/src/logging/emit.ts

@@ -1,5 +1,6 @@
 import { formatWithOptions } from 'node:util'
 
+import { fail } from '../asserts'
 import { $blu, $grn, $gry, $red, $t, $ylw } from './colors'
 import { DEBUG, INFO, NOTICE, TRACE, WARN } from './levels'
 import { logOptions } from './options'
@@ -14,13 +15,17 @@ let _output = logOptions.output
 let _indentSize = logOptions.indentSize
 let _taskLength = logOptions.taskLength
 let _lineLength = logOptions.lineLength
-let _inspectOptions = logOptions.inspectOptions
+let _inspectOptions = { ...logOptions.inspectOptions }
 logOptions.on('changed', (options) => {
   _output = options.output
   _indentSize = options.indentSize
   _taskLength = options.taskLength
   _lineLength = options.lineLength
-  _inspectOptions = options.inspectOptions
+  _inspectOptions = { ...options.inspectOptions } // proxy
+  _defaultEmitter =
+    options.format === 'fancy' ? emitFancy :
+    options.format === 'plain' ? emitPlain :
+    fail(`Invalid log format "${logOptions.format}"`)
 })
 
 /* ========================================================================== *
@@ -38,6 +43,12 @@ export interface LogEmitterOptions {
 /** Emit a line (or multiple lines) of text to the log */
 export type LogEmitter = (options: LogEmitterOptions, args: any[]) => void
 
+/** A {@link LogEmitter} function configurable with a specific emitter */
+export interface ConfigurableLogEmitter extends LogEmitter {
+  get emitter(): LogEmitter
+  set emitter(emitter: LogEmitter | undefined)
+}
+
 /* ========================================================================== */
 
 /** Emit in full colors with spinner support and whatnot! */
@@ -120,3 +131,55 @@ export const emitPlain: LogEmitter = (options: LogEmitterOptions, args: any[]):
     _output.write(`${linePrefix}${line}\n`)
   }
 }
+
+/* ========================================================================== */
+
+export interface ForkedLogMessage {
+  logLevel: LogLevel,
+  taskName: string,
+  lines: string[],
+}
+
+/** Emit to the parent process of a forked child, or to the default emitter */
+export const emitForked: LogEmitter = (options: LogEmitterOptions, args: any[]): void => {
+  if (process.connected && process.send) {
+    const { taskName, level, prefix = '', indent = 0 } = options
+    const linePrefix = ''.padStart(indent * _indentSize) + prefix
+
+    /* Now for the normal logging of all our parameters */
+    const breakLength = _lineLength - _taskLength - linePrefix.length - 20
+    const message = formatWithOptions({ ..._inspectOptions, breakLength }, ...args)
+
+    /* Format each individual line */
+    const lines = message.split('\n').map((line) => `${linePrefix}${line}`)
+
+    /* Send the message to the parent process */
+    process.send({ logLevel: level, taskName, lines })
+  } else {
+    _defaultEmitter(options, args)
+  }
+}
+
+/* ========================================================================== */
+
+/** The _default_ emitter (from `format`) */
+let _defaultEmitter =
+  logOptions.format === 'fancy' ? emitFancy :
+  logOptions.format === 'plain' ? emitPlain :
+  fail(`Invalid log format "${logOptions.format}"`)
+
+/** The _actual_ emitter (either default or configured) */
+let _emitter = _defaultEmitter
+
+/** Our `emit` wrapper function to export */
+const wrapper: LogEmitter = function emit(options: LogEmitterOptions, args: any[]): void {
+  _defaultEmitter(options, args)
+}
+
+/** A _configurable_ {@link LogEmitter} where log should be emitted to */
+export const emit = Object.defineProperty(wrapper, 'emitter', {
+  get: () => _emitter,
+  set: (emitter: LogEmitter | undefined) => {
+    _emitter = emitter || _defaultEmitter
+  },
+}) as ConfigurableLogEmitter

package/src/logging/github.ts

@@ -1,20 +1,15 @@
 import { EOL } from 'node:os'
 import { formatWithOptions } from 'node:util'
 
+import { stripAnsi } from '../utils/ansi'
 import { logOptions } from './options'
 
 import type { AbsolutePath } from '../paths'
 
-/* Strip ANSI from strings */
-const ansiRegExp = new RegExp([
-  '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
-  '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))',
-].join('|'), 'g')
-
 /* Initial values, and subscribe to changes */
 let _output = logOptions.output
-let _inspectOptions = logOptions.inspectOptions
 let _githubAnnotations = logOptions.githubAnnotations
+let _inspectOptions = { ...logOptions.inspectOptions, breakLength: Infinity }
 logOptions.on('changed', (options) => {
   _output = options.output
   _githubAnnotations = options.githubAnnotations
@@ -23,16 +18,14 @@ logOptions.on('changed', (options) => {
 
 
 function escapeData(data: string): string {
-  return data
-      .replace(ansiRegExp, '')
+  return stripAnsi(data)
       .replace(/%/g, '%25')
       .replace(/\r/g, '%0D')
       .replace(/\n/g, '%0A')
 }
 
 function escapeProp(prop: string | number): string {
-  return `${prop}`
-      .replace(ansiRegExp, '')
+  return stripAnsi(`${prop}`)
       .replace(/%/g, '%25')
       .replace(/\r/g, '%0D')
       .replace(/\n/g, '%0A')

package/src/logging/logger.ts

@@ -1,8 +1,10 @@
 import { formatWithOptions } from 'node:util'
 
 import { BuildFailure } from '../asserts'
+import { currentContext } from '../async'
+import { stripAnsi } from '../utils/ansi'
 import { $gry } from './colors'
-import { emitFancy, emitPlain } from './emit'
+import { emit } from './emit'
 import { DEBUG, ERROR, INFO, NOTICE, TRACE, WARN } from './levels'
 import { logOptions } from './options'
 import { ReportImpl } from './report'
@@ -16,11 +18,7 @@ import type { Report } from './report'
 
 /* Initial value of log colors, and subscribe to changes */
 let _level = logOptions.level
-let _format = logOptions.format
-let _defaultTaskName = logOptions.defaultTaskName
-logOptions.on('changed', ({ defaultTaskName, format, level }) => {
-  _defaultTaskName = defaultTaskName
-  _format = format
+logOptions.on('changed', ({ level }) => {
   _level = level
 })
 
@@ -50,6 +48,8 @@ export interface Log {
 export interface Logger extends Log {
   /** The current level for logging. */
   level: LogLevel,
+  /** The current indent level for logging. */
+  indent: number,
 
   /** Enter a sub-level of logging, increasing indent */
   enter(): void
@@ -64,36 +64,31 @@ export interface Logger extends Log {
 }
 
 /** Return a {@link Logger} associated with the specified task name. */
-export function getLogger(task: string = _defaultTaskName): Logger {
-  let logger = _loggers.get(task)
-  if (! logger) {
-    const emitter = _format === 'fancy' ? emitFancy : emitPlain
-    logger = new LoggerImpl(task, emitter)
-    _loggers.set(task, logger)
-  }
-  return logger
+export function getLogger(task?: string, indent?: number): Logger {
+  const context = currentContext()
+  const taskName = task === undefined ? (context?.taskName || '') : task
+  const indentLevel = indent === undefined ? (context?.log.indent || 0) : 0
+  return new LoggerImpl(taskName, emit, indentLevel)
 }
 
 /* ========================================================================== */
 
-/** Cache of loggers by task-name. */
-const _loggers = new Map<string, Logger>()
 /** Weak set of already logged build failures */
 const _loggedFailures = new WeakSet<BuildFailure>()
 
 /** Default implementation of the {@link Logger} interface. */
 class LoggerImpl implements Logger {
   private readonly _stack: { level: LogLevel, message: string, indent: number }[] = []
-  private _level = _level
-  private _indent = 0
+  public level = _level
 
   constructor(
       private readonly _task: string,
       private readonly _emitter: LogEmitter,
+      public indent: number,
   ) {}
 
-  private _emit(level: LogLevel, args: [ any, ...any ]): void {
-    if (this._level > level) return
+  private _emit(level: LogLevel, args: [ any, ...any ], taskName = this._task): void {
+    if (this.level > level) return
 
     // The `BuildFailure` is a bit special case
     const params = args.filter((arg) => {
@@ -123,7 +118,7 @@ class LoggerImpl implements Logger {
     if (params.length === 0) return
 
     // Prepare our options for logging
-    const options = { level, taskName: this._task, indent: this._indent }
+    const options = { level, taskName, indent: this.indent }
 
     // Dump any existing stack entry
     if (this._stack.length) {
@@ -137,14 +132,6 @@ class LoggerImpl implements Logger {
     this._emitter(options, params)
   }
 
-  get level(): LogLevel {
-    return this._level
-  }
-
-  set level(level: LogLevel) {
-    this._level = level
-  }
-
   trace(...args: [ any, ...any ]): void {
     this._emit(TRACE, args)
   }
@@ -179,19 +166,19 @@ class LoggerImpl implements Logger {
   enter(...args: [] | [ level: LogLevel, message: string ]): void {
     if (args.length) {
       const [ level, message ] = args
-      this._stack.push({ level, message, indent: this._indent })
+      this._stack.push({ level, message, indent: this.indent })
     }
 
-    this._indent ++
+    this.indent ++
   }
 
   leave(): void
   leave(level: LogLevel, message: string): void
   leave(...args: [] | [ level: LogLevel, message: string ]): void {
     this._stack.pop()
-    this._indent --
+    this.indent --
 
-    if (this._indent < 0) this._indent = 0
+    if (this.indent < 0) this.indent = 0
 
     if (args.length) {
       const [ level, message ] = args
@@ -209,8 +196,8 @@ class LoggerImpl implements Logger {
       }
 
       let { indent = 0, prefix = '' } = options
-      prefix = this._indent ? $gry('| ') + prefix : prefix
-      indent += this._indent
+      prefix = this.indent ? $gry('| ') + prefix : prefix
+      indent += this.indent
       this._emitter({ ...options, indent, prefix }, args)
     }
     return new ReportImpl(title, this._task, emitter)
@@ -219,12 +206,7 @@ class LoggerImpl implements Logger {
 
 /* ========================================================================== */
 
-/** 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 */
+/** A test logger, writing to a buffer always _without_ colors/indent */
 export class TestLogger extends LoggerImpl {
   private _lines: string[] = []
 
@@ -236,10 +218,10 @@ export class TestLogger extends LoggerImpl {
       /* Now for the normal logging of all our parameters */
       formatWithOptions({ colors: false, breakLength: 120 }, ...args)
           .split('\n').forEach((line) => {
-            const stripped = line.replaceAll(ansiRegExp, '')
+            const stripped = stripAnsi(line)
             this._lines.push(`${linePrefix}${stripped}`)
           })
-    })
+    }, 0)
   }
 
   /** Return the _current_ buffer for this instance */

package/src/logging/options.ts

@@ -1,5 +1,4 @@
 import { EventEmitter } from 'node:events'
-import { Socket } from 'node:net'
 
 import { getSingleton } from '../utils/singleton'
 import { getLevelNumber, NOTICE } from './levels'
@@ -30,16 +29,12 @@ export interface LogOptions {
   indentSize: number,
   /** Whether to show sources in reports or not. */
   showSources: boolean,
-  /** The task name to be used by default if a task is not contextualized. */
-  defaultTaskName: string,
   /** Whether GitHub annotations are enabled or not. */
   githubAnnotations: boolean,
+
   /** The options used by NodeJS for object inspection. */
   readonly inspectOptions: InspectOptions,
 
-  /** Set an inspect option in {@link LogOptions.inspectOptions}). */
-  setInspectOption<K extends keyof InspectOptions>(key: K, value: InspectOptions[K]): void
-
   /** Add an event listener for the specified event. */
   on(eventName: 'changed', listener: (logOptions: this) => void): this;
   /** Add an event listener for the specified event triggering only once. */
@@ -51,9 +46,8 @@ export interface LogOptions {
    * Return a record of environment variables for forking.
    *
    * @param taskName The default task name of the forked process
-   * @param logFd A file descriptor where logs should be sinked to
    */
-  forkEnv(taskName?: string, logFd?: number): Record<string, string>
+  forkEnv(taskName?: string): Record<string, string>
 }
 
 /* ========================================================================== *
@@ -72,7 +66,6 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
   private _showSources = true // by default, always show source snippets
   private _githubAnnotations = false // ultimately set by the constructor
   private _inspectOptions: InspectOptions = {}
-  private _defaultTaskName = ''
   private _taskLength = 0
   private _indentSize = 2
 
@@ -104,12 +97,7 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
      * and it's processed _last_ as it's normally only created by fork below
      * and consumed by the `Exec` plug (which has no other way of communicating)
      */
-    const { fd, ...options } = JSON.parse(process.env.__LOG_OPTIONS || '{}')
-    if (fd) {
-      const output = new Socket({ fd, readable: false, writable: true }).unref()
-      process.on('beforeExit', () => output.end())
-      this._output = output
-    }
+    const options = JSON.parse(process.env.__LOG_OPTIONS || '{}')
     Object.assign(this, options)
   }
 
@@ -117,17 +105,19 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
     super.emit('changed', this)
   }
 
-  forkEnv(taskName?: string, fd?: number): Record<string, string> {
+  forkEnv(taskName?: string): Record<string, string> {
+    void taskName
     return {
       __LOG_OPTIONS: JSON.stringify({
         level: this._level,
         colors: this._colors,
+        format: this._format,
         lineLength: this._lineLength,
         taskLength: this._taskLength,
+        showSources: this._showSources,
         githubAnnotations: this.githubAnnotations,
-        defaultTaskName: taskName || this._defaultTaskName,
+        indentSize: this.indentSize,
         spinner: false, // forked spinner is always false
-        fd, // file descriptor for logs
       }),
     }
   }
@@ -159,6 +149,7 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
   set colors(color: boolean) {
     this._colors = color
     this._colorsSet = true
+    this._inspectOptions.colors = color
     this._notifyListeners()
   }
 
@@ -218,15 +209,6 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
     this._notifyListeners()
   }
 
-  get defaultTaskName(): string {
-    return this._defaultTaskName
-  }
-
-  set defaultTaskName(defaultTaskName: string) {
-    this._defaultTaskName = defaultTaskName
-    this._notifyListeners()
-  }
-
   get githubAnnotations(): boolean {
     return this._githubAnnotations
   }
@@ -237,16 +219,26 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
   }
 
   get inspectOptions(): InspectOptions {
-    return {
-      colors: this._colors,
-      breakLength: this._lineLength,
-      ...this._inspectOptions,
-    }
-  }
-
-  setInspectOption<K extends keyof InspectOptions>(key: K, value: InspectOptions[K]): void {
-    this._inspectOptions[key] = value
-    this._notifyListeners()
+    return new Proxy(this._inspectOptions, {
+      get: (target, prop): any => {
+        if (prop === 'colors') return this.colors
+        if (prop === 'breakLength') return this._lineLength
+        return (target as any)[prop]
+      },
+      set: (target, prop, value): boolean => {
+        if (prop === 'colors') {
+          this.colors = !! value
+        } else if (prop === 'breakLength') {
+          const length = parseInt(value)
+          if (isNaN(length)) return false
+          this.lineLength = length
+        } else {
+          (target as any)[prop] = value
+        }
+        this._notifyListeners()
+        return true
+      },
+    })
   }
 }
 

package/src/logging.ts

@@ -2,6 +2,7 @@ import { currentContext } from './async'
 import { $gry, $wht } from './logging/colors'
 import { getLogger } from './logging/logger'
 import { setupSpinner } from './logging/spinner'
+import { stripAnsi } from './utils/ansi'
 
 import type { Log, Logger } from './logging/logger'
 
@@ -75,13 +76,14 @@ export const log: LogFunction = ((): LogFunction => {
 
 /** 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
+  const length = stripAnsi(message).length
+  const padLines = length > 60 ? length + 2 : 62
+  const padBlank = length > 60 ? 0 : 60 - length
 
   log.notice([
     '',
     $gry(`\u2554${''.padStart(padLines, '\u2550')}\u2557`),
-    `${$gry('\u2551')} ${$wht(message.padEnd(padMessage, ' '))} ${$gry('\u2551')}`,
+    `${$gry('\u2551')} ${$wht(message)}${''.padEnd(padBlank, ' ')} ${$gry('\u2551')}`,
     $gry(`\u255A${''.padStart(padLines, '\u2550')}\u255D`),
     '',
   ].join('\n'))

package/src/plugs/exports.ts

@@ -1,6 +1,7 @@
 import { EOL } from 'node:os'
 import { sep } from 'node:path'
 
+import { assert } from '../asserts'
 import { Files } from '../files'
 import { readFile, writeFile } from '../fs'
 import { $p } from '../logging'
@@ -76,7 +77,7 @@ install('exports', class Exports implements Plug<Files> {
       packageData.type === 'commonjs' ? 'commonjs' :
       packageData.type == null ? 'commonjs' :
       undefined
-    if (! type) context.log.fail(`Unknown module type "${packageData.type}" in ${$p(incomingFile)}`)
+    assert(type, `Unknown module type "${packageData.type}" in ${$p(incomingFile)}`)
 
     context.log.debug(`Package file ${$p(incomingFile)} declares module type "${type}"`)
 
@@ -84,9 +85,7 @@ install('exports', class Exports implements Plug<Files> {
     const esmExtension = this._esmExtension || (type === 'module' ? '.js' : '.mjs')
 
     // reject when commonjs and ecmascript modules have the same extension
-    if (cjsExtension === esmExtension) {
-      context.log.fail(`CommonJS and EcmaScript modules both resolve to same extension "${cjsExtension}"`)
-    }
+    assert(cjsExtension !== esmExtension, `CommonJS and EcmaScript modules both resolve to same extension "${cjsExtension}"`)
 
     const exports: ExportsDeclaration = {}
     function addExport(

package/src/utils/ansi.ts

@@ -0,0 +1,10 @@
+/** A {@link RegExp} matching ANSI escapes */
+export const ansiRegExp = new RegExp([
+  '[\\u001B\\u009B][[\\]()#;?]*(?:(?:(?:(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]+)*|[a-zA-Z\\d]+(?:;[-a-zA-Z\\d\\/#&.:=?%@~_]*)*)?\\u0007)',
+  '(?:(?:\\d{1,4}(?:;\\d{0,4})*)?[\\dA-PR-TZcf-nq-uy=><~]))',
+].join('|'), 'g')
+
+/** Strip ANSI characters (colors) from a string */
+export function stripAnsi(string: string): string {
+  return string && string.replace(ansiRegExp, '')
+}

package/src/utils/exec.ts

@@ -3,7 +3,7 @@ import path from 'node:path'
 import readline from 'node:readline'
 
 import { assert, BuildFailure } from '../asserts'
-import { $p } from '../logging'
+import { $p, logOptions } from '../logging'
 import { getCurrentWorkingDirectory, resolveDirectory } from '../paths'
 
 import type { SpawnOptions } from 'node:child_process'
@@ -56,7 +56,12 @@ export async function execChild(
 
   // Build our environment variables record
   const PATH = childPaths.join(path.delimiter)
-  const childEnv: Record<string, string> = { ...process.env, ...env, PATH }
+  const childEnv: Record<string, string> = {
+    ...process.env, // environment from current running process
+    ...env, // environment configured from "execChild" arguments
+    ...logOptions.forkEnv(), // forked log options for child plugjs
+    PATH, // path with all ".../node_modules/.bin" directories
+  }
 
   // Instrument coverage directory if needed
   if (coverageDir) childEnv.NODE_V8_COVERAGE = context.resolve(coverageDir)

package/src/utils.ts

@@ -1,3 +1,4 @@
+export * from './utils/ansi'
 export * from './utils/diff'
 export * from './utils/exec'
 export * from './utils/jsonc'