@plugjs/plug 0.2.6 → 0.3.0

package/src/logging/options.ts

@@ -1,4 +1,5 @@
 import { EventEmitter } from 'node:events'
+import { Socket } from 'node:net'
 
 import { getLevelNumber, NOTICE } from './levels'
 
@@ -28,6 +29,8 @@ export interface LogOptions {
   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,
 
@@ -41,8 +44,13 @@ export interface LogOptions {
   /** Remove an event listener for the specified event. */
   off(eventName: 'changed', listener: (logOptions: this) => void): this;
 
-  /** Return a record of environment variables for forking. */
-  forkEnv(taskName?: string): Record<string, string>
+  /**
+   * 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>
 }
 
 /* ========================================================================== *
@@ -58,6 +66,7 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
   private _lineLength = (<NodeJS.WriteStream> this._output).columns || 80
   private _lineLengthSet = false // has line length been set manually?
   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
@@ -78,27 +87,34 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
       // Other values don't change the value of `options.colors`
     }
 
+    /* If the `GITHUB_ACTIONS` is `true` then enable annotations */
+    this._githubAnnotations = process.env.GITHUB_ACTIONS === 'true'
+
     /*
      * The `__LOG_OPTIONS` variable is a JSON-serialized `LogOptions` object
      * 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)
      */
-    Object.assign(this, JSON.parse(process.env.__LOG_OPTIONS || '{}'))
+    const { fd, ...options } = JSON.parse(process.env.__LOG_OPTIONS || '{}')
+    if (fd) this.output = new Socket({ fd }).unref()
+    Object.assign(this, options)
   }
 
   private _notifyListeners(): void {
     super.emit('changed', this)
   }
 
-  forkEnv(taskName?: string): Record<string, string> {
+  forkEnv(taskName?: string, fd?: number): Record<string, string> {
     return {
       __LOG_OPTIONS: JSON.stringify({
         level: this._level,
         colors: this._colors,
         lineLength: this._lineLength,
         taskLength: this._taskLength,
+        githubAnnotations: this.githubAnnotations,
         defaultTaskName: taskName || this._defaultTaskName,
         spinner: false, // forked spinner is always false
+        fd, // file descriptor for logs
       }),
     }
   }
@@ -189,6 +205,15 @@ class LogOptionsImpl extends EventEmitter implements LogOptions {
     this._notifyListeners()
   }
 
+  get githubAnnotations(): boolean {
+    return this._githubAnnotations
+  }
+
+  set githubAnnotations(githubAnnotations: boolean) {
+    this._githubAnnotations = githubAnnotations
+    this._notifyListeners()
+  }
+
   get inspectOptions(): InspectOptions {
     return {
       colors: this._colors,

package/src/logging/report.ts

@@ -1,13 +1,22 @@
 import { BuildFailure } from '../asserts'
 import { readFile } from '../fs'
 import { $blu, $cyn, $gry, $red, $und, $wht, $ylw } from './colors'
-import { ERROR, NOTICE, WARN } from './levels'
+import { ERROR, logLevels, NOTICE, WARN } from './levels'
 import { logOptions } from './options'
+import { githubAnnotation } from './github'
 
 import type { AbsolutePath } from '../paths'
 import type { LogEmitter } from './emit'
 import type { LogLevels } from './levels'
 
+let _showSources = logOptions.showSources
+let _githubAnnotations = logOptions.githubAnnotations
+logOptions.on('changed', (options) => {
+  _showSources = options.showSources
+  _githubAnnotations = options.githubAnnotations
+})
+
+
 /* ========================================================================== */
 
 /** Levels used in a {@link Report}  */
@@ -267,12 +276,12 @@ export class ReportImpl implements Report {
 
 
   done(showSources?: boolean | undefined): void {
-    if (showSources == null) showSources = logOptions.showSources
+    if (showSources == null) showSources = _showSources
     if (! this.empty) this._emit(showSources)
     if (this.errors) throw BuildFailure.fail()
   }
 
-  private _emit(showSources: boolean): this {
+  private _emit(showSources: boolean): void {
     /* Counters for all we need to print nicely */
     let fPad = 0
     let aPad = 0
@@ -281,7 +290,7 @@ export class ReportImpl implements Report {
     let cPad = 0
 
     /* Skip report all together if empty! */
-    if ((this._annotations.size === 0) && (this._records.size === 0)) return this
+    if ((this._annotations.size === 0) && (this._records.size === 0)) return
 
     /* This is GIANT: sort and convert our data for easy reporting */
     const entries = [ ...this._annotations.keys(), ...this._records.keys() ]
@@ -431,7 +440,32 @@ export class ReportImpl implements Report {
       this._emitter(options, [ '' ])
     }
 
-    /* Done! */
-    return this
+    /* Annotate in GitHub */
+    if (_githubAnnotations) {
+      for (const entry of entries) {
+        const file = entry.file === nul ? undefined : entry.file
+
+        for (const report of entry.records) {
+          const type: 'error' | 'warning' | null =
+            report.level === logLevels.ERROR ? 'error' :
+            report.level === logLevels.WARN ? 'warning' :
+            null
+
+          if (! type) continue
+
+          const title = `${this._title} (task "${this._task}")`
+          const col = report.column || undefined
+          const line = report.line || undefined
+          const endColumn =
+            report.column ?
+              report.length >= Number.MAX_SAFE_INTEGER ? undefined :
+              ((report.column + report.length) || undefined) :
+            undefined
+          const message = report.messages.join('\n')
+
+          githubAnnotation({ type, title, file, col, line, endColumn }, message)
+        }
+      }
+    }
   }
 }

package/src/logging.ts

@@ -3,6 +3,7 @@ import { getLogger, type Log } from './logging/logger'
 import { setupSpinner } from './logging/spinner'
 
 export * from './logging/colors'
+export * from './logging/github'
 export * from './logging/levels'
 export * from './logging/logger'
 export * from './logging/options'

package/src/utils/exec.ts

@@ -1,5 +1,5 @@
 import path from 'node:path'
-import reaadline from 'node:readline'
+import readline from 'node:readline'
 import { fork as forkProcess, spawn as spawnProcess } from 'node:child_process'
 
 import { assert, BuildFailure } from '../asserts'
@@ -62,7 +62,7 @@ export async function execChild(
 
   // Build our environment variables record
   const PATH = childPaths.join(path.delimiter)
-  const logForkEnv = logOptions.forkEnv(context.taskName)
+  const logForkEnv = logOptions.forkEnv(context.taskName, 4)
   const childEnv: Record<string, string> = { ...process.env, ...env, ...logForkEnv, PATH }
 
   // Instrument coverage directory if needed
@@ -71,32 +71,43 @@ export async function execChild(
   // Prepare the options for calling `spawn`
   const childOptions: SpawnOptions = {
     ...extraOptions,
-    stdio: [ 'ignore', 'pipe', 'pipe' ],
+    stdio: [ 'ignore', 'pipe', 'pipe', 'ipc', 'pipe' ],
     cwd: childCwd,
     env: childEnv,
     shell,
   }
 
-  // Add the 'ipc' channel to stdio options if forking
-  if (fork) childOptions.stdio = [ 'ignore', 'pipe', 'pipe', 'ipc' ]
-
   // Spawn our subprocess and monitor its stdout/stderr
-  context.log.info('Executing', [ cmd, ...args ])
-  context.log.info('Execution options', childOptions)
+  context.log.info(fork ? 'Forking' : 'Executing', [ cmd, ...args ])
+  context.log.debug('Child process options', childOptions)
+
   const child = fork ?
     forkProcess(cmd, args, childOptions) :
     spawnProcess(cmd, args, childOptions)
 
-  // Standard output to "notice"
-  if (child.stdout) {
-    const out = reaadline.createInterface(child.stdout)
-    out.on('line', (line) => line ? context.log.notice(line) : context.log.notice('\u00a0'))
-  }
-
-  // Standard error to "warning"
-  if (child.stderr) {
-    const err = reaadline.createInterface(child.stderr)
-    err.on('line', (line) => line ? context.log.warn(line) : context.log.warn('\u00a0'))
+  try {
+    context.log.info('Child process PID', child.pid)
+
+    // Standard output to "notice"
+    if (child.stdout) {
+      const out = readline.createInterface(child.stdout)
+      out.on('line', (line) => context.log.notice(line || '\u00a0'))
+    }
+
+    // Standard error to "warning"
+    if (child.stderr) {
+      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()
+    throw error
   }
 
   // Return our promise from the spawn events