@contrast/contrast 1.0.0

package/src/lambda/__mocks__/lambdaConfig.json

@@ -0,0 +1,42 @@
+{
+  "$metadata": {
+    "httpStatusCode": 200,
+    "requestId": "c1495998-4606-46ba-b4fc-f7d0d165172d",
+    "attempts": 1,
+    "totalRetryDelay": 0
+  },
+  "Code": {
+    "Location": "https://awslambda-eu-cent-1-tasks.s3.eu-central-1.amazonaws.com/snapshots/123456789012/FunctionLambda-90e7680-c598cb5f-6bc9-4107-9fe7-13c126eb3b9e?versionId=ThxUComOVL.qnyEN9Bmi3xzK1JshuKA3&X-Amz-Security-Token=IQoJb3JpZ2luX2VjEGcaDGV1LWNlbnRyYWwtMSJIMEYCIQDAMKTGQ5WEMHM9H7cZQugjEX8QWvq5zRxtXg%2Fz6m9lmAIhAMst%2F5iQkOPJ%2BNfflPiwD4GQchajTfvbNvVeGlz%2BdFi%2FKokECPD%2F%2F%2F%2F%2F%2F%2F%2F%2F%2FwEQAxoMNjgwNjg2NTU5NDM0IgwPQDJYINU9W7Csw4sq3QO52WKm5PvlVEeLrwstuDqPPKxhdK57A6z2foEF0Bp%2Bz%2Fp%2Flei2DzbpqjPDluzljZmzh3kP8QKPwq25Yk59%2BfXnxlSkHYe3GXO6W6VLBkPk81T0C9keVwdMijW1ZV94KN8qBB17kERR3sFIhBWXJRLhXSAdLREAfNLaE%2FgnP1eC1b5MZCBW46lbjmYHhHshgZJEUD2fy%2BRuOB4HijldLkpHKgZfwiD0ICXkvxF5NQT6tUhlQPNN%2BCrC2RQ0NSkmjXiaL2BXaDxaQVhZwMTGzBEyLAonA9bSisObWrVEjJcC4%2Bqz9ce25l2yYf77lEXWymEp9NvFFcUNAt6tt%2FAm2qMixcLxV0Y2NuBUBjIvPnNnTvBop%2FvAC1Rh6033AmWpmkK0tD65wEsTS4XAEtnD%2B%2Bku4r6kzatRJ88Lq9YOTbjs%2BMEccy9YIFp7Rwf2%2Bdw3EKHSqz4aB0R9KYa07NooZ%2Bym1VZWfGLfhFRJwKRLk3qKkY%2Bj4laizIE%2BBgqC7f7%2FYXcFk8RGX8vlX5y%2BMKWhBXoMPqAPG7ruoG1RbjQX8TEJvuG0G8c5x76fRjB2VRlykY78wa7%2B83a8oBqMfojq7hQWByNv%2B13KHVIIqrG87tL%2BtrmS7GAoils0vXf0Mvowqt6RkgY6pAGKzTtWpXiIhFLe5n2CNNDMuT9xCSCpQIWf2M9GcNabj%2FAUHIa81gvZwuHzB6DYpEj2cZ7wO22Ve%2FRLIrzdkBROoRYnT0GFevXUJAoO2WolWU13JS7owlBPTW7aET6o7fHJUhwAxPZPCp1cSaFMO5cDN%2BTOVm7V6P4es6m87S1yozp5SzHx3KblhJJF6krPHX6YCWC%2B%2FAu9tu7PqgiZ3RQTZ26f4A%3D%3D&X-Amz-Algorithm=AWS4-HMAC-SHA256&X-Amz-Date=20220330T153702Z&X-Amz-SignedHeaders=host&X-Amz-Expires=600&X-Amz-Credential=ASIAZ47AUUDFFU2TD45R%2F20220330%2Feu-central-1%2Fs3%2Faws4_request&X-Amz-Signature=4f9187001f127561afee310d9a127acacb5064c51688f7cd65f98ccb0a7aaa10",
+    "RepositoryType": "S3"
+  },
+  "Configuration": {
+    "Architectures": ["x86_64"],
+    "CodeSha256": "KNNSfx0YOrZ+pG3fK0qbGBJv/b8V0/gWFFkFw581i4o=",
+    "CodeSize": 39577174,
+    "DeadLetterConfig": {
+      "TargetArn": "arn:aws:sqs:eu-central-1:123456789012:devlocaleuDeadLetterQ-89016d3"
+    },
+    "Description": "",
+    "Environment": {
+      "Variables": {
+        "EVENTS_BUCKET": "devlocaleu-cn-events-4h6eig-eu-central-1-1676820",
+        "AGENTS_TABLE": "devlocaleu.agent.agents"
+      }
+    },
+    "EphemeralStorage": { "Size": 512 },
+    "FunctionArn": "arn:aws:lambda:eu-central-1:123456789012:function:FunctionLambda-90e7680",
+    "FunctionName": "FunctionLambda-90e7680",
+    "Handler": "com.contrastsecurity.scan.ScanHandler::handleEventDataWithContext",
+    "LastModified": "2022-03-28T11:14:56.000+0000",
+    "LastUpdateStatus": "Successful",
+    "MemorySize": 1024,
+    "PackageType": "Zip",
+    "RevisionId": "d174710a-23ff-499b-a7ba-61036beabd7a",
+    "Role": "arn:aws:iam::123456789012:role/Function_Role",
+    "Runtime": "java11",
+    "State": "Active",
+    "Timeout": 900,
+    "TracingConfig": { "Mode": "PassThrough" },
+    "Version": "$LATEST"
+  }
+}

package/src/lambda/arn.ts

@@ -0,0 +1,32 @@
+import { CliError } from './cliError'
+import { ERRORS } from './constants'
+
+type ARN = {
+  partition: string
+  service: string
+  region: string
+  accountId: string
+  resource: string
+  resourceId?: string
+}
+
+const ARN_REGEX = /arn:(?<partition>[^:\n]*):(?<service>[^:\n]*):(?<region>[^:\n]*):(?<accountId>[^:\n]*):(?<ignore>(?<resource>[^:/\n]*)[:/])?(?<resourceId>.*)/
+
+const parseARN = (arn: string | undefined) => {
+  if (!arn) {
+    throw new CliError(ERRORS.FAILED_TO_START_SCAN, {
+      errorCode: 'failedToParseArn'
+    })
+  }
+
+  const arnMatch = arn.match(ARN_REGEX)
+  if (!arnMatch) {
+    throw new CliError(ERRORS.FAILED_TO_START_SCAN, {
+      errorCode: 'failedToParseArn'
+    })
+  }
+
+  return arnMatch.groups as ARN
+}
+
+export { parseARN, ARN }

package/src/lambda/aws.ts

@@ -0,0 +1,247 @@
+import {
+  Lambda,
+  GetFunctionCommand,
+  GetLayerVersionByArnCommand,
+  FunctionConfiguration,
+  ResourceNotFoundException,
+  LambdaServiceException
+} from '@aws-sdk/client-lambda'
+import {
+  GetRolePolicyCommand,
+  IAMClient,
+  paginateListRolePolicies,
+  paginateListAttachedRolePolicies,
+  GetPolicyCommand,
+  GetPolicyVersionCommand
+} from '@aws-sdk/client-iam'
+import { fromIni } from '@aws-sdk/credential-provider-ini'
+import { RegionInputConfig } from '@aws-sdk/config-resolver/dist-types/regionConfig/resolveRegionConfig'
+import { EndpointsInputConfig } from '@aws-sdk/config-resolver/dist-types/endpointsConfig/resolveEndpointsConfig'
+import { AwsAuthInputConfig } from '@aws-sdk/middleware-signing/dist-types/configurations'
+import { CliError } from './cliError'
+import { LambdaOptions } from './lambda'
+import { ERRORS } from './constants'
+
+type AWSClientConfig = RegionInputConfig &
+  EndpointsInputConfig &
+  AwsAuthInputConfig
+
+const getAwsClientOptions = ({
+  region,
+  endpointUrl,
+  profile
+}: LambdaOptions): AWSClientConfig => {
+  const credentials = profile ? fromIni({ profile }) : undefined
+  return {
+    region: region || process.env.AWS_DEFAULT_REGION,
+    endpoint: endpointUrl,
+    credentials
+  }
+}
+
+const getLambdaClient = (lambdaOptions: LambdaOptions) => {
+  try {
+    const clientOptions = getAwsClientOptions(lambdaOptions)
+    return new Lambda(clientOptions)
+  } catch (error) {
+    const errorObj = error as any
+    if (errorObj?.code === 'ERR_INVALID_URL') {
+      throw new CliError(ERRORS.AWS_ERROR, { description: errorObj.message })
+    }
+
+    throw error
+  }
+}
+
+const getIAMClient = (lambdaOptions: LambdaOptions) => {
+  const clientOptions = getAwsClientOptions(lambdaOptions)
+  return new IAMClient(clientOptions)
+}
+
+const getLambdaFunctionConfiguration = async (
+  client: Lambda,
+  lambdaOptions: LambdaOptions
+) => {
+  const { functionName: FunctionName } = lambdaOptions
+  const getFunctionCommand = new GetFunctionCommand({ FunctionName })
+  try {
+    return await client.send(getFunctionCommand)
+  } catch (error) {
+    throwAwsError(error)
+  }
+}
+
+const getLayersLinks = async (
+  client: Lambda,
+  functionConfiguration: FunctionConfiguration
+) => {
+  const { Layers: layers = [] } = functionConfiguration
+  const resultPromises = layers.map(async layerDict => {
+    try {
+      const layerArn = layerDict.Arn
+      const getLayerVersionByArnCommand = new GetLayerVersionByArnCommand({
+        Arn: layerArn
+      })
+      const layer = await client.send(getLayerVersionByArnCommand)
+      return {
+        Arn: layerArn,
+        Location: layer.Content?.Location
+      }
+    } catch (e) {
+      if (e instanceof ResourceNotFoundException) {
+        e.message = `The layer ${layerDict.Arn} could not be found. We will continue the scan without it.`
+        throw e
+      }
+      throw e
+    }
+  })
+  const results = await Promise.allSettled(resultPromises)
+  const validLayers = results.filter(layerResult => {
+    if (layerResult.status === 'rejected') {
+      console.warn(layerResult.reason.message)
+      return false
+    }
+    return true
+  })
+  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+  // @ts-ignore: value is not recognized
+  return validLayers.map(layer => layer.value)
+}
+
+const getLambdaPolicies = async (
+  functionConfiguration: FunctionConfiguration,
+  lambdaOptions: LambdaOptions
+) => {
+  const { Role: roleArn } = functionConfiguration
+  const roleSplitList = roleArn?.split('/')
+
+  if (roleSplitList) {
+    const roleName = roleSplitList[roleSplitList.length - 1]
+    const client = exports.getIAMClient(lambdaOptions)
+    const rolePolicies = await getRolePolicies(roleName, client)
+    const attachedPolicies = await getAttachedPolicies(roleName, client)
+    return [...rolePolicies, ...attachedPolicies]
+  }
+}
+
+const getRolePolicyNames = async (roleName: string, client: IAMClient) => {
+  const listRolePolicyNames = []
+
+  try {
+    for await (const page of paginateListRolePolicies(
+      { client },
+      { RoleName: roleName }
+    )) {
+      if (page.PolicyNames) {
+        listRolePolicyNames.push(...page.PolicyNames)
+      }
+    }
+  } catch (error) {
+    throwAwsError(error)
+  }
+
+  return listRolePolicyNames
+}
+
+const getAttachedPolicyNames = async (roleName: string, client: IAMClient) => {
+  const listAttachedPolicies = []
+  for await (const page of paginateListAttachedRolePolicies(
+    { client },
+    { RoleName: roleName }
+  )) {
+    if (page.AttachedPolicies) {
+      listAttachedPolicies.push(...page.AttachedPolicies)
+    }
+  }
+  return listAttachedPolicies
+}
+
+const getRolePolicies = async (roleName: string, client: IAMClient) => {
+  const listRolePolicyNames = await exports.getRolePolicyNames(roleName, client)
+
+  if (listRolePolicyNames) {
+    const rolePoliciesPromises = listRolePolicyNames.map(
+      async (policyName: any) => {
+        const getRolePolicyCommand = new GetRolePolicyCommand({
+          PolicyName: policyName,
+          RoleName: roleName
+        })
+
+        const rolePolicy = await client.send(getRolePolicyCommand)
+        const policyDoc = JSON.parse(
+          decodeURIComponent(rolePolicy?.PolicyDocument || '{}')
+        )
+        policyDoc.PolicyName = policyName
+        return policyDoc
+      }
+    )
+
+    const rolePolicies = await Promise.all(rolePoliciesPromises)
+    return rolePolicies
+  }
+
+  return []
+}
+
+const getAttachedPolicies = async (roleName: string, client: IAMClient) => {
+  const listAttachedPolicies = await exports.getAttachedPolicyNames(
+    roleName,
+    client
+  )
+  const attachedPoliciesPromises = listAttachedPolicies.map(
+    async (policyDict: { PolicyArn: any; PolicyName: any }) => {
+      const getPolicyCommand = new GetPolicyCommand({
+        PolicyArn: policyDict.PolicyArn
+      })
+      const policy = await client.send(getPolicyCommand)
+      if (policy.Policy) {
+        const getPolicyVersionCommand = new GetPolicyVersionCommand({
+          PolicyArn: policy.Policy.Arn,
+          VersionId: policy.Policy.DefaultVersionId
+        })
+        const policyVersion = await client.send(getPolicyVersionCommand)
+        const policyDoc = JSON.parse(
+          decodeURIComponent(policyVersion?.PolicyVersion?.Document || '{}')
+        )
+        policyDoc['PolicyName'] = policyDict.PolicyName
+        policyDoc['PolicyArn'] = policyDict.PolicyArn
+        return policyDoc
+      }
+    }
+  )
+
+  const attachedPolicies = await Promise.all(attachedPoliciesPromises)
+  return attachedPolicies
+}
+
+/**
+ *
+ * @param error any error
+ * @returns throw AWS error in union format
+ */
+const throwAwsError = (error: any) => {
+  const serviceError = error as LambdaServiceException
+
+  if (error instanceof Error && serviceError.$metadata) {
+    const { httpStatusCode } = serviceError.$metadata
+    const { message } = error
+
+    throw new CliError(ERRORS.AWS_ERROR, {
+      statusCode: httpStatusCode,
+      description: message
+    })
+  }
+
+  throw error
+}
+
+export {
+  getAttachedPolicyNames,
+  getRolePolicyNames,
+  getIAMClient,
+  getLambdaClient,
+  getLambdaFunctionConfiguration,
+  getLayersLinks,
+  getLambdaPolicies,
+  throwAwsError
+}

package/src/lambda/cliError.ts

@@ -0,0 +1,72 @@
+import i18n from 'i18n'
+import * as errorHandling from '../common/errorHandling'
+
+type ErrorDetails = {
+  statusCode?: number // API statusCode
+  errorCode?: string // internal errorCode
+  description?: string // free usage
+  data?: any //
+}
+
+class CliError extends Error {
+  statusCode?: number
+  errorCode?: string
+  description?: string
+  data?: any
+
+  statusCodeDescription?: string
+  errorCodeDescription?: string
+
+  constructor(headerMessage: string, details?: ErrorDetails) {
+    const message = i18n.__(headerMessage || '')
+    super(message)
+
+    const { statusCode, errorCode, data, description } = details || {}
+
+    this.statusCode = statusCode
+    this.errorCode = errorCode
+    this.data = data
+    this.description = description
+
+    if (errorCode) {
+      this.errorCodeDescription = i18n.__(errorCode || '')
+    }
+
+    if (statusCode) {
+      this.statusCodeDescription = this.getMessageByStatusCode(statusCode)
+    }
+  }
+
+  getErrorMessage() {
+    let finalDesc =
+      this.errorCodeDescription || this.statusCodeDescription || ''
+
+    if (this.description) {
+      finalDesc += finalDesc ? `\n${this.description}` : this.description
+    }
+    return errorHandling.getErrorMessage(this.message, finalDesc)
+  }
+
+  getMessageByStatusCode(statusCode: number) {
+    switch (statusCode) {
+      case 200:
+        return ''
+      case 400:
+        return i18n.__('badRequestErrorHeader')
+      case 401:
+        return i18n.__('unauthenticatedErrorHeader')
+      case 403:
+        return i18n.__('forbiddenRequestErrorHeader')
+      case 404:
+        return i18n.__('not_found_404')
+      case 423:
+        return i18n.__('resourceLockedErrorHeader')
+      case 500:
+        return i18n.__('internalServerErrorHeader')
+      default:
+        return i18n.__('something_went_wrong')
+    }
+  }
+}
+
+export { CliError }

package/src/lambda/constants.ts

@@ -0,0 +1,11 @@
+// TODO: don't forget to add translation in `src/constants/lambda.js` for each value
+
+const ERRORS = Object.freeze({
+  AWS_ERROR: 'awsError',
+  FAILED_TO_START_SCAN: 'failedToStartScan',
+  FAILED_TO_GET_SCAN: 'failedToGetScan',
+  FAILED_TO_GET_RESULTS: 'failedToGetResults',
+  VALIDATION_FAILED: 'validationFailed'
+})
+
+export { ERRORS }

package/src/lambda/help.ts

@@ -0,0 +1,76 @@
+import commandLineUsage from 'command-line-usage'
+import i18n from 'i18n'
+
+const lambdaUsageGuide = commandLineUsage([
+  {
+    header: i18n.__('lambdaHeader'),
+    content: [i18n.__('lambdaSummary')]
+  },
+  {
+    header: i18n.__('constantsPrerequisitesHeader'),
+    content: [i18n.__('lambdaPrerequisitesContent')]
+  },
+  {
+    header: i18n.__('constantsUsage'),
+    content: [i18n.__('lambdaUsage')]
+  },
+  {
+    header: i18n.__('constantsOptions'),
+    content: [
+      {
+        name: i18n.__('lambdaFunctionNameOption'),
+        summary: i18n.__('lambdaFunctionNameSummery')
+      },
+      {
+        name: i18n.__('lambdaEndpointOption'),
+        summary:
+          '{italic ' +
+          i18n.__('constantsOptional') +
+          '}: ' +
+          i18n.__('lambdaEndpointSummery')
+      },
+      {
+        name: i18n.__('lambdaRegionOption'),
+        summary:
+          '{italic ' +
+          i18n.__('constantsOptional') +
+          '}: ' +
+          i18n.__('lambdaRegionSummery')
+      },
+      {
+        name: i18n.__('lambdaProfileOption'),
+        summary:
+          '{italic ' +
+          i18n.__('constantsOptional') +
+          '}: ' +
+          i18n.__('lambdaProfileSummery')
+      },
+      {
+        name: i18n.__('lambdaJsonOption'),
+        summary:
+          '{italic ' +
+          i18n.__('constantsOptional') +
+          '}: ' +
+          i18n.__('lambdaJsonSummery')
+      },
+      {
+        name: i18n.__('lambdaVerboseOption'),
+        summary:
+          '{italic ' +
+          i18n.__('constantsOptional') +
+          '}: ' +
+          i18n.__('lambdaVerbosSummery')
+      }
+    ]
+  },
+  {
+    content: [
+      { name: i18n.__('lambdaHelpOption'), summary: i18n.__('helpSummary') }
+    ]
+  },
+  {
+    content: '{underline https://www.contrastsecurity.com}'
+  }
+])
+
+export { lambdaUsageGuide }

package/src/lambda/lambda.ts

@@ -0,0 +1,174 @@
+import commandLineArgs from 'command-line-args'
+import { performance } from 'perf_hooks'
+import { kebabCase } from 'lodash'
+import i18n from 'i18n'
+import { getAuth } from '../utils/paramsUtil/paramHandler'
+import { CliError } from './cliError'
+import { ERRORS } from './constants'
+import { lambdaUsageGuide } from './help'
+import { log } from './logUtils'
+import { pollScanUntilCompletion } from './scanDetailCompletion'
+import { requestScanFunctionPost } from './scanRequest'
+import { getScanResults } from './scanResults'
+import { prettyPrintResults } from './utils'
+
+type LambdaOptions = {
+  functionName?: string
+  region?: string
+  endpointUrl?: string
+  profile?: string
+  help?: boolean
+  verbose?: boolean
+  jsonOutput?: boolean
+  _unknown?: string[]
+}
+
+type ApiParams = {
+  organizationId: string
+  provider: 'aws'
+  accountId: string
+}
+
+const failedStates = [
+  'UNSUPPORTED',
+  'EXCLUDED',
+  'CANCELED',
+  'FAILED',
+  'DISMISSED'
+]
+
+const printHelpMessage = () => {
+  log(lambdaUsageGuide)
+}
+
+const getLambdaOptions = (argv: string[]) => {
+  const lambdaDefinitions = [
+    { name: 'function-name', alias: 'f', type: String },
+    { name: 'region', alias: 'r', type: String },
+    { name: 'endpoint-url', alias: 'e', type: String },
+    { name: 'profile', alias: 'p', type: String },
+    { name: 'help', alias: 'h', type: Boolean },
+    { name: 'verbose', alias: 'v', type: Boolean },
+    { name: 'json-output', alias: 'j', type: Boolean }
+  ]
+
+  const lambdaOptions: LambdaOptions = commandLineArgs(lambdaDefinitions, {
+    argv,
+    partial: true,
+    camelCase: true,
+    caseInsensitive: true
+  })
+
+  return lambdaOptions
+}
+
+const processLambda = async (argv: string[]) => {
+  const lambdaOptions = getLambdaOptions(argv)
+  const { help } = lambdaOptions
+
+  if (help) {
+    return handleLambdaHelp()
+  }
+
+  try {
+    validateRequiredLambdaParams(lambdaOptions)
+
+    await actualProcessLambda(lambdaOptions)
+  } catch (error) {
+    if (error instanceof CliError) {
+      console.error(error.getErrorMessage())
+    } else if (error instanceof Error) {
+      console.error(error.message)
+    }
+    process.exit(1)
+  }
+}
+
+const actualProcessLambda = async (lambdaOptions: LambdaOptions) => {
+  const auth = getAuth()
+  const startTime = performance.now()
+  const { jsonOutput } = lambdaOptions
+  const { scanId, params, functionArn } = await requestScanFunctionPost(
+    auth,
+    lambdaOptions
+  )
+  const scans = await pollScanUntilCompletion(auth, 10, params, scanId)
+  const failedScan = scans
+    ?.filter((s: any) => s.scanType === 2)
+    .find((s: any) => failedStates.includes(s.state))
+
+  if (failedScan) {
+    throw new CliError(ERRORS.FAILED_TO_GET_SCAN, {
+      statusCode: 200,
+      errorCode: failedScan.state,
+      description: failedScan.stateReasonText
+    })
+  }
+
+  const resultsResponse = await getScanResults(
+    auth,
+    params,
+    scanId,
+    functionArn
+  )
+
+  if (jsonOutput) {
+    console.log(JSON.stringify(resultsResponse?.data?.results, null, 2))
+    return
+  }
+
+  const results = resultsResponse?.data?.results
+  if (!results) {
+    throw new CliError(ERRORS.FAILED_TO_GET_RESULTS, {
+      errorCode: 'missingResults'
+    })
+  }
+
+  if (!results.length) {
+    log('👏 No vulnerabilities found')
+  }
+
+  const endTime = performance.now()
+  const scanDurationMs = endTime - startTime
+
+  log(`----- Scan completed ${(scanDurationMs / 1000).toFixed(2)}s -----`)
+
+  if (results?.length) {
+    prettyPrintResults(results)
+  }
+}
+
+const validateRequiredLambdaParams = (options: LambdaOptions) => {
+  if (options._unknown?.length) {
+    throw new CliError(ERRORS.VALIDATION_FAILED, {
+      description: i18n.__('notSupportedFlags', options._unknown.join('\n'))
+    })
+  }
+
+  if (!options?.functionName) {
+    throw new CliError(ERRORS.VALIDATION_FAILED, {
+      errorCode: 'missingFunctionName'
+    })
+  }
+
+  const flagsWithoutValues = Object.entries(options)
+    .filter(([, value]) => !value)
+    .map(([key]) => key)
+    .map(p => `--${kebabCase(p)}`)
+
+  if (flagsWithoutValues.length) {
+    throw new CliError(ERRORS.VALIDATION_FAILED, {
+      description: i18n.__(
+        'missingFlagArguments',
+        flagsWithoutValues.join('\n')
+      )
+    })
+  }
+}
+
+const handleLambdaHelp = () => {
+  printHelpMessage()
+  process.exit(0)
+}
+
+export { processLambda, LambdaOptions, ApiParams }

package/src/lambda/logUtils.ts

@@ -0,0 +1,46 @@
+import chalk from 'chalk'
+import util from 'util'
+
+interface logStyles {
+  bold?: boolean
+  italic?: boolean
+  underline?: boolean
+  strikethrough?: boolean
+}
+
+const log = (message: string | number, styles?: logStyles) => {
+  let chalkFunction = chalk.reset
+
+  if (styles?.bold) {
+    chalkFunction = chalk.bold
+  } else if (styles?.italic) {
+    chalkFunction = chalk.italic
+  } else if (styles?.underline) {
+    chalkFunction = chalk.underline
+  } else if (styles?.strikethrough) {
+    chalkFunction = chalk.strikethrough
+  }
+
+  console.log(styles ? chalkFunction(message) : message)
+}
+
+/**
+ *
+ * @param obj any json object or string
+ * @param depth determines how levels it will recurse to show the json
+ */
+const prettyPrintJson = (obj: string | any, depth: number | null = null) => {
+  if (!obj) {
+    return
+  }
+
+  let objToPrint = obj
+
+  if (typeof obj === 'string') {
+    objToPrint = JSON.parse(obj)
+  }
+
+  console.log(util.inspect(objToPrint, { colors: true, depth }))
+}
+
+export { log, prettyPrintJson }