@farthershore/cli 0.3.9 → 0.3.10

package/node_modules/pino/lib/transport-stream.js

@@ -0,0 +1,56 @@
+'use strict'
+
+const { realImport, realRequire } = require('real-require')
+
+module.exports = loadTransportStreamBuilder
+
+/**
+ * Loads & returns a function to build transport streams
+ * @param {string} target
+ * @returns {Promise<function(object): Promise<import('node:stream').Writable>>}
+ * @throws {Error} In case the target module does not export a function
+ */
+async function loadTransportStreamBuilder (target) {
+  let fn
+  try {
+    const toLoad = target.startsWith('file://') ? target : 'file://' + target
+
+    if (toLoad.endsWith('.ts') || toLoad.endsWith('.cts')) {
+      // TODO: add support for the TSM modules loader ( https://github.com/lukeed/tsm ).
+      if (process[Symbol.for('ts-node.register.instance')]) {
+        realRequire('ts-node/register')
+      } else if (process.env && process.env.TS_NODE_DEV) {
+        realRequire('ts-node-dev')
+      }
+      // TODO: Support ES imports once tsc, tap & ts-node provide better compatibility guarantees.
+      fn = realRequire(decodeURIComponent(target))
+    } else {
+      fn = (await realImport(toLoad))
+    }
+  } catch (error) {
+    // See this PR for details: https://github.com/pinojs/thread-stream/pull/34
+    if ((error.code === 'ENOTDIR' || error.code === 'ERR_MODULE_NOT_FOUND')) {
+      fn = realRequire(target)
+    } else if (error.code === undefined || error.code === 'ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING') {
+      // When bundled with pkg, an undefined error is thrown when called with realImport
+      // When bundled with pkg and using node v20, an ERR_VM_DYNAMIC_IMPORT_CALLBACK_MISSING error is thrown when called with realImport
+      // More info at: https://github.com/pinojs/thread-stream/issues/143
+      try {
+        fn = realRequire(decodeURIComponent(target))
+      } catch {
+        throw error
+      }
+    } else {
+      throw error
+    }
+  }
+
+  // Depending on how the default export is performed, and on how the code is
+  // transpiled, we may find cases of two nested "default" objects.
+  // See https://github.com/pinojs/pino/issues/1243#issuecomment-982774762
+  if (typeof fn === 'object') fn = fn.default
+  if (typeof fn === 'object') fn = fn.default
+  if (typeof fn !== 'function') throw Error('exported worker is not a function')
+
+  return fn
+}

package/node_modules/pino/lib/transport.js

@@ -0,0 +1,289 @@
+'use strict'
+
+const { createRequire } = require('module')
+const { existsSync } = require('node:fs')
+const getCallers = require('./caller')
+const { join, isAbsolute, sep } = require('node:path')
+const { fileURLToPath } = require('node:url')
+const sleep = require('atomic-sleep')
+const onExit = require('on-exit-leak-free')
+const ThreadStream = require('thread-stream')
+
+function setupOnExit (stream) {
+  // This is leak free, it does not leave event handlers
+  onExit.register(stream, autoEnd)
+  onExit.registerBeforeExit(stream, flush)
+
+  stream.on('close', function () {
+    onExit.unregister(stream)
+  })
+}
+
+// Check if preload flags exist in execArgv.
+// During preload phase (require.main undefined), we pass empty execArgv to prevent infinite worker spawning.
+// We don't try to filter and pass other flags because many (like --stack-trace-limit, --tls-cipher-list)
+// aren't valid for worker threads and would cause ERR_WORKER_INVALID_EXEC_ARGV.
+function hasPreloadFlags () {
+  const execArgv = process.execArgv
+  for (let i = 0; i < execArgv.length; i++) {
+    const arg = execArgv[i]
+    if (arg === '--import' || arg === '--require' || arg === '-r') {
+      return true
+    }
+    if (arg.startsWith('--import=') || arg.startsWith('--require=') || arg.startsWith('-r=')) {
+      return true
+    }
+  }
+  return false
+}
+
+function sanitizeNodeOptions (nodeOptions) {
+  const tokens = nodeOptions.match(/(?:[^\s"']+|"[^"]*"|'[^']*')+/g)
+  if (!tokens) {
+    return nodeOptions
+  }
+
+  const sanitized = []
+  let changed = false
+
+  for (let i = 0; i < tokens.length; i++) {
+    const token = tokens[i]
+
+    if (token === '--require' || token === '-r' || token === '--import') {
+      const next = tokens[i + 1]
+      if (next && shouldDropPreload(next)) {
+        changed = true
+        i++
+        continue
+      }
+
+      sanitized.push(token)
+      if (next) {
+        sanitized.push(next)
+        i++
+      }
+      continue
+    }
+
+    if (token.startsWith('--require=') || token.startsWith('-r=') || token.startsWith('--import=')) {
+      const value = token.slice(token.indexOf('=') + 1)
+      if (shouldDropPreload(value)) {
+        changed = true
+        continue
+      }
+    }
+
+    sanitized.push(token)
+  }
+
+  return changed ? sanitized.join(' ') : nodeOptions
+}
+
+function shouldDropPreload (value) {
+  const unquoted = stripQuotes(value)
+  if (!unquoted) {
+    return false
+  }
+
+  let path = unquoted
+  if (path.startsWith('file://')) {
+    try {
+      path = fileURLToPath(path)
+    } catch {
+      return false
+    }
+  }
+
+  return isAbsolute(path) && !existsSync(path)
+}
+
+function stripQuotes (value) {
+  const first = value[0]
+  const last = value[value.length - 1]
+
+  if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
+    return value.slice(1, -1)
+  }
+
+  return value
+}
+
+function buildStream (filename, workerData, workerOpts, sync, name) {
+  // When pino is loaded during a preload phase (via --import or --require),
+  // pass empty execArgv to prevent infinite spawning. Each worker would
+  // otherwise re-run the preload, creating another transport.
+  if (!workerOpts.execArgv && hasPreloadFlags() && require.main === undefined) {
+    workerOpts = {
+      ...workerOpts,
+      execArgv: []
+    }
+  }
+
+  if (!workerOpts.env && process.env.NODE_OPTIONS) {
+    const nodeOptions = sanitizeNodeOptions(process.env.NODE_OPTIONS)
+    if (nodeOptions !== process.env.NODE_OPTIONS) {
+      workerOpts = {
+        ...workerOpts,
+        env: {
+          ...process.env,
+          NODE_OPTIONS: nodeOptions
+        }
+      }
+    }
+  }
+
+  workerOpts = { ...workerOpts, name }
+
+  const stream = new ThreadStream({
+    filename,
+    workerData,
+    workerOpts,
+    sync
+  })
+
+  stream.on('ready', onReady)
+  stream.on('close', function () {
+    process.removeListener('exit', onExit)
+  })
+
+  process.on('exit', onExit)
+
+  function onReady () {
+    process.removeListener('exit', onExit)
+    stream.unref()
+
+    if (workerOpts.autoEnd !== false) {
+      setupOnExit(stream)
+    }
+  }
+
+  function onExit () {
+    /* istanbul ignore next */
+    if (stream.closed) {
+      return
+    }
+    stream.flushSync()
+    // Apparently there is a very sporadic race condition
+    // that in certain OS would prevent the messages to be flushed
+    // because the thread might not have been created still.
+    // Unfortunately we need to sleep(100) in this case.
+    sleep(100)
+    stream.end()
+  }
+
+  return stream
+}
+
+function autoEnd (stream) {
+  stream.ref()
+  stream.flushSync()
+  stream.end()
+  stream.once('close', function () {
+    stream.unref()
+  })
+}
+
+function flush (stream) {
+  stream.flushSync()
+}
+
+function transport (fullOptions) {
+  const { pipeline, targets, levels, dedupe, worker = {}, caller = getCallers(), sync = false } = fullOptions
+
+  const options = {
+    ...fullOptions.options
+  }
+
+  // Backwards compatibility
+  const callers = typeof caller === 'string' ? [caller] : caller
+
+  // This will be eventually modified by bundlers
+  const bundlerOverrides = (typeof globalThis === 'object' &&
+    Object.prototype.hasOwnProperty.call(globalThis, '__bundlerPathsOverrides') &&
+    globalThis.__bundlerPathsOverrides &&
+    typeof globalThis.__bundlerPathsOverrides === 'object')
+    ? globalThis.__bundlerPathsOverrides
+    : Object.create(null)
+
+  let target = fullOptions.target
+
+  if (target && targets) {
+    throw new Error('only one of target or targets can be specified')
+  }
+
+  if (targets) {
+    target = bundlerOverrides['pino-worker'] || join(__dirname, 'worker.js')
+    options.targets = targets.filter(dest => dest.target).map((dest) => {
+      return {
+        ...dest,
+        target: fixTarget(dest.target)
+      }
+    })
+    options.pipelines = targets.filter(dest => dest.pipeline).map((dest) => {
+      return dest.pipeline.map((t) => {
+        return {
+          ...t,
+          level: dest.level, // duplicate the pipeline `level` property defined in the upper level
+          target: fixTarget(t.target)
+        }
+      })
+    })
+  } else if (pipeline) {
+    target = bundlerOverrides['pino-worker'] || join(__dirname, 'worker.js')
+    options.pipelines = [pipeline.map((dest) => {
+      return {
+        ...dest,
+        target: fixTarget(dest.target)
+      }
+    })]
+  }
+
+  if (levels) {
+    options.levels = levels
+  }
+
+  if (dedupe) {
+    options.dedupe = dedupe
+  }
+
+  options.pinoWillSendConfig = true
+
+  const name = (targets || pipeline) ? 'pino.transport' : target
+  return buildStream(fixTarget(target), options, worker, sync, name)
+
+  function fixTarget (origin) {
+    origin = bundlerOverrides[origin] || origin
+
+    if (isAbsolute(origin) || origin.indexOf('file://') === 0) {
+      return origin
+    }
+
+    if (origin === 'pino/file') {
+      return join(__dirname, '..', 'file.js')
+    }
+
+    let fixTarget
+
+    for (const filePath of callers) {
+      try {
+        const context = filePath === 'node:repl'
+          ? process.cwd() + sep
+          : filePath
+
+        fixTarget = createRequire(context).resolve(origin)
+        break
+      } catch (err) {
+        // Silent catch
+        continue
+      }
+    }
+
+    if (!fixTarget) {
+      throw new Error(`unable to determine transport target for "${origin}"`)
+    }
+
+    return fixTarget
+  }
+}
+
+module.exports = transport

package/node_modules/pino/lib/worker.js

@@ -0,0 +1,194 @@
+'use strict'
+
+const EE = require('node:events')
+const { pipeline, PassThrough } = require('node:stream')
+const pino = require('../pino.js')
+const build = require('pino-abstract-transport')
+const loadTransportStreamBuilder = require('./transport-stream')
+
+// This file is not checked by the code coverage tool,
+// as it is not reliable.
+
+/* istanbul ignore file */
+
+/*
+ * > Multiple targets & pipelines
+ *
+ *
+ * ┌─────────────────────────────────────────────────┐    ┌─────┐
+ * │                                                 │    │  p  │
+ * │                                                 │    │  i  │
+ * │                   target                        │    │  n  │
+ * │               │ ────────────────────────────────┼────┤  o  │
+ * │   targets     │   target                        │    │  .  │
+ * │ ────────────► │ ────────────────────────────────┼────┤  m  │       source
+ * │               │   target                        │    │  u  │         │
+ * │               │ ────────────────────────────────┼────┤  l  │         │write
+ * │               │                                 │    │  t  │         ▼
+ * │               │  pipeline   ┌───────────────┐   │    │  i  │      ┌────────┐
+ * │               │ ──────────► │  PassThrough  ├───┼────┤  s  ├──────┤        │
+ * │               │             └───────────────┘   │    │  t  │ write│ Thread │
+ * │               │                                 │    │  r  │◄─────┤ Stream │
+ * │               │  pipeline   ┌───────────────┐   │    │  e  │      │        │
+ * │               │ ──────────► │  PassThrough  ├───┼────┤  a  │      └────────┘
+ * │                             └───────────────┘   │    │  m  │
+ * │                                                 │    │     │
+ * └─────────────────────────────────────────────────┘    └─────┘
+ *
+ *
+ *
+ *  > One single pipeline or target
+ *
+ *
+ *                                                           source
+ *                                                             │
+ * ┌────────────────────────────────────────────────┐          │write
+ * │                                                │          ▼
+ * │                                                │      ┌────────┐
+ * │   targets     │   target                       │      │        │
+ * │ ────────────► │  ──────────────────────────────┤      │        │
+ * │               │                                │      │        │
+ * │                                                ├──────┤        │
+ * │                                                │      │        │
+ * │                                                │      │        │
+ * │                     OR                         │      │        │
+ * │                                                │      │        │
+ * │                                                │      │        │
+ * │                               ┌──────────────┐ │      │        │
+ * │   targets     │   pipeline    │              │ │      │ Thread │
+ * │ ────────────► │  ────────────►│ PassThrough  ├─┤      │ Stream │
+ * │               │               │              │ │      │        │
+ * │                               └──────────────┘ │      │        │
+ * │                                                │      │        │
+ * │                     OR                         │ write│        │
+ * │                                                │◄─────┤        │
+ * │                                                │      │        │
+ * │                ┌──────────────┐                │      │        │
+ * │    pipeline    │              │                │      │        │
+ * │ ──────────────►│ PassThrough  ├────────────────┤      │        │
+ * │                │              │                │      │        │
+ * │                └──────────────┘                │      └────────┘
+ * │                                                │
+ * │                                                │
+ * └────────────────────────────────────────────────┘
+ */
+
+module.exports = async function ({ targets, pipelines, levels, dedupe }) {
+  const targetStreams = []
+
+  // Process targets
+  if (targets && targets.length) {
+    targets = await Promise.all(targets.map(async (t) => {
+      const fn = await loadTransportStreamBuilder(t.target)
+      const stream = await fn(t.options)
+      return {
+        level: t.level,
+        stream
+      }
+    }))
+
+    targetStreams.push(...targets)
+  }
+
+  // Process pipelines
+  if (pipelines && pipelines.length) {
+    pipelines = await Promise.all(
+      pipelines.map(async (p) => {
+        let level
+        const pipeDests = await Promise.all(
+          p.map(async (t) => {
+            // level assigned to pipeline is duplicated over all its targets, just store it
+            level = t.level
+            const fn = await loadTransportStreamBuilder(t.target)
+            const stream = await fn(t.options)
+            return stream
+          }
+          ))
+
+        return {
+          level,
+          stream: createPipeline(pipeDests)
+        }
+      })
+    )
+    targetStreams.push(...pipelines)
+  }
+
+  // Skip building the multistream step if either one single pipeline or target is defined and
+  // return directly the stream instance back to TreadStream.
+  // This is equivalent to define either:
+  //
+  // pino.transport({ target: ... })
+  //
+  // OR
+  //
+  // pino.transport({ pipeline: ... })
+  if (targetStreams.length === 1) {
+    return targetStreams[0].stream
+  } else {
+    return build(process, {
+      parse: 'lines',
+      metadata: true,
+      close (err, cb) {
+        let expected = 0
+        for (const transport of targetStreams) {
+          expected++
+          transport.stream.on('close', closeCb)
+          transport.stream.end()
+        }
+
+        function closeCb () {
+          if (--expected === 0) {
+            cb(err)
+          }
+        }
+      }
+    })
+  }
+
+  // TODO: Why split2 was not used for pipelines?
+  function process (stream) {
+    const multi = pino.multistream(targetStreams, { levels, dedupe })
+    // TODO manage backpressure
+    stream.on('data', function (chunk) {
+      const { lastTime, lastMsg, lastObj, lastLevel } = this
+      multi.lastLevel = lastLevel
+      multi.lastTime = lastTime
+      multi.lastMsg = lastMsg
+      multi.lastObj = lastObj
+
+      // TODO handle backpressure
+      multi.write(chunk + '\n')
+    })
+  }
+
+  /**
+ * Creates a pipeline using the provided streams and return an instance of `PassThrough` stream
+ * as a source for the pipeline.
+ *
+ * @param {(TransformStream|WritableStream)[]} streams An array of streams.
+ *   All intermediate streams in the array *MUST* be `Transform` streams and only the last one `Writable`.
+ * @returns A `PassThrough` stream instance representing the source stream of the pipeline
+ */
+  function createPipeline (streams) {
+    const ee = new EE()
+    const stream = new PassThrough({
+      autoDestroy: true,
+      destroy (_, cb) {
+        ee.on('error', cb)
+        ee.on('closed', cb)
+      }
+    })
+
+    pipeline(stream, ...streams, function (err) {
+      if (err && err.code !== 'ERR_STREAM_PREMATURE_CLOSE') {
+        ee.emit('error', err)
+        return
+      }
+
+      ee.emit('closed')
+    })
+
+    return stream
+  }
+}

package/node_modules/pino/package.json

@@ -0,0 +1,120 @@
+{
+  "name": "pino",
+  "version": "10.3.1",
+  "description": "super fast, all natural json logger",
+  "main": "pino.js",
+  "type": "commonjs",
+  "types": "pino.d.ts",
+  "browser": "./browser.js",
+  "scripts": {
+    "borp": "borp --timeout 60000 --coverage --check-coverage --lines 95 --functions 95 --branches 95 --statements 95",
+    "docs": "docsify serve",
+    "browser-test": "airtap --local 8080 test/browser*test.js",
+    "lint": "eslint .",
+    "prepublishOnly": "node test/internals/version.test.js",
+    "test": "npm run lint && npm run transpile && npm run borp && jest test/jest && npm run test-types",
+    "test-ci": "npm run lint && npm run transpile && npm run borp && npm run test-types",
+    "test-ci-pnpm": "pnpm run lint && npm run transpile && borp --timeout 60000 && pnpm run test-types",
+    "test-ci-yarn-pnp": "yarn run lint && npm run transpile && borp --timeout 60000",
+    "test-types": "tsc && tsd && ts-node test/types/pino.ts && attw --pack .",
+    "test:smoke": "smoker smoke:pino && smoker smoke:browser && smoker smoke:file",
+    "smoke:pino": "node ./pino.js",
+    "smoke:browser": "node ./browser.js",
+    "smoke:file": "node ./file.js",
+    "transpile": "node ./test/fixtures/ts/transpile.cjs",
+    "cov-ui": "tap --ts --coverage-report=html",
+    "bench": "node benchmarks/utils/runbench all",
+    "bench-basic": "node benchmarks/utils/runbench basic",
+    "bench-object": "node benchmarks/utils/runbench object",
+    "bench-deep-object": "node benchmarks/utils/runbench deep-object",
+    "bench-multi-arg": "node benchmarks/utils/runbench multi-arg",
+    "bench-long-string": "node benchmarks/utils/runbench long-string",
+    "bench-child": "node benchmarks/utils/runbench child",
+    "bench-child-child": "node benchmarks/utils/runbench child-child",
+    "bench-child-creation": "node benchmarks/utils/runbench child-creation",
+    "bench-formatters": "node benchmarks/utils/runbench formatters",
+    "update-bench-doc": "node benchmarks/utils/generate-benchmark-doc > docs/benchmarks.md"
+  },
+  "bin": {
+    "pino": "./bin.js"
+  },
+  "precommit": "test",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pinojs/pino.git"
+  },
+  "keywords": [
+    "fast",
+    "logger",
+    "stream",
+    "json"
+  ],
+  "author": "Matteo Collina <hello@matteocollina.com>",
+  "contributors": [
+    "David Mark Clements <huperekchuno@googlemail.com>",
+    "James Sumners <james.sumners@gmail.com>",
+    "Thomas Watson Steen <w@tson.dk> (https://twitter.com/wa7son)"
+  ],
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/pinojs/pino/issues"
+  },
+  "homepage": "https://getpino.io",
+  "devDependencies": {
+    "@arethetypeswrong/cli": "^0.18.1",
+    "@matteo.collina/tspl": "^0.2.0",
+    "@types/flush-write-stream": "^1.0.0",
+    "@types/node": "^25.0.3",
+    "airtap": "5.0.0",
+    "bole": "^5.0.5",
+    "borp": "^0.21.0",
+    "bunyan": "^1.8.14",
+    "debug": "^4.3.4",
+    "docsify-cli": "^4.4.4",
+    "eslint": "^9.37.0",
+    "eslint-plugin-import": "^2.26.0",
+    "eslint-plugin-n": "17.23.2",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-plugin-promise": "^6.0.0",
+    "execa": "^5.0.0",
+    "fastbench": "^1.0.1",
+    "flush-write-stream": "^2.0.0",
+    "import-fresh": "^3.2.1",
+    "jest": "^30.0.3",
+    "log": "^6.0.0",
+    "loglevel": "^1.6.7",
+    "midnight-smoker": "1.1.1",
+    "neostandard": "^0.12.2",
+    "pino-pretty": "^13.0.0",
+    "pre-commit": "^1.2.2",
+    "proxyquire": "^2.1.3",
+    "pump": "^3.0.0",
+    "rimraf": "^6.0.1",
+    "semver": "^7.3.7",
+    "split2": "^4.0.0",
+    "steed": "^1.1.3",
+    "strip-ansi": "^6.0.0",
+    "tape": "^5.5.3",
+    "through2": "^4.0.0",
+    "ts-node": "^10.9.1",
+    "tsd": "^0.33.0",
+    "typescript": "~5.9.2",
+    "winston": "^3.7.2"
+  },
+  "dependencies": {
+    "atomic-sleep": "^1.0.0",
+    "on-exit-leak-free": "^2.1.0",
+    "pino-abstract-transport": "^3.0.0",
+    "pino-std-serializers": "^7.0.0",
+    "process-warning": "^5.0.0",
+    "quick-format-unescaped": "^4.0.3",
+    "real-require": "^0.2.0",
+    "safe-stable-stringify": "^2.3.1",
+    "@pinojs/redact": "^0.4.0",
+    "sonic-boom": "^4.0.1",
+    "thread-stream": "^4.0.0"
+  },
+  "tsd": {
+    "directory": "test/types"
+  }
+}