cli.mts

#!/usr/bin/env node

import { fileURLToPath, pathToFileURL } from 'node:url'

import meow from 'meow'
import { messageWithCauses, stackWithCauses } from 'pony-cause'
import lookupRegistryAuthToken from 'registry-auth-token'
import lookupRegistryUrl from 'registry-url'
import updateNotifier from 'tiny-updater'
import colors from 'yoctocolors-cjs'

import { debugDir, debugFn } from '@socketsecurity/registry/lib/debug'
import { logger } from '@socketsecurity/registry/lib/logger'

import { rootAliases, rootCommands } from './commands.mts'
import constants from './constants.mts'
import { AuthError, InputError, captureException } from './utils/errors.mts'
import { failMsgWithBadge } from './utils/fail-msg-with-badge.mts'
import { meowWithSubcommands } from './utils/meow-with-subcommands.mts'
import { serializeResultJson } from './utils/serialize-result-json.mts'
import {
  finalizeTelemetry,
  setupTelemetryExitHandlers,
  trackCliComplete,
  trackCliError,
  trackCliStart,
} from './utils/telemetry/integration.mts'
import { socketPackageLink } from './utils/terminal-link.mts'

const __filename = fileURLToPath(import.meta.url)

// Capture CLI start time at module level for global error handlers.
const cliStartTime = Date.now()

// Set up telemetry exit handlers early to catch all exit scenarios.
setupTelemetryExitHandlers()

void (async () => {
  // Track CLI start for telemetry.
  await trackCliStart(process.argv)

  const registryUrl = lookupRegistryUrl()
  await updateNotifier({
    authInfo: lookupRegistryAuthToken(registryUrl, { recursive: true }),
    name: constants.SOCKET_CLI_BIN_NAME,
    registryUrl,
    ttl: 86_400_000 /* 24 hours in milliseconds */,
    version: constants.ENV.INLINED_SOCKET_CLI_VERSION,
    logCallback: (name: string, version: string, latest: string) => {
      logger.log(
        `\n\n📦 Update available for ${colors.cyan(name)}: ${colors.gray(version)} → ${colors.green(latest)}`,
      )
      logger.log(
        `📝 ${socketPackageLink('npm', name, `files/${latest}/CHANGELOG.md`, 'View changelog')}`,
      )
    },
  })

  try {
    await meowWithSubcommands(
      {
        name: constants.SOCKET_CLI_BIN_NAME,
        argv: process.argv.slice(2),
        importMeta: { url: `${pathToFileURL(__filename)}` } as ImportMeta,
        subcommands: rootCommands,
      },
      { aliases: rootAliases },
    )

    // Track successful CLI completion.
    await trackCliComplete(process.argv, cliStartTime, process.exitCode)
  } catch (e) {
    process.exitCode = 1

    // Track CLI error for telemetry.
    await trackCliError(process.argv, cliStartTime, e, process.exitCode)
    debugFn('error', 'CLI uncaught error')
    debugDir('error', e)

    let errorBody: string | undefined
    let errorTitle: string
    let errorMessage = ''
    if (e instanceof AuthError) {
      errorTitle = 'Authentication error'
      errorMessage = e.message
    } else if (e instanceof InputError) {
      errorTitle = 'Invalid input'
      errorMessage = e.message
      errorBody = e.body
    } else if (e instanceof Error) {
      errorTitle = 'Unexpected error'
      errorMessage = messageWithCauses(e)
      errorBody = stackWithCauses(e)
    } else {
      errorTitle = 'Unexpected error with no details'
    }

    // Try to parse the flags, find out if --json is set.
    const isJson = (() => {
      const cli = meow({
        argv: process.argv.slice(2),
        // Prevent meow from potentially exiting early.
        autoHelp: false,
        autoVersion: false,
        flags: {},
        importMeta: { url: `${pathToFileURL(__filename)}` } as ImportMeta,
      })
      return !!cli.flags['json']
    })()

    if (isJson) {
      logger.log(
        serializeResultJson({
          ok: false,
          message: errorTitle,
          cause: errorMessage,
        }),
      )
    } else {
      // Add 2 newlines in stderr to bump below any spinner.
      logger.error('\n')
      logger.fail(failMsgWithBadge(errorTitle, errorMessage))
      if (errorBody) {
        debugDir('inspect', { errorBody })
      }
    }

    await captureException(e)
  }
})().catch(async err => {
  // Fatal error in main async function.
  console.error('Fatal error:', err)

  // Track CLI error for fatal exceptions.
  await trackCliError(process.argv, cliStartTime, err, 1)

  // Finalize telemetry before fatal exit.
  await finalizeTelemetry()

  // eslint-disable-next-line n/no-process-exit
  process.exit(1)
})

// Handle uncaught exceptions.
process.on('uncaughtException', async err => {
  console.error('Uncaught exception:', err)

  // Track CLI error for uncaught exception.
  await trackCliError(process.argv, cliStartTime, err, 1)

  // Finalize telemetry before exit.
  await finalizeTelemetry()

  // eslint-disable-next-line n/no-process-exit
  process.exit(1)
})

// Handle unhandled promise rejections.
process.on('unhandledRejection', async (reason, promise) => {
  console.error('Unhandled rejection at:', promise, 'reason:', reason)

  // Track CLI error for unhandled rejection.
  const error = reason instanceof Error ? reason : new Error(String(reason))
  await trackCliError(process.argv, cliStartTime, error, 1)

  // Finalize telemetry before exit.
  await finalizeTelemetry()

  // eslint-disable-next-line n/no-process-exit
  process.exit(1)
})