@socketsecurity/cli 0.10.1 → 0.11.1

package/lib/shadow/tty-server.cjs

@@ -1,222 +0,0 @@
-const path = require('path')
-const { PassThrough } = require('stream')
-
-const ipc_version = require('../../package.json').version
-const { isErrnoException } = require('../utils/type-helpers.cjs')
-
-/**
- * @typedef {import('stream').Readable} Readable
- */
-/**
- * @typedef {import('stream').Writable} Writable
- */
-/**
- * @param {import('chalk')['default']['level']} colorLevel
- * @param {boolean} isInteractive
- * @param {any} npmlog
- * @returns {Promise<{ captureTTY<RET extends any>(mutexFn: (input: Readable | null, output?: Writable, colorLevel: import('chalk')['default']['level']) => Promise<RET>): Promise<RET> }>}
- */
-module.exports = async function createTTYServer (colorLevel, isInteractive, npmlog) {
-  const TTY_IPC = process.env['SOCKET_SECURITY_TTY_IPC']
-  const net = require('net')
-  /**
-   * @type {import('readline')}
-   */
-  let readline
-  const isSTDINInteractive = isInteractive
-  if (!isSTDINInteractive && TTY_IPC) {
-    return {
-      async captureTTY (mutexFn) {
-        return new Promise((resolve, reject) => {
-          const conn = net.createConnection({
-            path: TTY_IPC
-          }).on('error', reject)
-          let captured = false
-          /**
-           * @type {Array<Buffer>}
-           */
-          const bufs = []
-          conn.on('data', function awaitCapture (chunk) {
-            bufs.push(chunk)
-            /**
-             * @type {Buffer | null}
-             */
-            let lineBuff = Buffer.concat(bufs)
-            try {
-              if (!captured) {
-                const EOL = lineBuff.indexOf('\n'.charCodeAt(0))
-                if (EOL !== -1) {
-                  conn.removeListener('data', awaitCapture)
-                  conn.push(lineBuff.slice(EOL + 1))
-                  const {
-                    ipc_version: remote_ipc_version,
-                    capabilities: { input: hasInput, output: hasOutput, colorLevel: ipcColorLevel }
-                  } = JSON.parse(lineBuff.slice(0, EOL).toString('utf-8'))
-                  lineBuff = null
-                  captured = true
-                  if (remote_ipc_version !== ipc_version) {
-                    throw new Error('Mismatched STDIO tunnel IPC version, ensure you only have 1 version of socket CLI being called.')
-                  }
-                  const input = hasInput ? new PassThrough() : null
-                  input?.pause()
-                  if (input) conn.pipe(input)
-                  const output = hasOutput ? new PassThrough() : null
-                  output?.pipe(conn)
-                  // make ora happy
-                  // @ts-ignore
-                  output.isTTY = true
-                  // @ts-ignore
-                  output.cursorTo = function cursorTo (x, y, callback) {
-                    readline = readline || require('readline')
-                    // @ts-ignore
-                    readline.cursorTo(this, x, y, callback)
-                  }
-                  // @ts-ignore
-                  output.clearLine = function clearLine (dir, callback) {
-                    readline = readline || require('readline')
-                    // @ts-ignore
-                    readline.clearLine(this, dir, callback)
-                  }
-                  mutexFn(hasInput ? input : null, hasOutput ? /** @type {Writable} */(output) : undefined, ipcColorLevel)
-                    .then(resolve, reject)
-                    .finally(() => {
-                      conn.unref()
-                      conn.end()
-                      input?.end()
-                      output?.end()
-                      // process.exit(13)
-                    })
-                }
-              }
-            } catch (e) {
-              reject(e)
-            }
-          })
-        })
-      }
-    }
-  }
-  /**
-   * @type {Array<{resolve(): void}>}}
-   */
-  const pendingCaptures = []
-  let captured = false
-  const sock = path.join(require('os').tmpdir(), `socket-security-tty-${process.pid}.sock`)
-  process.env['SOCKET_SECURITY_TTY_IPC'] = sock
-  try {
-    await require('fs/promises').unlink(sock)
-  } catch (e) {
-    if (isErrnoException(e) && e.code !== 'ENOENT') {
-      throw e
-    }
-  }
-  const input = isSTDINInteractive ? process.stdin : null
-  const output = process.stderr
-  if (input) {
-    await new Promise((resolve, reject) => {
-      const server = net.createServer(async (conn) => {
-        if (captured) {
-          const captured = new Promise((resolve) => {
-            pendingCaptures.push({
-              resolve () {
-                resolve(undefined)
-              }
-            })
-          })
-          await captured
-        } else {
-          captured = true
-        }
-        const wasProgressEnabled = npmlog.progressEnabled
-        npmlog.pause()
-        if (wasProgressEnabled) {
-          npmlog.disableProgress()
-        }
-        conn.write(`${JSON.stringify({
-          ipc_version,
-          capabilities: {
-            input: Boolean(input),
-            output: true,
-            colorLevel
-          }
-        })}\n`)
-        conn.on('data', (data) => {
-          output.write(data)
-        })
-        conn.on('error', (e) => {
-          output.write(`there was an error prompting from a subshell (${e.message}), socket npm closing`)
-          process.exit(1)
-        })
-        input.on('data', (data) => {
-          conn.write(data)
-        })
-        input.on('end', () => {
-          conn.unref()
-          conn.end()
-          if (wasProgressEnabled) {
-            npmlog.enableProgress()
-          }
-          npmlog.resume()
-          nextCapture()
-        })
-      }).listen(sock, () => resolve(server)).on('error', (err) => {
-        reject(err)
-      }).unref()
-      process.on('exit', () => {
-        server.close()
-        try {
-          require('fs').unlinkSync(sock)
-        } catch (e) {
-          if (isErrnoException(e) && e.code !== 'ENOENT') {
-            throw e
-          }
-        }
-      })
-      resolve(server)
-    })
-  }
-  /**
-   *
-   */
-  function nextCapture () {
-    if (pendingCaptures.length > 0) {
-      const nextCapture = pendingCaptures.shift()
-      if (nextCapture) {
-        nextCapture.resolve()
-      }
-    } else {
-      captured = false
-    }
-  }
-  return {
-    async captureTTY (mutexFn) {
-      if (captured) {
-        const captured = new Promise((resolve) => {
-          pendingCaptures.push({
-            resolve () {
-              resolve(undefined)
-            }
-          })
-        })
-        await captured
-      } else {
-        captured = true
-      }
-      const wasProgressEnabled = npmlog.progressEnabled
-      try {
-        npmlog.pause()
-        if (wasProgressEnabled) {
-          npmlog.disableProgress()
-        }
-        // need await here for proper finally timing
-        return await mutexFn(input, output, colorLevel)
-      } finally {
-        if (wasProgressEnabled) {
-          npmlog.enableProgress()
-        }
-        npmlog.resume()
-        nextCapture()
-      }
-    }
-  }
-}

package/lib/shadow/update-notifier.mjs

@@ -1,3 +0,0 @@
-// ESM entrypoint doesn't work w/ --require, this needs to be done w/ a spawnSync sadly
-import { initUpdateNotifier } from '../utils/update-notifier.js'
-initUpdateNotifier()

package/lib/utils/api-helpers.js

@@ -1,42 +0,0 @@
-import chalk from 'chalk'
-import { ErrorWithCause } from 'pony-cause'
-
-import { AuthError } from './errors.js'
-
-/**
- * @template {import('@socketsecurity/sdk').SocketSdkOperations} T
- * @param {T} _name
- * @param {import('@socketsecurity/sdk').SocketSdkErrorType<T>} result
- * @param {import('ora').Ora} spinner
- * @returns {never}
- */
-export function handleUnsuccessfulApiResponse (_name, result, spinner) {
-  const resultError = 'error' in result && result.error && typeof result.error === 'object' ? result.error : {}
-  const message = 'message' in resultError && typeof resultError.message === 'string' ? resultError.message : 'No error message returned'
-
-  if (result.status === 401 || result.status === 403) {
-    spinner.stop()
-    throw new AuthError(message)
-  }
-  spinner.fail(chalk.white.bgRed('API returned an error:') + ' ' + message)
-  process.exit(1)
-}
-
-/**
- * @template T
- * @param {Promise<T>} value
- * @param {string} description
- * @returns {Promise<T>}
- */
-export async function handleApiCall (value, description) {
-  /** @type {T} */
-  let result
-
-  try {
-    result = await value
-  } catch (cause) {
-    throw new ErrorWithCause(`Failed ${description}`, { cause })
-  }
-
-  return result
-}

package/lib/utils/chalk-markdown.js

@@ -1,125 +0,0 @@
-import chalk from 'chalk'
-import isUnicodeSupported from 'is-unicode-supported'
-import terminalLink from 'terminal-link'
-
-// From the 'log-symbols' module
-const unicodeLogSymbols = {
-  info: chalk.blue('ℹ'),
-  success: chalk.green('✔'),
-  warning: chalk.yellow('⚠'),
-  error: chalk.red('✖'),
-}
-
-// From the 'log-symbols' module
-const fallbackLogSymbols = {
-  info: chalk.blue('i'),
-  success: chalk.green('√'),
-  warning: chalk.yellow('‼'),
-  error: chalk.red('×'),
-}
-
-// From the 'log-symbols' module
-export const logSymbols = isUnicodeSupported() ? unicodeLogSymbols : fallbackLogSymbols
-
-const markdownLogSymbols = {
-  info: ':information_source:',
-  error: ':stop_sign:',
-  success: ':white_check_mark:',
-  warning: ':warning:',
-}
-
-export class ChalkOrMarkdown {
-  /** @type {boolean} */
-  useMarkdown
-
-  /**
-   * @param {boolean} useMarkdown
-   */
-  constructor (useMarkdown) {
-    this.useMarkdown = !!useMarkdown
-  }
-
-  /**
-   * @param {string} text
-   * @param {number} [level]
-   * @returns {string}
-   */
-  header (text, level = 1) {
-    return this.useMarkdown
-      ? `\n${''.padStart(level, '#')} ${text}\n`
-      : chalk.underline(`\n${level === 1 ? chalk.bold(text) : text}\n`)
-  }
-
-  /**
-   * @param {string} text
-   * @returns {string}
-   */
-  bold (text) {
-    return this.useMarkdown
-      ? `**${text}**`
-      : chalk.bold(`${text}`)
-  }
-
-  /**
-   * @param {string} text
-   * @returns {string}
-   */
-  italic (text) {
-    return this.useMarkdown
-      ? `_${text}_`
-      : chalk.italic(`${text}`)
-  }
-
-  /**
-   * @param {string} text
-   * @param {string|undefined} url
-   * @param {{ fallback?: boolean, fallbackToUrl?: boolean }} options
-   * @returns {string}
-   */
-  hyperlink (text, url, { fallback = true, fallbackToUrl } = {}) {
-    if (!url) return text
-    return this.useMarkdown
-      ? `[${text}](${url})`
-      : terminalLink(text, url, {
-        fallback: fallbackToUrl ? (_text, url) => url : fallback
-      })
-  }
-
-  /**
-   * @param {string[]} items
-   * @returns {string}
-   */
-  list (items) {
-    const indentedContent = items.map(item => this.indent(item).trimStart())
-    return this.useMarkdown
-      ? '* ' + indentedContent.join('\n* ') + '\n'
-      : indentedContent.join('\n') + '\n'
-  }
-
-  /**
-   * @returns {typeof logSymbols}
-   */
-  get logSymbols () {
-    return this.useMarkdown ? markdownLogSymbols : logSymbols
-  }
-
-  /**
-   * @param {string} text
-   * @param {number} [level]
-   * @returns {string}
-   */
-  indent (text, level = 1) {
-    const indent = ''.padStart(level * 2, ' ')
-    return indent + text.split('\n').join('\n' + indent)
-  }
-
-  /**
-   * @param {unknown} value
-   * @returns {string}
-   */
-  json (value) {
-    return this.useMarkdown
-      ? '```json\n' + JSON.stringify(value) + '\n```'
-      : JSON.stringify(value)
-  }
-}

package/lib/utils/errors.js

@@ -1,14 +0,0 @@
-export class AuthError extends Error {}
-
-export class InputError extends Error {
-  /**
-   * @param {string} message
-   * @param {string} [body]
-   */
-  constructor (message, body) {
-    super(message)
-
-    /** @type {string|undefined} */
-    this.body = body
-  }
-}

package/lib/utils/flags.js

@@ -1,27 +0,0 @@
-/**
- * @typedef FlagExtensions
- * @property {string} description
- */
-
-/**
- * @template {import('meow').FlagType} Type
- * @template Default
- * @template {boolean} [IsMultiple=false]
- * @typedef {import('meow').Flag<Type, Default, IsMultiple> & FlagExtensions} Flag
- */
-
-/** @typedef {Flag<'string', string> | Flag<'string', string[], true>} StringFlag */
-/** @typedef {Flag<'boolean', boolean> | Flag<'boolean', boolean[], true>} BooleanFlag */
-/** @typedef {Flag<'number', number> | Flag<'number', number[], true>} NumberFlag */
-/** @typedef {StringFlag | BooleanFlag | NumberFlag} AnyFlag */
-/** @typedef {Record<string, AnyFlag>} AnyFlags */
-
-/**
- * @template {AnyFlags} Flags
- * @param {Flags} flags
- * @returns {Readonly<Flags>}
- */
-export function prepareFlags (flags) {
-  // As we can't do "satisfies AnyFlags" in JS yet (+ we add a bonus through Readonly<>)
-  return flags
-}

package/lib/utils/format-issues.js

@@ -1,99 +0,0 @@
-/** @typedef {import('@socketsecurity/sdk').SocketSdkReturnType<'getIssuesByNPMPackage'>['data']} SocketIssueList */
-/** @typedef {SocketIssueList[number]['value'] extends infer U | undefined ? U : never} SocketIssue */
-
-import { pick, stringJoinWithSeparateFinalSeparator } from './misc.js'
-
-const SEVERITIES_BY_ORDER = /** @type {const} */ ([
-  'critical',
-  'high',
-  'middle',
-  'low',
-])
-
-/**
- * @param {SocketIssue['severity']|undefined} lowestToInclude
- * @returns {Array<SocketIssue['severity']>}
- */
- function getDesiredSeverities (lowestToInclude) {
-  /** @type {Array<SocketIssue['severity']>} */
-  const result = []
-
-  for (const severity of SEVERITIES_BY_ORDER) {
-    result.push(severity)
-    if (severity === lowestToInclude) {
-      break
-    }
-  }
-
-  return result
-}
-/* TODO: Delete this function when we remove the report command */
-/**
- * @param {SocketIssueList} issues
- * @param {SocketIssue['severity']} [lowestToInclude]
- * @returns {Record<SocketIssue['severity'], number>}
- */
-export function getSeverityCount (issues, lowestToInclude) {
-  const severityCount = pick(
-    { low: 0, middle: 0, high: 0, critical: 0 },
-    getDesiredSeverities(lowestToInclude)
-  )
-
-  for (const issue of issues) {
-    const value = issue.value
-
-    if (!value) {
-      continue
-    }
-
-    if (severityCount[value.severity] !== undefined) {
-      severityCount[value.severity] += 1
-    }
-  }
-
-  return severityCount
-}
-
-/* The following function is the updated one */
-/**
- * @param {Array<SocketIssue>} issues
- * @param {SocketIssue['severity']} [lowestToInclude]
- * @returns {Record<SocketIssue['severity'], number>}
- */
-export function getCountSeverity (issues, lowestToInclude) {
-  const severityCount = pick(
-    { low: 0, middle: 0, high: 0, critical: 0 },
-    getDesiredSeverities(lowestToInclude)
-  )
-
-  for (const issue of issues) {
-    const severity = issue.severity
-
-    if (!severity) {
-      continue
-    }
-
-    if (severityCount[severity] !== undefined) {
-      severityCount[severity] += 1
-    }
-  }
-
-  return severityCount
-}
-
-/**
- * @param {Record<SocketIssue['severity'], number>} severityCount
- * @returns {string}
- */
-export function formatSeverityCount (severityCount) {
-  /** @type {string[]} */
-  const summary = []
-
-  for (const severity of SEVERITIES_BY_ORDER) {
-    if (severityCount[severity]) {
-      summary.push(`${severityCount[severity]} ${severity}`)
-    }
-  }
-
-  return stringJoinWithSeparateFinalSeparator(summary)
-}

package/lib/utils/formatting.js

@@ -1,47 +0,0 @@
-/** @typedef {string|{ description: string }} ListDescription */
-
-/**
- * @typedef HelpListOptions
- * @property {string} [keyPrefix]
- * @property {number} [padName]
- */
-
-/**
- * @param {Record<string,ListDescription>} list
- * @param {number} indent
- * @param {HelpListOptions} options
- * @returns {string}
- */
-export function printHelpList (list, indent, options = {}) {
-  const {
-    keyPrefix = '',
-    padName = 18,
-  } = options
-
-  const names = Object.keys(list).sort()
-
-  let result = ''
-
-  for (const name of names) {
-    const rawDescription = list[name]
-    const description = (typeof rawDescription === 'object' ? rawDescription.description : rawDescription) || ''
-
-    result += ''.padEnd(indent) + (keyPrefix + name).padEnd(padName) + description + '\n'
-  }
-
-  return result.trim()
-}
-
-/**
- * @param {Record<string, ListDescription>} list
- * @param {number} indent
- * @param {HelpListOptions} options
- * @returns {string}
- */
-export function printFlagList (list, indent, options = {}) {
-  return printHelpList({
-    'help': 'Print this help and exits.',
-    'version': 'Prints current version and exits.',
-    ...list,
-  }, indent, { keyPrefix: '--', ...options })
-}