@tapjs/processinfo 1.0.0

package/LICENSE

@@ -0,0 +1,15 @@
+The ISC License
+
+Copyright (c) 2022 Isaac Z. Schlueter and Contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR
+IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,97 @@
+# @tapjs/processinfo
+
+A Node.js loader to track processes and which JavaScript files they load.
+
+After the process has run, all wrapped process info is dumped to
+`.tap/processinfo`.
+
+The exported object can also be used to spawn processes, clear the
+processinfo data, or load the processinfo data.
+
+## USAGE
+
+Run the top level process with a `--loader` or `--require` argument to
+track all Node.js child processes.
+
+```sh
+# wrap both CommonJS and ESM
+node --loader=@tapjs/processinfo/esm file.js
+
+# wrap only CommonJS
+node --require=@tapjs/processinfo/cjs
+```
+
+To spawn a wrapped process from JavaScript, you can run:
+
+```js
+const ProcessInfo = require('@tapjs/processinfo')
+// any of these will work
+const childProcess = ProcessInfo.spawn(cmd, args, options)
+const childProcess = ProcessInfo.exec(cmd, options)
+const childProcess = ProcessInfo.spawnSync(cmd, args, options)
+const childProcess = ProcessInfo.execSync(cmd, options)
+```
+
+The `cmd` and `args` parameters are identical to the methods from the
+Node.js `child_process` module. The `options` parameter is also identical,
+but may also include an `externalID` field, which if set to a string, will
+be used as the processinfo `externalID`.
+
+If you just use the normal `spawn`/`exec` methods from the Node.js
+`child_process` module, then the relevant environment variables will still
+be tracked, unless explicitly set to `''` or some other value.
+
+### Interacting with Process Info
+
+To load the process info data, use the exported `ProcessInfo` class.
+
+```js
+const ProcessInfo = require('@tapjs/processinfo')
+
+const processInfo = new ProcessInfo()
+// returns
+// {
+//   roots: Set([ProcessInfo.Node, ...]) for each root process group
+//   files: Map({ filename => Set([ProcessInfo.Node, ...]) }),
+//   externalIDs: Map({ externalID => ProcessInfo.Node }),
+//   uuids: Map({ uuid => ProcessInfo.Node }),
+// }
+// A ProcessInfo.Node looks like:
+// {
+//   date: iso date string,
+//   argv,
+//   execArgv,
+//   cwd,
+//   pid,
+//   ppid,
+//   uuid,
+//   externalID,
+//   parent: <ProcessInfo.Node or null for root node>,
+//   root: <ProcessInfo.Node>,
+//   children: [ProcessInfo.Node, ...],
+//   files: [ filename, ... ],
+//   code: unix exit code,
+//   signal: terminating signal or null,
+//   runtime: high resolution run time in ms,
+// }
+const data = await processInfo.load()
+// say we wanted to find all the files loaded by the process 'foo'
+const proc = data.externalIDs.get('foo')
+console.error(`Files loaded by process named 'foo':`, proc.files)
+
+// now let's find all any other named processes that loaded them
+for (const f of proc.files) {
+  for (const otherProc of data.files.get(f)) {
+    // walk up the tree looking for a named process
+    for (let parent = otherProc; parent; parent = parent.parent) {
+      if (parent.externalID && parent !== proc) {
+        console.error(`Also loaded by process ${parent.externalID}`)
+      }
+    }
+  }
+}
+```
+
+Note: unless there has been a previous wrapped process run, nothing will be
+present in the data. That is, `data.root` will be null, and all the maps
+will be empty.

package/lib/argv-to-node-options.cjs

@@ -0,0 +1,2 @@
+exports.argvToNodeOptions = argv =>
+  argv.map(o => `"${o.replace(/"/g, '\\"')}"`).join(' ')

package/lib/child_process.cjs

@@ -0,0 +1,63 @@
+const {
+  spawn,
+  spawnSync,
+  exec,
+  execSync,
+  execFile,
+  execFileSync,
+} = require('child_process')
+const { getExclude } = require('./get-exclude.cjs')
+const { spawnOpts } = require('./spawn-opts.cjs')
+const k = '_TAPJS_PROCESSINFO_EXCLUDE_'
+
+module.exports = {
+  spawn(cmd, args, options) {
+    return spawn(cmd, args, spawnOpts(options, getExclude(k)))
+  },
+
+  spawnSync(cmd, args, options) {
+    return spawnSync(cmd, args, spawnOpts(options, getExclude(k)))
+  },
+
+  exec(cmd, options, callback) {
+    if (typeof options === 'function') {
+      callback = options
+      options = {}
+    }
+
+    return exec(cmd, spawnOpts(options, getExclude(k)), callback)
+  },
+
+  execSync(cmd, options) {
+    return execSync(cmd, spawnOpts(options, getExclude(k)))
+  },
+
+  execFile(cmd, ...execFileArgs) {
+    let args = []
+    let options = {}
+    let callback = undefined
+    for (const arg of execFileArgs) {
+      if (Array.isArray(arg)) {
+        args = arg
+      } else if (arg && typeof arg === 'object') {
+        options = arg
+      } else if (typeof arg === 'function') {
+        callback = arg
+      }
+    }
+    return execFile(cmd, args, spawnOpts(options, getExclude(k)), callback)
+  },
+
+  execFileSync(cmd, ...execFileArgs) {
+    let args = []
+    let options = {}
+    for (const arg of execFileArgs) {
+      if (Array.isArray(arg)) {
+        args = arg
+      } else if (arg && typeof arg === 'object') {
+        options = arg
+      }
+    }
+    return execFileSync(cmd, args, spawnOpts(options, getExclude(k)))
+  },
+}

package/lib/cjs.cjs

@@ -0,0 +1,16 @@
+// commonjs style loader hook
+const { getProcessInfo } = require('./get-process-info.cjs')
+const { getExclude } = require('./get-exclude.cjs')
+
+// have to make this a module-local, otherwise it reloads the info
+const processInfo = getProcessInfo()
+const exclude = getExclude('_TAPJS_PROCESSINFO_EXCLUDE_')
+
+const { addHook } = require('pirates')
+
+const matcher = filename => !exclude.test(filename)
+const hook = (code, filename) => {
+  processInfo.files.push(filename)
+  return code
+}
+addHook(hook, { exts: ['.js', '.cjs'], matcher })

package/lib/esm.mjs

@@ -0,0 +1,44 @@
+// usage: node '--loader=esm.mjs?other-loader&otherotherloader' foo.mjs
+import { fileURLToPath } from 'url'
+import { getProcessInfo } from './get-process-info.cjs'
+import { getExclude } from './get-exclude.cjs'
+import './cjs.cjs'
+
+const processInfo = getProcessInfo()
+const exclude = getExclude('_TAPJS_PROCESSINFO_EXCLUDE_')
+
+const others = Promise.all(
+  [...new URL(import.meta.url).searchParams.keys()].map(s =>
+    import(s).catch(() => ({}))
+  )
+)
+const hasLoad = (async () =>
+  (await others).filter(loader => typeof loader.load === 'function'))()
+const hasResolve = (async () =>
+  (await others).filter(loader => typeof loader.resolve === 'function'))()
+
+const myLoad = defaultFn => async (url, context) => {
+  if (/^file:/.test(url)) {
+    const filename = fileURLToPath(url)
+    if (!exclude.test(filename)) {
+      processInfo.files.push(filename)
+    }
+  }
+  return defaultFn(url, context, defaultFn)
+}
+
+export const load = async (url, context, defaultFn) =>
+  runAll(await hasLoad, 'load', url, context, myLoad(defaultFn))
+
+export const resolve = async (url, context, defaultFn) =>
+  runAll(await hasResolve, 'resolve', url, context, defaultFn)
+
+const runAll = async (set, method, url, context, defaultFn, i = 0) => {
+  if (i >= set.length) {
+    return defaultFn(url, context, defaultFn)
+  } else {
+    return set[i][method](url, context, (url, context, _) =>
+      runAll(set, method, url, context, defaultFn, i + 1)
+    )
+  }
+}

package/lib/get-exclude.cjs

@@ -0,0 +1,21 @@
+const defaultExclude =
+  /(^|[\\/])(node_modules|\.tap|tap-testdir-.*?|tap-snapshots|tests?|[^\/]+\.test\.[cm]?js|__tests?__)([\\/]|$)/i
+
+const parseExclude = src => {
+  const parsed = src.match(/^\/(.*)\/([a-z]*)$/)
+  if (parsed) {
+    try {
+      return new RegExp(parsed[1], parsed[2])
+    } catch (e) {}
+  }
+}
+
+const getExclude = k => {
+  const src = process.env[k]
+  const exclude = (src && parseExclude(src)) || defaultExclude
+  process.env[k] = String(exclude)
+  return exclude
+}
+
+exports.defaultExclude = defaultExclude
+exports.getExclude = getExclude

package/lib/get-process-info.cjs

@@ -0,0 +1,45 @@
+const { v4: uuid } = require('uuid')
+
+const envKey = k => `_TAPJS_PROCESSINFO_${k.toUpperCase()}_`
+const getEnv = k => process.env[envKey(k)]
+const setEnv = (k, v) => (process.env[envKey(k)] = v)
+const delEnv = k => delete process.env[envKey(k)]
+
+let processInfo = null
+const getProcessInfo = () => {
+  if (!processInfo) {
+    require('./register-env.cjs')
+    require('./register-coverage.cjs')
+    require('./register-process-end.cjs')
+    processInfo = {
+      hrstart: process.hrtime(),
+      date: new Date().toISOString(),
+      argv: process.argv,
+      execArgv: process.execArgv,
+      NODE_OPTIONS: process.env.NODE_OPTIONS,
+      cwd: process.cwd(),
+      pid: process.pid,
+      ppid: process.ppid,
+      parent: getEnv('parent') || null,
+      uuid: uuid(),
+      files: [],
+    }
+
+    if (!processInfo.parent) {
+      processInfo.root = processInfo.uuid
+      setEnv('root', processInfo.uuid)
+    } else {
+      processInfo.root = getEnv('root')
+    }
+    // this is the parent of any further child processes
+    setEnv('parent', processInfo.uuid)
+    const externalID = getEnv('external_id')
+    if (externalID) {
+      processInfo.externalID = externalID
+      // externalID only applies to ONE process, not all its children.
+      delEnv('external_id')
+    }
+  }
+  return processInfo
+}
+module.exports = { getProcessInfo }

package/lib/index.cjs

@@ -0,0 +1,163 @@
+const {
+  spawn,
+  spawnSync,
+  exec,
+  execSync,
+  execFile,
+  execFileSync,
+} = require('./child_process.cjs')
+
+const { resolve, basename } = require('path')
+
+const { ProcessInfoNode } = require('./process-info-node.cjs')
+
+const {
+  writeFileSync,
+  readdirSync,
+  rmSync,
+  rmdirSync,
+  mkdirSync,
+} = require('fs')
+const { writeFile, readdir, rm, rmdir, mkdir } = require('fs/promises')
+
+const { safeJSONSync, safeJSON } = require('./json-file.cjs')
+
+class ProcessInfo {
+  constructor({
+    dir = resolve(process.cwd(), '.tap/processinfo'),
+    exclude = /(^|\\|\/)node_modules(\\|\/|$)/,
+  } = {}) {
+    this.dir = dir
+    this.exclude = exclude
+    this.roots = new Set()
+    this.files = new Map()
+    this.uuids = new Map()
+    this.pendingRoot = new Map()
+    this.pendingParent = new Map()
+    this.externalIDs = new Map()
+  }
+
+  clear() {
+    this.roots.clear()
+    this.files.clear()
+    this.uuids.clear()
+    this.externalIDs.clear()
+  }
+
+  async save() {
+    await mkdir(this.dir, { recursive: true })
+    const writes = []
+    for (const [uuid, info] of this.uuids.entries()) {
+      const f = `${this.dir}/${uuid}.json`
+      writes.push(writeFile(f, JSON.stringify(info) + '\n', 'utf8'))
+    }
+    await Promise.all(writes)
+  }
+
+  async saveSync() {
+    mkdirSync(this.dir, { recursive: true })
+    for (const [uuid, info] of this.uuids.entries()) {
+      const f = `${this.dir}/${uuid}.json`
+      writeFileSync(f, JSON.stringify(info) + '\n', 'utf8')
+    }
+  }
+
+  async erase() {
+    this.clear()
+    /* istanbul ignore next - node version compat */
+    try {
+      await rm(this.dir, { recursive: true })
+    } catch (e) {
+      await rmdir(this.dir, { recursive: true })
+    }
+  }
+
+  eraseSync() {
+    this.clear()
+    /* istanbul ignore next - node version compat */
+    try {
+      rmSync(this.dir, { recursive: true })
+    } catch (e) {
+      rmdirSync(this.dir, { recursive: true })
+    }
+  }
+
+  async load() {
+    const promises = []
+    for (const entry of await readdir(this.dir).catch(() => [])) {
+      const uuid = basename(entry, '.json')
+      if (this.uuids.has(uuid)) {
+        continue
+      }
+      const f = resolve(this.dir, entry)
+      promises.push(
+        safeJSON(f).then(data => {
+          if (!data.uuid || data.uuid !== uuid) {
+            return
+          }
+          new ProcessInfoNode(data).link(this)
+        })
+      )
+    }
+    await Promise.all(promises)
+
+    return this
+  }
+
+  loadSync() {
+    let entries
+    try {
+      entries = readdirSync(this.dir)
+    } catch (_) {
+      entries = []
+    }
+    for (const entry of entries) {
+      const uuid = basename(entry, '.json')
+      if (this.uuids.has(uuid)) {
+        continue
+      }
+      const f = resolve(this.dir, entry)
+      const data = safeJSONSync(f)
+      if (!data.uuid || data.uuid !== uuid) {
+        continue
+      }
+      new ProcessInfoNode(data).link(this)
+    }
+
+    return this
+  }
+
+  static get Node() {
+    return ProcessInfoNode
+  }
+
+  static get ProcessInfo() {
+    return ProcessInfo
+  }
+
+  static get spawn() {
+    return spawn
+  }
+
+  static get spawnSync() {
+    return spawnSync
+  }
+
+  static get exec() {
+    return exec
+  }
+
+  static get execSync() {
+    return execSync
+  }
+
+  static get execFile() {
+    return execFile
+  }
+
+  static get execFileSync() {
+    return execFileSync
+  }
+}
+
+module.exports = ProcessInfo

package/lib/json-file.cjs

@@ -0,0 +1,19 @@
+// read the file and json decode it, if anything fails, return {}
+
+const { readFile } = require('fs/promises')
+const { readFileSync } = require('fs')
+
+const safeJSONSync = f => {
+  try {
+    return JSON.parse(readFileSync(f, 'utf8'))
+  } catch (e) {
+    return {}
+  }
+}
+
+const safeJSON = f =>
+  readFile(f, 'utf8')
+    .then(d => JSON.parse(d))
+    .catch(() => ({}))
+
+module.exports = { safeJSON, safeJSONSync }

package/lib/node-options-env.cjs

@@ -0,0 +1,100 @@
+const cjsLoader = require.resolve('./cjs.cjs')
+const esmLoader = require.resolve('./esm.mjs')
+
+// esm --loader is actually last-wins, so only counts as having
+// it if it's the last loader in line.  To get around that, we pass
+// ALL loaders to our loader as ?a&b&c&...
+//
+// cjs --require stacks in order, so as long as it's there, it counts.
+
+const hasCJSLoader = args => hasLoader(args, ['-r', '--require'], cjsLoader)
+
+const hasESMLoader = args =>
+  hasLoader(args, ['--experimental-loader', '--loader'], esmLoader, true)
+
+const addCJS = args =>
+  !hasCJSLoader(args) ? args.concat('--require=' + cjsLoader) : args
+const addESM = args => squashLoaders(args)
+
+const cjsOnly = args => (hasESMLoader(args) ? false : hasCJSLoader(args))
+
+const { nodeOptionsToArgv } = require('./node-options-to-argv.cjs')
+const { argvToNodeOptions } = require('./argv-to-node-options.cjs')
+const { fileURLToPath, pathToFileURL } = require('url')
+
+const { resolve } = require('path')
+const resolveLoader = (path, isURI) => {
+  path = decode(path, isURI)
+  try {
+    return require.resolve(/^\.?\.[\\/]/.test(path) ? resolve(path) : path)
+  } catch (e) {
+    return path
+  }
+}
+
+const decode = (path, isURI) =>
+  !isURI
+    ? path
+    : /^file:/.test(path)
+    ? fileURLToPath(path)
+    : decodeURIComponent(path)
+
+const squashLoaders = args => {
+  const loaders = []
+  const re = /^--(?:experimental-)?loader(?:=(.*))?$/
+  const squashed = []
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    const parsed = arg.match(re)
+    if (!parsed) {
+      squashed.push(arg)
+      continue
+    }
+    const val = parsed[1] || args[++i]
+    if (!val) {
+      // --loader with no value anywhere, just put it back how it was
+      // and let node barf on it
+      squashed.push(arg, args[i - 1])
+      continue
+    }
+    const resolved = resolveLoader(val, true)
+    if (resolved === esmLoader) {
+      continue
+    }
+    loaders.push(encodeURIComponent(val.replace(/\\/g, '/')))
+  }
+  const q = loaders.length ? '?' : ''
+  squashed.push(`--loader=${pathToFileURL(esmLoader)}${q}${loaders.join('&')}`)
+  return squashed
+}
+
+const hasLoader = (args, keys, value, isURI = false) => {
+  value = decode(value, isURI)
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i]
+    // -r <value>
+    if (
+      keys.includes(arg) &&
+      i < args.length - 1 &&
+      resolveLoader(args[i + 1], isURI) === value
+    ) {
+      return true
+    } else if (arg.startsWith('--') && arg.includes('=')) {
+      // --require=<value>
+      const [k, ...rest] = arg.split('=')
+      if (keys.includes(k) && resolveLoader(rest.join('='), isURI) === value) {
+        return true
+      } else {
+        continue
+      }
+    }
+  }
+  return false
+}
+
+const nodeOptionsEnv = (env, args) => {
+  const no = nodeOptionsToArgv(env.NODE_OPTIONS)
+  return argvToNodeOptions(cjsOnly(args.concat(no)) ? addCJS(no) : addESM(no))
+}
+
+module.exports = { nodeOptionsEnv }

package/lib/node-options-to-argv.cjs

@@ -0,0 +1,52 @@
+exports.nodeOptionsToArgv = no => {
+  if (!no) return []
+  const argv = []
+  let escaping = false
+  let inquote = false
+  let tokStart = 0
+  let tok = ''
+  for (let i = 0; i < no.length; i++) {
+    const c = no.charAt(i)
+    switch (c) {
+      case '"':
+        if (escaping) {
+          tok += no.slice(tokStart, i - 1) + '"'
+          tokStart = i + 1
+          escaping = false
+        } else if (inquote) {
+          tok += no.slice(tokStart, i)
+          tokStart = i + 1
+          inquote = false
+        } else {
+          inquote = true
+          tok += no.slice(tokStart, i)
+          tokStart = i + 1
+        }
+        continue
+
+      case '\\':
+        if (inquote) {
+          escaping = true
+        }
+        continue
+
+      case ' ':
+        if (inquote) continue
+        tok += no.slice(tokStart, i)
+        tokStart = i + 1
+        argv.push(tok)
+        tok = ''
+        continue
+
+      default:
+        escaping = false
+        continue
+    }
+  }
+  if (inquote) {
+    return []
+  }
+  tok += no.slice(tokStart)
+  argv.push(tok)
+  return argv
+}

package/lib/process-info-node.cjs

@@ -0,0 +1,76 @@
+class ProcessInfoNode {
+  constructor(data) {
+    this.parent = null
+    this.children = null
+    this.files = null
+    Object.assign(this, data)
+  }
+
+  toJSON() {
+    return {
+      ...this,
+      root: this.root && this.root.uuid,
+      parent: this.parent && this.parent.uuid,
+      children: this.children && [...this.children].map(c => c.uuid),
+    }
+  }
+
+  link(db) {
+    db.uuids.set(this.uuid, this)
+    this.parent = db.uuids.get(this.parent) || this.parent || null
+    this.root = db.uuids.get(this.root) || this.root
+
+    if (this.parent === null) {
+      this.root = this
+      if (db.pendingRoot.has(this.uuid)) {
+        for (const n of db.pendingRoot.get(this.uuid)) {
+          n.root = this
+        }
+        db.pendingRoot.delete(this.uuid)
+      }
+      db.roots.add(this)
+    } else if (typeof this.root === 'string') {
+      if (db.pendingRoot.has(this.root)) {
+        db.pendingRoot.get(this.root).add(this)
+      } else {
+        db.pendingRoot.set(this.root, new Set([this]))
+      }
+    }
+
+    if (typeof this.parent === 'string') {
+      if (db.pendingParent.has(this.parent)) {
+        db.pendingParent.get(this.parent).add(this)
+      } else {
+        db.pendingParent.set(this.parent, new Set([this]))
+      }
+    } else if (this.parent !== null) {
+      if (!this.parent.children) {
+        this.parent.children = new Set([this])
+      } else {
+        this.parent.children.add(this)
+      }
+    }
+
+    if (db.pendingParent.has(this.uuid)) {
+      this.children = db.pendingParent.get(this.uuid)
+      for (const n of this.children) {
+        n.parent = this
+      }
+      db.pendingParent.delete(this.uuid)
+    }
+
+    for (const f of this.files) {
+      if (!db.files.has(f)) {
+        db.files.set(f, new Set([this]))
+      } else {
+        db.files.get(f).add(this)
+      }
+    }
+
+    if (this.externalID) {
+      db.externalIDs.set(this.externalID, this)
+    }
+  }
+}
+
+module.exports = { ProcessInfoNode }

package/lib/register-coverage.cjs

@@ -0,0 +1,74 @@
+// start tracking coverage, unless disabled explicltly
+// export so that we know to collect at the end of the process
+const enabled = process.env._TAPJS_PROCESSINFO_COVERAGE_ !== '0'
+if (enabled) {
+  process.env._TAPJS_PROCESSINFO_COVERAGE_ = '1'
+  process.setSourceMapsEnabled(true)
+
+  // NB: coverage exclusion is in addition to processinfo
+  // exclusion.  Only show coverage for a file we care
+  // about at least somewhat, but coverage is a subset.
+  const { getExclude } = require('./get-exclude.cjs')
+  const exclude = getExclude('_TAPJS_PROCESSINFO_COV_EXCLUDE_')
+  const inspector = require('inspector')
+  const session = new inspector.Session()
+  module.exports.session = session
+  session.connect()
+  session.post('Profiler.enable')
+  session.post('Runtime.enable')
+  session.post('Profiler.startPreciseCoverage', {
+    callCount: true,
+    detailed: true,
+  })
+
+  const { fileURLToPath } = require('url')
+  const { findSourceMap } = require('module')
+
+  const lineLengths = f =>
+    readFileSync(f, 'utf8')
+      .split(/\n|\u2028|\u2029/)
+      .map(l => l.length)
+
+  const { mkdirSync, writeFileSync, readFileSync } = require('fs')
+
+  const coverageOnProcessEnd = (cwd, processInfo) => {
+    const f = `${cwd}/.tap/coverage/${processInfo.uuid}.json`
+    mkdirSync(`${cwd}/.tap/coverage`, { recursive: true })
+
+    session.post('Profiler.takePreciseCoverage', (er, cov) => {
+      session.post('Profiler.stopPreciseCoverage')
+
+      /* istanbul ignore next - something very strange and bad happened */
+      if (er) {
+        throw er
+      }
+
+      const sourceMapCache = (cov['source-map-cache'] = {})
+      cov.result = cov.result.filter(obj => {
+        if (!/^file:/.test(obj.url)) {
+          return false
+        }
+        const f = fileURLToPath(obj.url)
+        if (!processInfo.files.includes(f) || exclude.test(f)) {
+          return false
+        }
+        // see if it has a source map
+        const s = findSourceMap(f)
+        if (s) {
+          const { payload } = s
+          sourceMapCache[obj.url] = Object.assign(Object.create(null), {
+            lineLengths: lineLengths(f),
+            data: payload,
+          })
+        }
+        return true
+      })
+
+      writeFileSync(f, JSON.stringify(cov, 0, 2) + '\n', 'utf8')
+    })
+  }
+
+  module.exports = { coverageOnProcessEnd }
+} else {
+  module.exports = { coverageOnProcessEnd: () => {} }
+}

package/lib/register-env.cjs

@@ -0,0 +1,21 @@
+const processOnSpawn = require('process-on-spawn')
+const hasOwn = (o, k) => Object.prototype.hasOwnProperty.call(o, k)
+
+processOnSpawn.addListener(obj => {
+  const env = obj.env || {}
+  obj.env = Object.assign(env, getEnvs(env))
+  return obj
+})
+
+const envRE = /^_TAPJS_PROCESSINFO_/
+
+const getEnvs = env => {
+  // load it here so that it isn't cached before the loader attaches
+  // in self-test scenario.
+  const { nodeOptionsEnv } = require('./node-options-env.cjs')
+  return Object.fromEntries(
+    Object.entries(process.env)
+      .filter(([k, v]) => !hasOwn(env, k) && envRE.test(k))
+      .concat([['NODE_OPTIONS', nodeOptionsEnv(env, process.execArgv)]])
+  )
+}

package/lib/register-process-end.cjs

@@ -0,0 +1,29 @@
+const onExit = require('signal-exit')
+const { getProcessInfo } = require('./get-process-info.cjs')
+
+const { mkdirSync, writeFileSync } = require('fs')
+const cwd = process.cwd()
+const globals = new Set(Object.keys(global))
+const { coverageOnProcessEnd } = require('./register-coverage.cjs')
+
+onExit(
+  (code, signal) => {
+    const processInfo = getProcessInfo()
+    processInfo.code = code
+    processInfo.signal = signal
+    const runtime = process.hrtime(processInfo.hrstart)
+    delete processInfo.hrstart
+    processInfo.files = [...new Set(processInfo.files)]
+    processInfo.runtime = runtime[0] * 1e3 + runtime[1] / 1e6
+    const globalsAdded = Object.keys(global).filter(k => !globals.has(k))
+    if (globalsAdded.length) {
+      processInfo.globalsAdded = globalsAdded
+    }
+
+    const f = `${cwd}/.tap/processinfo/${processInfo.uuid}.json`
+    mkdirSync(`${cwd}/.tap/processinfo`, { recursive: true })
+    writeFileSync(f, JSON.stringify(processInfo) + '\n', 'utf8')
+    coverageOnProcessEnd(cwd, processInfo)
+  },
+  { alwaysLast: true }
+)

package/lib/spawn-opts.cjs

@@ -0,0 +1,16 @@
+const { nodeOptionsEnv } = require('./node-options-env.cjs')
+
+const spawnOpts = (options = {}, exclude) => {
+  const { externalID } = options
+  const env = { ...(options.env || process.env) }
+  env.NODE_OPTIONS = nodeOptionsEnv(env, [])
+  if (externalID) {
+    env._TAPJS_PROCESSINFO_EXTERNAL_ID_ = externalID
+  }
+  if (exclude) {
+    env._TAPJS_PROCESSINFO_EXCLUDE_ = String(exclude)
+  }
+  return { ...options, env }
+}
+
+module.exports = { spawnOpts }

package/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@tapjs/processinfo",
+  "version": "1.0.0",
+  "main": "lib/index.cjs",
+  "files": [
+    "lib"
+  ],
+  "exports": {
+    ".": "./lib/index.cjs",
+    "./esm": "./lib/esm.mjs",
+    "./cjs": "./lib/cjs.cjs"
+  },
+  "scripts": {
+    "format": "prettier --write . --loglevel warn",
+    "test": "tap",
+    "snap": "tap",
+    "preversion": "npm test",
+    "postversion": "npm publish",
+    "prepublishOnly": "git push origin --follow-tags"
+  },
+  "tap": {
+    "coverage-map": "map.cjs"
+  },
+  "prettier": {
+    "semi": false,
+    "printWidth": 80,
+    "tabWidth": 2,
+    "useTabs": false,
+    "singleQuote": true,
+    "jsxSingleQuote": false,
+    "bracketSameLine": true,
+    "arrowParens": "avoid",
+    "endOfLine": "lf"
+  },
+  "dependencies": {
+    "pirates": "^4.0.5",
+    "process-on-spawn": "^1.0.0",
+    "tap": "^16.3.0",
+    "uuid": "^8.3.2"
+  },
+  "engines": {
+    "node": ">=16"
+  },
+  "license": "ISC",
+  "devDependencies": {
+    "@npmcli/promise-spawn": "^2.0.1",
+    "eslint-config-prettier": "^8.5.0",
+    "prettier": "^2.6.2",
+    "diff": "^5.0.0"
+  },
+  "repository": "https://github.com/tapjs/processinfo"
+}