@capgo/cli 4.12.14 → 4.13.3

package/src/app/add.ts

@@ -1,158 +0,0 @@
-import { existsSync, readFileSync } from 'node:fs'
-import process from 'node:process'
-import mime from 'mime'
-import { program } from 'commander'
-import * as p from '@clack/prompts'
-import { checkLatest } from '../api/update'
-import type { Options } from '../api/app'
-import { checkAppExists, newIconPath } from '../api/app'
-import type {
-  Organization,
-} from '../utils'
-import {
-  checkPlanValid,
-  createSupabaseClient,
-  findSavedKey,
-  formatError,
-  getConfig,
-  getOrganization,
-  verifyUser,
-} from '../utils'
-
-export async function addApp(appId: string, options: Options, throwErr = true) {
-  await addAppInternal(appId, options, undefined, throwErr)
-}
-
-export async function addAppInternal(appId: string, options: Options, organization?: Organization, throwErr = true) {
-  if (throwErr)
-    p.intro(`Adding`)
-
-  await checkLatest()
-  options.apikey = options.apikey || findSavedKey()
-  const config = await getConfig()
-  appId = appId || config?.app?.appId
-
-  if (!options.apikey) {
-    p.log.error(`Missing API key, you need to provide a API key to upload your bundle`)
-    program.error('')
-  }
-  if (!appId) {
-    p.log.error('Missing argument, you need to provide a appId, or be in a capacitor project')
-    program.error('')
-  }
-
-  if (appId.includes('--')) {
-    p.log.error('The app id includes illegal symbols. You cannot use "--" in the app id')
-    program.error('')
-  }
-
-  const supabase = await createSupabaseClient(options.apikey)
-
-  await verifyUser(supabase, options.apikey, ['write', 'all'])
-
-  // Check we have app access to this appId
-  const appExist = await checkAppExists(supabase, appId)
-  if (appExist) {
-    p.log.error(`App ${appId} already exist`)
-    program.error('')
-  }
-
-  if (!organization)
-    organization = await getOrganization(supabase, ['admin', 'super_admin'])
-
-  const organizationUid = organization.gid
-
-  await checkPlanValid(supabase, organizationUid, options.apikey, undefined, false)
-
-  let { name, icon } = options
-  appId = appId || config?.app?.appId
-  name = name || config?.app?.appName || 'Unknown'
-  icon = icon || 'resources/icon.png' // default path for capacitor app
-  if (!icon || !name) {
-    p.log.error('Missing argument, you need to provide a appId and a name, or be in a capacitor project')
-    program.error('')
-  }
-  if (throwErr)
-    p.log.info(`Adding ${appId} to Capgo`)
-
-  let iconBuff
-  let iconType
-
-  if (icon && existsSync(icon)) {
-    iconBuff = readFileSync(icon)
-    const contentType = mime.getType(icon)
-    iconType = contentType || 'image/png'
-    p.log.warn(`Found app icon ${icon}`)
-  }
-  else if (existsSync(newIconPath)) {
-    iconBuff = readFileSync(newIconPath)
-    const contentType = mime.getType(newIconPath)
-    iconType = contentType || 'image/png'
-    p.log.warn(`Found app icon ${newIconPath}`)
-  }
-  else {
-    p.log.warn(`Cannot find app icon in any of the following locations: ${icon}, ${newIconPath}`)
-  }
-
-  const fileName = `icon`
-  let signedURL = 'https://xvwzpoazmxkqosrdewyv.supabase.co/storage/v1/object/public/images/capgo.png'
-
-  // upload image if available
-  if (iconBuff && iconType) {
-    const { error } = await supabase.storage
-      .from(`images/org/${organizationUid}/${appId}`)
-      .upload(fileName, iconBuff, {
-        contentType: iconType,
-      })
-    if (error) {
-      console.error(error)
-      p.log.error(`Could not add app ${formatError(error)}`)
-      program.error('')
-    }
-    const { data: signedURLData } = await supabase
-      .storage
-      .from(`images/org/${organizationUid}/${appId}`)
-      .getPublicUrl(fileName)
-    signedURL = signedURLData?.publicUrl || signedURL
-  }
-  // add app to db
-  const { error: dbError } = await supabase
-    .from('apps')
-    .insert({
-      icon_url: signedURL,
-      owner_org: organizationUid,
-      name,
-      app_id: appId,
-    })
-  if (dbError) {
-    p.log.error(`Could not add app ${formatError(dbError)}`)
-    program.error('')
-  }
-  const { error: dbVersionError } = await supabase
-    .from('app_versions')
-    .insert([{
-      owner_org: organizationUid,
-      deleted: true,
-      name: 'unknown',
-      app_id: appId,
-    }, {
-      owner_org: organizationUid,
-      deleted: true,
-      name: 'builtin',
-      app_id: appId,
-    }])
-  if (dbVersionError) {
-    p.log.error(`Could not add app ${formatError(dbVersionError)}`)
-    program.error('')
-  }
-  p.log.success(`App ${appId} added to Capgo. ${throwErr ? 'You can upload a bundle now' : ''}`)
-  if (throwErr) {
-    p.outro(`Done ✅`)
-    process.exit()
-  }
-  return true
-}
-
-export async function addCommand(apikey: string, options: Options) {
-  addApp(apikey, options, true)
-}

package/src/app/debug.ts

@@ -1,259 +0,0 @@
-import process from 'node:process'
-import ky from 'ky'
-import * as p from '@clack/prompts'
-import { program } from 'commander'
-import type LogSnag from 'logsnag'
-import type { Database } from '../types/supabase.types'
-import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
-import { checkLatest } from '../api/update'
-import { OrganizationPerm, convertAppName, createSupabaseClient, defaultApiHost, findSavedKey, formatError, getConfig, getLocalConfig, getOrganizationId, useLogSnag, verifyUser } from '../utils'
-
-function wait(ms: number) {
-  return new Promise((resolve) => {
-    setTimeout(resolve, ms)
-  })
-}
-
-export interface OptionsBaseDebug {
-  apikey: string
-  device?: string
-}
-
-export async function markSnag(channel: string, orgId: string, snag: LogSnag, event: string, icon = '✅') {
-  await snag.track({
-    channel,
-    event,
-    icon,
-    user_id: orgId,
-    notify: false,
-  }).catch()
-}
-
-export async function cancelCommand(channel: string, command: boolean | symbol, orgId: string, snag: LogSnag) {
-  if (p.isCancel(command)) {
-    await markSnag(channel, orgId, snag, 'canceled', '🤷')
-    process.exit()
-  }
-}
-
-interface Order {
-  key: string
-  sortable?: 'asc' | 'desc'
-}
-
-interface QueryStats {
-  appId: string
-  devicesId?: string[]
-  search?: string
-  order?: Order[]
-  rangeStart?: string
-  rangeEnd?: string
-  limit?: number
-}
-interface LogData {
-  app_id: string
-  device_id: string
-  action: Database['public']['Enums']['stats_action']
-  version_id: number
-  version?: number
-  created_at: string
-}
-export async function getStats(apikey: string, query: QueryStats, after: string | null): Promise<LogData[]> {
-  try {
-    const dataD = await ky
-      .post(`${defaultApiHost}/private/stats`, {
-        headers: {
-          'Content-Type': 'application/json',
-          'capgkey': apikey,
-        },
-        body: JSON.stringify(query),
-      })
-      .then(res => res.json<LogData[]>())
-      .catch((err) => {
-        console.error('Cannot get devices', err)
-        return [] as LogData[]
-      })
-    if (dataD?.length > 0 && (after === null || after !== dataD[0].created_at))
-      return dataD
-  }
-  catch (error) {
-    p.log.error(`Cannot get stats ${formatError(error)}`)
-  }
-  return []
-}
-
-async function displayError(data: LogData, channel: string, orgId: string, snag: LogSnag, baseUrl: string) {
-  p.log.info(`Log from Device: ${data.device_id}`)
-  if (data.action === 'get') {
-    p.log.info('Update Sent your your device, wait until event download complete')
-    await markSnag(channel, orgId, snag, 'done')
-  }
-  else if (data.action.startsWith('download_')) {
-    const action = data.action.split('_')[1]
-    if (action === 'complete') {
-      p.log.info('Your bundle has been downloaded on your device, background the app now and open it again to see the update')
-      await markSnag(channel, orgId, snag, 'downloaded')
-    }
-    else if (action === 'fail') {
-      p.log.error('Your bundle has failed to download on your device.')
-      p.log.error('Please check if you have network connection and try again')
-    }
-    else {
-      p.log.info(`Your bundle is downloading ${action}% ...`)
-    }
-  }
-  else if (data.action === 'set') {
-    p.log.info('Your bundle has been set on your device ❤️')
-    await markSnag(channel, orgId, snag, 'set')
-    return false
-  }
-  else if (data.action === 'NoChannelOrOverride') {
-    p.log.error(`No default channel or override (channel/device) found, please create it here ${baseUrl}`)
-  }
-  else if (data.action === 'needPlanUpgrade') {
-    p.log.error('Your are out of quota, please upgrade your plan here https://web.capgo.app/dashboard/settings/plans')
-  }
-  else if (data.action === 'missingBundle') {
-    p.log.error('Your bundle is missing, please check how you build your app')
-  }
-  else if (data.action === 'noNew') {
-    p.log.error(`The version number you uploaded to your default channel in Capgo, is the same as the present in the device ${data.device_id}.`)
-    p.log.error(`To fix it, ensure the variable:
-      - iOS: keyCFBundleShortVersionString or MARKETING_VERSION
-      - Android: versionName
-    Are lower than the version number you uploaded to Capgo.`)
-    p.log.error('More info here: https://capgo.app/blog/how-version-work-in-capgo/#versioning-system')
-  }
-  else if (data.action === 'disablePlatformIos') {
-    p.log.error(`iOS is disabled in the default channel and your device ${data.device_id} is an iOS device ${baseUrl}`)
-  }
-  else if (data.action === 'disablePlatformAndroid') {
-    p.log.error(`Android is disabled in the default channel and your device ${data.device_id} is an Android device ${baseUrl}`)
-  }
-  else if (data.action === 'disableAutoUpdateToMajor') {
-    p.log.error(`The version number you uploaded to your default channel in Capgo, is a major version higher (ex: 1.0.0 in device to 2.0.0 in Capgo) than the present in the device ${data.device_id}.`)
-    p.log.error('Capgo is set by default to protect you from this, and avoid sending breaking changes incompatible with the native code present in the device.')
-    p.log.error(`To fix it, ensure the variable:
-  - iOS: keyCFBundleShortVersionString or MARKETING_VERSION
-  - Android: versionName
-Are lower than the version number you uploaded to Capgo.`)
-    p.log.error('More info here: https://capgo.app/blog/how-version-work-in-capgo/#versioning-system')
-  }
-  else if (data.action === 'disableAutoUpdateUnderNative') {
-    p.log.error(`The version number you uploaded to your default channel in Capgo, is lower than the present in the device ${data.device_id}.`)
-    p.log.error(`To fix it, ensure the variable:
-      - iOS: keyCFBundleShortVersionString or MARKETING_VERSION
-      - Android: versionName
-    Are lower than the version number you uploaded to Capgo.`)
-    p.log.error('More info here: https://capgo.app/blog/how-version-work-in-capgo/#versioning-system')
-  }
-  else if (data.action === 'disableDevBuild') {
-    p.log.error(`Dev build is disabled in the default channel. ${baseUrl}`)
-    p.log.error('Set your channel to allow it if you wanna test your app')
-  }
-  else if (data.action === 'disableEmulator') {
-    p.log.error(`Emulator is disabled in the default channel. ${baseUrl}`)
-    p.log.error('Set your channel to allow it if you wanna test your app')
-  }
-  else if (data.action === 'cannotGetBundle') {
-    p.log.error(`We cannot get your bundle from the default channel. ${baseUrl}`)
-    p.log.error('Are you sure your default channel has a bundle set?')
-  }
-  else if (data.action === 'set_fail') {
-    p.log.error(`Your bundle seems to be corrupted, try to download from ${baseUrl} to identify the issue`)
-  }
-  else if (data.action === 'reset') {
-    p.log.error('Your device has been reset to the builtin bundle, did notifyAppReady() is present in the code builded and uploaded to Capgo ?')
-  }
-  else if (data.action === 'update_fail') {
-    p.log.error('Your bundle has been installed but failed to call notifyAppReady()')
-    p.log.error('Please check if you have network connection and try again')
-  }
-  else if (data.action === 'checksum_fail') {
-    p.log.error('Your bundle has failed to validate checksum, please check your code and send it again to Capgo')
-  }
-  else {
-    p.log.error(`Log from Capgo ${data.action}`)
-  }
-  return true
-}
-
-export async function waitLog(channel: string, apikey: string, appId: string, snag: LogSnag, orgId: string, deviceId?: string) {
-  let loop = true
-  const appIdUrl = convertAppName(appId)
-  const config = await getLocalConfig()
-  const baseUrl = `${config.hostWeb}/app/p/${appIdUrl}`
-  await markSnag(channel, orgId, snag, 'Use waitlog')
-  const query: QueryStats = {
-    appId,
-    devicesId: deviceId ? [deviceId] : undefined,
-    order: [{
-      key: 'created_at',
-      sortable: 'desc',
-    }],
-    rangeStart: new Date().toISOString(),
-  }
-  let after: string | null = null
-  const s = p.spinner()
-  s.start(`Waiting for logs (Expect delay of 30 sec)`)
-  while (loop) {
-    await wait(5000)
-    const data = await getStats(apikey, query, after)
-    if (data.length > 0) {
-      after = data[0].created_at
-      for (const d of data) {
-        loop = await displayError(d, channel, orgId, snag, baseUrl)
-        if (!loop)
-          break
-      }
-    }
-  }
-  s.stop(`Stop watching logs`)
-  return Promise.resolve()
-}
-
-export async function debugApp(appId: string, options: OptionsBaseDebug) {
-  p.intro(`Debug Live update in Capgo`)
-
-  await checkLatest()
-  options.apikey = options.apikey || findSavedKey()
-  const config = await getConfig()
-
-  appId = appId || config?.app?.appId
-  const deviceId = options.device
-  if (!options.apikey) {
-    p.log.error(`Missing API key, you need to provide an API key to delete your app`)
-    program.error('')
-  }
-  if (!appId) {
-    p.log.error('Missing argument, you need to provide a appId, or be in a capacitor project')
-    program.error('')
-  }
-
-  const supabase = await createSupabaseClient(options.apikey)
-  const snag = useLogSnag()
-
-  const userId = await verifyUser(supabase, options.apikey)
-
-  p.log.info(`Getting active bundle in Capgo`)
-
-  // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionOrgErr(supabase, options.apikey, appId, OrganizationPerm.admin)
-
-  const orgId = await getOrganizationId(supabase, appId)
-
-  const doRun = await p.confirm({ message: `Automatic check if update working in device ?` })
-  await cancelCommand('debug', doRun, userId, snag)
-  if (doRun) {
-    p.log.info(`Wait logs sent to Capgo from ${appId} device, Please open your app 💪`)
-    await waitLog('debug', options.apikey, appId, snag, orgId, deviceId)
-    p.outro(`Done ✅`)
-  }
-  else {
-    // const appIdUrl = convertAppName(appId)
-    // p.log.info(`Check logs in https://web.capgo.app/app/p/${appIdUrl}/logs to see if update works.`)
-    p.outro(`Canceled ❌`)
-  }
-  p.outro(`Done ✅`)
-  process.exit()
-}

package/src/app/delete.ts

@@ -1,110 +0,0 @@
-import process from 'node:process'
-import { program } from 'commander'
-import * as p from '@clack/prompts'
-import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
-import type { OptionsBase } from '../utils'
-import { OrganizationPerm, createSupabaseClient, findSavedKey, formatError, getConfig, getOrganizationId, useLogSnag, verifyUser } from '../utils'
-
-export async function deleteApp(appId: string, options: OptionsBase) {
-  p.intro(`Deleting`)
-  options.apikey = options.apikey || findSavedKey()
-  const config = await getConfig()
-  appId = appId || config?.app?.appId
-  const snag = useLogSnag()
-
-  if (!options.apikey) {
-    p.log.error('Missing API key, you need to provide a API key to upload your bundle')
-    program.error('')
-  }
-  if (!appId) {
-    p.log.error('Missing argument, you need to provide a appId, or be in a capacitor project')
-    program.error('')
-  }
-  const supabase = await createSupabaseClient(options.apikey)
-
-  const userId = await verifyUser(supabase, options.apikey, ['write', 'all'])
-  // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionOrgErr(supabase, options.apikey, appId, OrganizationPerm.super_admin)
-
-  const { data: appOwnerRaw, error: appOwnerError } = await supabase.from('apps')
-    .select(`owner_org ( created_by, id )`)
-    .eq('app_id', appId)
-    .single()
-
-  const appOwner = appOwnerRaw as { owner_org: { created_by: string, id: string } } | null
-
-  if (!appOwnerError && (appOwner?.owner_org.created_by ?? '') !== userId) {
-    // We are dealing with a member user that is not the owner
-    // Deleting the app is not recomended at this stage
-
-    p.log.warn('Deleting the app is not recomended for users that are not the organization owner')
-    p.log.warn('You are invited as a super_admin but your are not the owner')
-    p.log.warn('It\'s strongly recomended that you do not continue!')
-
-    const shouldContinue = await p.select({
-      message: 'Do you want to continue?',
-      options: [
-        {
-          label: 'Yes',
-          value: 'yes',
-        },
-        {
-          label: 'No',
-          value: 'no',
-        },
-      ],
-    })
-
-    if (p.isCancel(shouldContinue) || shouldContinue === 'no') {
-      p.log.error('Canceled deleting the app, exiting')
-      program.error('')
-    }
-  }
-  else if (appOwnerError) {
-    p.log.warn(`Cannot get the app owner ${formatError(appOwnerError)}`)
-  }
-
-  const { error } = await supabase
-    .storage
-    .from(`images`)
-    .remove([`org/${appOwner?.owner_org.id}/${appId}/icon`])
-  if (error) {
-    console.error(error, `images/org/${appOwner?.owner_org.id}/${appId}`)
-    p.log.error('Could not delete app logo')
-  }
-
-  // TODO: make the version delete in R2 too
-  const { error: delError } = await supabase
-    .storage
-    .from(`apps/${appId}/${userId}`)
-    .remove(['versions'])
-  if (delError)
-    p.log.error('Could not delete app version')
-  // We should not care too much, most is in r2 anyways :/
-  // program.error('')
-
-  const { error: dbError } = await supabase
-    .from('apps')
-    .delete()
-    .eq('app_id', appId)
-    // .eq('user_id', userId)
-
-  if (dbError) {
-    p.log.error('Could not delete app')
-    program.error('')
-  }
-  const orgId = await getOrganizationId(supabase, appId)
-  await snag.track({
-    channel: 'app',
-    event: 'App Deleted',
-    icon: '🗑️',
-    user_id: orgId,
-    tags: {
-      'app-id': appId,
-    },
-    notify: false,
-  }).catch()
-  p.log.success(`App deleted in Capgo`)
-  p.outro('Done ✅')
-  process.exit()
-}

package/src/app/info.ts

@@ -1,89 +0,0 @@
-import { readFileSync } from 'node:fs'
-import { join } from 'node:path'
-import os from 'node:os'
-import process from 'node:process'
-import getLatest from 'get-latest-version'
-import * as p from '@clack/prompts'
-import pack from '../../package.json'
-
-async function getLatestDependencies(installedDependencies: { [key: string]: string }) {
-  const latestDependencies: { [key: string]: string } = {}
-  const all = []
-  for (const dependency in installedDependencies) {
-    if (Object.prototype.hasOwnProperty.call(installedDependencies, dependency)) {
-      // get in npm the last version of the dependency
-      all.push(getLatest(dependency))
-    }
-  }
-  await Promise.all(all)
-    .then((values) => {
-      const keys = Object.keys(installedDependencies)
-      for (let i = 0; i < values.length; i += 1) {
-        const v = values[i]
-        if (v)
-          latestDependencies[keys[i]] = v
-      }
-    })
-  return latestDependencies
-}
-
-async function readPackageJson() {
-  const packageJson = readFileSync(join(process.cwd(), 'package.json'))
-  return JSON.parse(packageJson as any)
-}
-
-async function getInstalledDependencies() {
-  const { dependencies } = await readPackageJson()
-  const installedDependencies: { [key: string]: string } = {
-    '@capgo/cli': pack.version,
-  }
-  for (const dependency in dependencies) {
-    if (Object.prototype.hasOwnProperty.call(dependencies, dependency)
-      && dependency.startsWith('@capgo/')
-      && dependency.startsWith('@capawesome/')
-      && dependency.startsWith('capacitor')) {
-      // remove ^ or ~ from version
-      const version = dependencies[dependency].replace('^', '').replace('~', '')
-      installedDependencies[dependency] = version
-    }
-  }
-  return installedDependencies
-}
-
-export async function getInfo() {
-  p.log.info(' 💊   Capgo Doctor  💊\n')
-  p.log.info(` OS: ${os.platform()} ${os.version()}\n`)
-  p.log.info(` Node: ${process.version}\n`)
-  p.log.info(' Installed Dependencies:\n')
-  const installedDependencies = await getInstalledDependencies()
-  if (Object.keys(installedDependencies).length === 0) {
-    // display in red color in shell with console log
-    p.log.warning('\x1B[31m%s\x1B[0m 🚨 No dependencies found')
-    process.exit(1)
-  }
-  for (const dependency in installedDependencies) {
-    if (Object.prototype.hasOwnProperty.call(installedDependencies, dependency)) {
-      const installedVersion = (installedDependencies as any)[dependency]
-      p.log.info(`   ${dependency}: ${installedVersion}`)
-    }
-  }
-  p.log.info('\n')
-  const s = p.spinner()
-  s.start(`Running: Loading latest dependencies`)
-  const latestDependencies = await getLatestDependencies(installedDependencies)
-  s.stop(`Latest Dependencies:`)
-  for (const dependency in latestDependencies) {
-    if (Object.prototype.hasOwnProperty.call(latestDependencies, dependency)) {
-      const latestVersion = (latestDependencies as any)[dependency]
-      p.log.info(`   ${dependency}: ${latestVersion}`)
-    }
-  }
-  if (JSON.stringify(installedDependencies) !== JSON.stringify(latestDependencies)) {
-    // display in red color in shell with console log
-    p.log.warn('\x1B[31m🚨 Some dependencies are not up to date\x1B[0m')
-    process.exit(1)
-  }
-  // display in green color in shell with console log
-  p.log.success('\x1B[32m✅ All dependencies are up to date\x1B[0m')
-  process.exit()
-}

package/src/app/list.ts

@@ -1,67 +0,0 @@
-import process from 'node:process'
-import { program } from 'commander'
-import { Table } from 'console-table-printer'
-import type { SupabaseClient } from '@supabase/supabase-js'
-import * as p from '@clack/prompts'
-import type { Database } from '../types/supabase.types'
-import type { OptionsBase } from '../utils'
-import { createSupabaseClient, findSavedKey, getHumanDate, verifyUser } from '../utils'
-import { checkLatest } from '../api/update'
-
-function displayApp(data: Database['public']['Tables']['apps']['Row'][]) {
-  if (!data.length) {
-    p.log.error('No apps found')
-    process.exit(1)
-  }
-  const t = new Table({
-    title: 'Apps',
-    charLength: { '❌': 2, '✅': 2 },
-  })
-
-  // add rows with color
-  data.reverse().forEach((row) => {
-    t.addRow({
-      Name: row.name,
-      id: row.app_id,
-      Created: getHumanDate(row.created_at),
-    })
-  })
-
-  p.log.success(t.render())
-}
-
-export async function getActiveApps(supabase: SupabaseClient<Database>) {
-  const { data, error: vError } = await supabase
-    .from('apps')
-    .select()
-    // .eq('user_id', userId)
-    .order('created_at', { ascending: false })
-
-  if (vError) {
-    p.log.error('Apps not found')
-    program.error('')
-  }
-  return data
-}
-
-export async function listApp(options: OptionsBase) {
-  p.intro(`List apps in Capgo`)
-
-  await checkLatest()
-  options.apikey = options.apikey || findSavedKey()
-
-  const supabase = await createSupabaseClient(options.apikey)
-
-  await verifyUser(supabase, options.apikey, ['write', 'all', 'read', 'upload'])
-
-  p.log.info(`Getting active bundle in Capgo`)
-
-  // Get all active app versions we might possibly be able to cleanup
-  const allApps = await getActiveApps(supabase)
-
-  p.log.info(`Active app in Capgo: ${allApps?.length}`)
-
-  displayApp(allApps)
-  p.outro(`Done ✅`)
-  process.exit()
-}