@capgo/cli 4.12.12 → 4.12.14-beta.0

package/src/bundle/upload.ts

@@ -1,17 +1,19 @@
 import { randomUUID } from 'node:crypto'
 import { existsSync, readFileSync } from 'node:fs'
+import { exit } from 'node:process'
 import type { Buffer } from 'node:buffer'
-import process from 'node:process'
-import * as p from '@clack/prompts'
 import { program } from 'commander'
 import { checksum as getChecksum } from '@tomasklaen/checksum'
 import ciDetect from 'ci-info'
 import type LogSnag from 'logsnag'
+import { S3Client } from '@bradenmacdonald/s3-lite-client'
 import ky, { HTTPError } from 'ky'
+import { confirm as confirmC, intro, log, outro, spinner as spinnerC } from '@clack/prompts'
 import { encryptSource } from '../api/crypto'
-import { type OptionsBase, OrganizationPerm, baseKeyPub, checkChecksum, checkCompatibility, checkPlanValid, convertAppName, createSupabaseClient, deletedFailedVersion, findSavedKey, formatError, getConfig, getLocalConfig, getLocalDepenencies, getOrganizationId, getPMAndCommand, hasOrganizationPerm, regexSemver, updateOrCreateChannel, updateOrCreateVersion, uploadMultipart, uploadUrl, useLogSnag, verifyUser, zipFile } from '../utils'
+import { type OptionsBase, OrganizationPerm, baseKeyPub, checkChecksum, checkCompatibility, checkPlanValid, convertAppName, createSupabaseClient, deletedFailedVersion, findSavedKey, formatError, getConfig, getLocalConfig, getLocalDepenencies, getOrganizationId, getPMAndCommand, hasOrganizationPerm, readPackageJson, regexSemver, updateOrCreateChannel, updateOrCreateVersion, uploadMultipart, uploadUrl, useLogSnag, verifyUser, zipFile } from '../utils'
 import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
 import { checkLatest } from '../api/update'
+import type { CapacitorConfig } from '../config'
 import { checkIndexPosition, searchInDirectory } from './check'
 
 interface Options extends OptionsBase {
@@ -27,6 +29,9 @@ interface Options extends OptionsBase {
   s3Apikey?: string
   s3Apisecret?: string
   s3BucketName?: string
+  s3Port?: number
+  s3SSL?: boolean
+  s3Endpoint?: string
   bundleUrl?: boolean
   codeCheck?: boolean
   minUpdateVersion?: string
@@ -40,20 +45,20 @@ interface Options extends OptionsBase {
 const alertMb = 20
 const UPLOAD_TIMEOUT = 120000
 
-type ConfigType = Awaited<ReturnType<typeof getConfig>>
 type SupabaseType = Awaited<ReturnType<typeof createSupabaseClient>>
 type pmType = ReturnType<typeof getPMAndCommand>
 type localConfigType = Awaited<ReturnType<typeof getLocalConfig>>
 
-function getBundle(config: ConfigType, options: Options) {
+async function getBundle(config: CapacitorConfig, options: Options) {
+  const pkg = await readPackageJson()
   // create bundle name format : 1.0.0-beta.x where x is a uuid
   const bundle = options.bundle
-    || config?.app?.extConfig?.plugins?.CapacitorUpdater?.version
-    || config?.app?.package?.version
+    || config?.plugins?.CapacitorUpdater?.version
+    || pkg?.version
     || `0.0.1-beta.${randomUUID().split('-')[0]}`
 
   if (!regexSemver.test(bundle)) {
-    p.log.error(`Your bundle name ${bundle}, is not valid it should follow semver convention : https://semver.org/`)
+    log.error(`Your bundle name ${bundle}, is not valid it should follow semver convention : https://semver.org/`)
     program.error('')
   }
 
@@ -63,24 +68,24 @@ function getBundle(config: ConfigType, options: Options) {
 function getApikey(options: Options) {
   const apikey = options.apikey || findSavedKey()
   if (!apikey) {
-    p.log.error(`Missing API key, you need to provide a API key to upload your bundle`)
+    log.error(`Missing API key, you need to provide a API key to upload your bundle`)
     program.error('')
   }
 
   return apikey
 }
 
-function getAppIdAndPath(appId: string | undefined, options: Options, config: ConfigType) {
-  const finalAppId = appId || config?.app?.appId
-  const path = options.path || config?.app?.webDir
+function getAppIdAndPath(appId: string | undefined, options: Options, config: CapacitorConfig) {
+  const finalAppId = appId || config?.appId
+  const path = options.path || config?.webDir
 
   if (!finalAppId || !path) {
-    p.log.error('Missing argument, you need to provide a appid and a path (--path), or be in a capacitor project')
+    log.error('Missing argument, you need to provide a appid and a path (--path), or be in a capacitor project')
     program.error('')
   }
 
   if (!existsSync(path)) {
-    p.log.error(`Path ${path} does not exist, build your app first, or provide a valid path`)
+    log.error(`Path ${path} does not exist, build your app first, or provide a valid path`)
     program.error('')
   }
 
@@ -93,12 +98,12 @@ function checkNotifyAppReady(options: Options, path: string) {
   if (typeof checkNotifyAppReady === 'undefined' || checkNotifyAppReady) {
     const isPluginConfigured = searchInDirectory(path, 'notifyAppReady')
     if (!isPluginConfigured) {
-      p.log.error(`notifyAppReady() is missing in the source code. see: https://capgo.app/docs/plugin/api/#notifyappready`)
+      log.error(`notifyAppReady() is missing in the source code. see: https://capgo.app/docs/plugin/api/#notifyappready`)
       program.error('')
     }
     const foundIndex = checkIndexPosition(path)
     if (!foundIndex) {
-      p.log.error(`index.html is missing in the root folder or in the only folder in the root folder`)
+      log.error(`index.html is missing in the root folder or in the only folder in the root folder`)
       program.error('')
     }
   }
@@ -125,7 +130,7 @@ async function verifyCompatibility(supabase: SupabaseType, pm: pmType, options:
 
   // We only check compatibility IF the channel exists
   if (!channelError && channelData && channelData.version && (channelData.version as any).native_packages && !ignoreMetadataCheck) {
-    const spinner = p.spinner()
+    const spinner = spinnerC()
     spinner.start(`Checking bundle compatibility with channel ${channel}`)
     const {
       finalCompatibility: finalCompatibilityWithChannel,
@@ -137,18 +142,18 @@ async function verifyCompatibility(supabase: SupabaseType, pm: pmType, options:
 
     if (finalCompatibility.find(x => x.localVersion !== x.remoteVersion)) {
       spinner.stop(`Bundle NOT compatible with ${channel} channel`)
-      p.log.warn(`You can check compatibility with "${pm.runner} @capgo/cli bundle compatibility"`)
+      log.warn(`You can check compatibility with "${pm.runner} @capgo/cli bundle compatibility"`)
 
       if (autoMinUpdateVersion) {
         minUpdateVersion = bundle
-        p.log.info(`Auto set min-update-version to ${minUpdateVersion}`)
+        log.info(`Auto set min-update-version to ${minUpdateVersion}`)
       }
     }
     else if (autoMinUpdateVersion) {
       try {
         const { minUpdateVersion: lastMinUpdateVersion } = channelData.version as any
         if (!lastMinUpdateVersion || !regexSemver.test(lastMinUpdateVersion)) {
-          p.log.error('Invalid remote min update version, skipping auto setting compatibility')
+          log.error('Invalid remote min update version, skipping auto setting compatibility')
           program.error('')
         }
 
@@ -156,7 +161,7 @@ async function verifyCompatibility(supabase: SupabaseType, pm: pmType, options:
         spinner.stop(`Auto set min-update-version to ${minUpdateVersion}`)
       }
       catch (error) {
-        p.log.error(`Cannot auto set compatibility, invalid data ${channelData}`)
+        log.error(`Cannot auto set compatibility, invalid data ${channelData}`)
         program.error('')
       }
     }
@@ -165,23 +170,23 @@ async function verifyCompatibility(supabase: SupabaseType, pm: pmType, options:
     }
   }
   else if (!ignoreMetadataCheck) {
-    p.log.warn(`Channel ${channel} is new or it's your first upload with compatibility check, it will be ignored this time`)
+    log.warn(`Channel ${channel} is new or it's your first upload with compatibility check, it will be ignored this time`)
     localDependencies = await getLocalDepenencies()
 
     if (autoMinUpdateVersion) {
       minUpdateVersion = bundle
-      p.log.info(`Auto set min-update-version to ${minUpdateVersion}`)
+      log.info(`Auto set min-update-version to ${minUpdateVersion}`)
     }
   }
 
   if (updateMetadataRequired && !minUpdateVersion && !ignoreMetadataCheck) {
-    p.log.error(`You need to provide a min-update-version to upload a bundle to this channel`)
+    log.error(`You need to provide a min-update-version to upload a bundle to this channel`)
     program.error('')
   }
 
   if (minUpdateVersion) {
     if (!regexSemver.test(minUpdateVersion)) {
-      p.log.error(`Your minimal version update ${minUpdateVersion}, is not valid it should follow semver convention : https://semver.org/`)
+      log.error(`Your minimal version update ${minUpdateVersion}, is not valid it should follow semver convention : https://semver.org/`)
       program.error('')
     }
   }
@@ -203,8 +208,8 @@ async function checkTrial(supabase: SupabaseType, orgId: string, localConfig: lo
     .single()
   if ((isTrial && isTrial > 0) || isTrialsError) {
   // TODO: Come back to this to fix for orgs v3
-    p.log.warn(`WARNING !!\nTrial expires in ${isTrial} days`)
-    p.log.warn(`Upgrade here: ${localConfig.hostWeb}/dashboard/settings/plans?oid=${orgId}`)
+    log.warn(`WARNING !!\nTrial expires in ${isTrial} days`)
+    log.warn(`Upgrade here: ${localConfig.hostWeb}/dashboard/settings/plans?oid=${orgId}`)
   }
 }
 
@@ -217,7 +222,7 @@ async function checkVersionExists(supabase: SupabaseType, appid: string, bundle:
     .single()
 
   if (appVersion || appVersionError) {
-    p.log.error(`Version already exists ${formatError(appVersionError)}`)
+    log.error(`Version already exists ${formatError(appVersionError)}`)
     program.error('')
   }
 }
@@ -229,28 +234,28 @@ async function prepareBundleFile(path: string, options: Options, localConfig: lo
   const key = options.key
 
   zipped = await zipFile(path)
-  const s = p.spinner()
+  const s = spinnerC()
   s.start(`Calculating checksum`)
   checksum = await getChecksum(zipped, 'crc32')
   s.stop(`Checksum: ${checksum}`)
   // key should be undefined or a string if false it should ingore encryption
   if (!key) {
-    p.log.info(`Encryption ignored`)
+    log.info(`Encryption ignored`)
   }
   else if (key || existsSync(baseKeyPub)) {
     const publicKey = typeof key === 'string' ? key : baseKeyPub
     let keyData = options.keyData || ''
     // check if publicKey exist
     if (!keyData && !existsSync(publicKey)) {
-      p.log.error(`Cannot find public key ${publicKey}`)
+      log.error(`Cannot find public key ${publicKey}`)
       if (ciDetect.isCI) {
-        p.log.error('Cannot ask if user wants to use capgo public key on the cli')
+        log.error('Cannot ask if user wants to use capgo public key on the cli')
         program.error('')
       }
 
-      const res = await p.confirm({ message: 'Do you want to use our public key ?' })
+      const res = await confirmC({ message: 'Do you want to use our public key ?' })
       if (!res) {
-        p.log.error(`Error: Missing public key`)
+        log.error(`Error: Missing public key`)
         program.error('')
       }
       keyData = localConfig.signKey || ''
@@ -271,11 +276,11 @@ async function prepareBundleFile(path: string, options: Options, localConfig: lo
       keyData = keyFile.toString()
     }
     // encrypt
-    p.log.info(`Encrypting your bundle`)
+    log.info(`Encrypting your bundle`)
     const res = encryptSource(zipped, keyData)
     sessionKey = res.ivSessionKey
     if (options.displayIvSession) {
-      p.log.info(`Your Iv Session key is ${sessionKey},
+      log.info(`Your Iv Session key is ${sessionKey},
 keep it safe, you will need it to decrypt your bundle.
 It will be also visible in your dashboard\n`)
     }
@@ -283,8 +288,8 @@ It will be also visible in your dashboard\n`)
   }
   const mbSize = Math.floor((zipped?.byteLength ?? 0) / 1024 / 1024)
   if (mbSize > alertMb) {
-    p.log.warn(`WARNING !!\nThe app size is ${mbSize} Mb, this may take a while to download for users\n`)
-    p.log.info(`Learn how to optimize your assets https://capgo.app/blog/optimise-your-images-for-updates/\n`)
+    log.warn(`WARNING !!\nThe app size is ${mbSize} Mb, this may take a while to download for users\n`)
+    log.info(`Learn how to optimize your assets https://capgo.app/blog/optimise-your-images-for-updates/\n`)
     await snag.track({
       channel: 'app-error',
       event: 'App Too Large',
@@ -301,19 +306,19 @@ It will be also visible in your dashboard\n`)
 }
 
 async function uploadBundleToCapgoCloud(supabase: SupabaseType, appid: string, bundle: string, orgId: string, zipped: Buffer, options: Options) {
-  const spinner = p.spinner()
+  const spinner = spinnerC()
   spinner.start(`Uploading Bundle`)
   const startTime = performance.now()
 
   try {
     if (options.multipart !== undefined && options.multipart) {
-      p.log.info(`Uploading bundle as multipart`)
+      log.info(`Uploading bundle as multipart`)
       await uploadMultipart(supabase, appid, bundle, zipped, orgId)
     }
     else {
       const url = await uploadUrl(supabase, appid, bundle)
       if (!url) {
-        p.log.error(`Cannot get upload url`)
+        log.error(`Cannot get upload url`)
         program.error('')
       }
       await ky.put(url, {
@@ -327,10 +332,10 @@ async function uploadBundleToCapgoCloud(supabase: SupabaseType, appid: string, b
     const endTime = performance.now()
     const uploadTime = ((endTime - startTime) / 1000).toFixed(2)
     spinner.stop(`Failed to upload bundle ( after ${uploadTime} seconds)`)
-    p.log.error(`Cannot upload bundle ( try again with --multipart option) ${formatError(errorUpload)}`)
+    log.error(`Cannot upload bundle ( try again with --multipart option) ${formatError(errorUpload)}`)
     if (errorUpload instanceof HTTPError) {
       const body = await errorUpload.response.text()
-      p.log.error(`Response: ${formatError(body)}`)
+      log.error(`Response: ${formatError(body)}`)
     }
     // call delete version on path /delete_failed_version to delete the version
     await deletedFailedVersion(supabase, appid, bundle)
@@ -367,68 +372,46 @@ async function setVersionInChannel(
       owner_org: orgId,
     })
     if (dbError3) {
-      p.log.error(`Cannot set channel, the upload key is not allowed to do that, use the "all" for this. ${formatError(dbError3)}`)
+      log.error(`Cannot set channel, the upload key is not allowed to do that, use the "all" for this. ${formatError(dbError3)}`)
       program.error('')
     }
     const appidWeb = convertAppName(appid)
     const bundleUrl = `${localConfig.hostWeb}/app/p/${appidWeb}/channel/${data.id}`
     if (data?.public)
-      p.log.info('Your update is now available in your public channel 🎉')
+      log.info('Your update is now available in your public channel 🎉')
     else if (data?.id)
-      p.log.info(`Link device to this bundle to try it: ${bundleUrl}`)
+      log.info(`Link device to this bundle to try it: ${bundleUrl}`)
 
     if (displayBundleUrl) {
-      p.log.info(`Bundle url: ${bundleUrl}`)
+      log.info(`Bundle url: ${bundleUrl}`)
     }
     else if (!versionId) {
-      p.log.warn('Cannot set bundle with upload key, use key with more rights for that')
+      log.warn('Cannot set bundle with upload key, use key with more rights for that')
       program.error('')
     }
     else if (!hasOrganizationPerm(permissions, OrganizationPerm.write)) {
-      p.log.warn('Cannot set channel as a upload organization member')
+      log.warn('Cannot set channel as a upload organization member')
     }
   }
 }
 
 export async function uploadBundle(preAppid: string, options: Options, shouldExit = true) {
-  p.intro(`Uploading`)
+  intro(`Uploading`)
   const pm = getPMAndCommand()
   await checkLatest()
 
-  const { s3Region, s3Apikey, s3Apisecret, s3BucketName } = options
-
-  if (s3BucketName || s3Region || s3Apikey || s3Apisecret) {
-    if (!s3BucketName || !s3Region || !s3Apikey || !s3Apisecret) {
-      p.log.error('Missing argument, for S3 upload you need to provide a bucket name, region, API key, and API secret')
-      program.error('')
-    }
-  }
-
-  if (s3Region && s3Apikey && s3Apisecret && s3BucketName) {
-    p.log.info('Uploading to S3')
-    // const s3Client = new S3Client({
-    //   region: s3Region,
-    //   credentials: {
-    //     accessKeyId: s3Apikey,
-    //     secretAccessKey: s3Apisecret,
-    //   },
-    // })
-    p.log.error('S3 upload is not available we have currenly an issue with it')
-    program.error('')
-    // todo: figure out s3 upload
-    return
-  }
+  const { s3Region, s3Apikey, s3Apisecret, s3BucketName, s3Endpoint, s3Port, s3SSL } = options
 
   const apikey = getApikey(options)
-  const config = await getConfig()
-  const { appid, path } = getAppIdAndPath(preAppid, options, config)
-  const bundle = getBundle(config, options)
+  const extConfig = await getConfig()
+  const { appid, path } = getAppIdAndPath(preAppid, options, extConfig.config)
+  const bundle = await getBundle(extConfig.config, options)
   const channel = options.channel || 'dev'
   const snag = useLogSnag()
 
   checkNotifyAppReady(options, path)
 
-  p.log.info(`Upload ${appid}@${bundle} started from path "${path}" to Capgo cloud`)
+  log.info(`Upload ${appid}@${bundle} started from path "${path}" to Capgo cloud`)
 
   const localConfig = await getLocalConfig()
   const supabase = await createSupabaseClient(apikey)
@@ -444,7 +427,7 @@ export async function uploadBundle(preAppid: string, options: Options, shouldExi
   await checkVersionExists(supabase, appid, bundle)
 
   if (options.external && !options.external.startsWith('https://')) {
-    p.log.error(`External link should should start with "https://" current is "${external}"`)
+    log.error(`External link should should start with "https://" current is "${external}"`)
     program.error('')
   }
 
@@ -488,17 +471,41 @@ export async function uploadBundle(preAppid: string, options: Options, shouldExi
 
   const { error: dbError } = await updateOrCreateVersion(supabase, versionData)
   if (dbError) {
-    p.log.error(`Cannot add bundle ${formatError(dbError)}`)
+    log.error(`Cannot add bundle ${formatError(dbError)}`)
     program.error('')
   }
 
-  if (zipped) {
+  if (zipped && (s3BucketName || s3Endpoint || s3Region || s3Apikey || s3Apisecret || s3Port || s3SSL)) {
+    if (!s3BucketName || !s3Endpoint || !s3Region || !s3Apikey || !s3Apisecret || !s3Port) {
+      log.error('Missing argument, for S3 upload you need to provide a bucket name, endpoint, region, port, API key, and API secret')
+      program.error('')
+    }
+
+    log.info('Uploading to S3')
+    const s3Client = new S3Client({
+      endPoint: s3Endpoint,
+      region: s3Region,
+      port: s3Port,
+      useSSL: s3SSL,
+      bucket: s3BucketName,
+      credentials: {
+        accessKeyId: s3Apikey,
+        secretAccessKey: s3Apisecret,
+      },
+    })
+    const fileName = `${appid}-${bundle}`
+    const encodeFileName = encodeURIComponent(fileName)
+    await s3Client.putObject(fileName, zipped)
+    versionData.external_url = `https://${s3Endpoint}/${encodeFileName}`
+    versionData.storage_provider = 'external'
+  }
+  else if (zipped) {
     await uploadBundleToCapgoCloud(supabase, appid, bundle, orgId, zipped, options)
 
     versionData.storage_provider = 'r2'
     const { error: dbError2 } = await updateOrCreateVersion(supabase, versionData)
     if (dbError2) {
-      p.log.error(`Cannot update bundle ${formatError(dbError2)}`)
+      log.error(`Cannot update bundle ${formatError(dbError2)}`)
       program.error('')
     }
   }
@@ -516,8 +523,8 @@ export async function uploadBundle(preAppid: string, options: Options, shouldExi
     notify: false,
   }).catch()
   if (shouldExit) {
-    p.outro('Time to share your update to the world 🌍')
-    process.exit()
+    outro('Time to share your update to the world 🌍')
+    exit()
   }
   return true
 }
@@ -527,19 +534,19 @@ export async function uploadCommand(appid: string, options: Options) {
     await uploadBundle(appid, options, true)
   }
   catch (error) {
-    p.log.error(formatError(error))
+    log.error(formatError(error))
     program.error('')
   }
 }
 
 export async function uploadDeprecatedCommand(appid: string, options: Options) {
   const pm = getPMAndCommand()
-  p.log.warn(`⚠️  This command is deprecated, use "${pm.runner} @capgo/cli bundle upload" instead ⚠️`)
+  log.warn(`⚠️  This command is deprecated, use "${pm.runner} @capgo/cli bundle upload" instead ⚠️`)
   try {
     await uploadBundle(appid, options, true)
   }
   catch (error) {
-    p.log.error(formatError(error))
+    log.error(formatError(error))
     program.error('')
   }
 }

package/src/bundle/zip.ts

@@ -1,9 +1,9 @@
 import { randomUUID } from 'node:crypto'
 import { writeFileSync } from 'node:fs'
-import process from 'node:process'
+import { exit } from 'node:process'
 import { program } from 'commander'
-import * as p from '@clack/prompts'
 import { checksum as getChecksum } from '@tomasklaen/checksum'
+import { intro, log, outro, spinner } from '@clack/prompts'
 import { checkLatest } from '../api/update'
 import type {
   OptionsBase,
@@ -11,6 +11,7 @@ import type {
 import {
   formatError,
   getConfig,
+  readPackageJson,
   regexSemver,
   useLogSnag,
   zipFile,
@@ -35,37 +36,38 @@ export async function zipBundle(appId: string, options: Options) {
     if (!json)
       await checkLatest()
 
-    const config = await getConfig()
-    appId = appId || config?.app?.appId
+    const extConfig = await getConfig()
+    appId = appId || extConfig?.config?.appId
     // create bundle name format : 1.0.0-beta.x where x is a uuid
     const uuid = randomUUID().split('-')[0]
-    bundle = bundle || config?.app?.package?.version || `0.0.1-beta.${uuid}`
+    const pack = await readPackageJson()
+    bundle = bundle || pack?.version || `0.0.1-beta.${uuid}`
     if (!json)
-      p.intro(`Zipping ${appId}@${bundle}`)
+      intro(`Zipping ${appId}@${bundle}`)
     // check if bundle is valid
-    if (!regexSemver.test(bundle)) {
+    if (bundle && !regexSemver.test(bundle)) {
       if (!json)
-        p.log.error(`Your bundle name ${bundle}, is not valid it should follow semver convention : https://semver.org/`)
+        log.error(`Your bundle name ${bundle}, is not valid it should follow semver convention : https://semver.org/`)
       else
         console.error(formatError({ error: 'invalid_semver' }))
       program.error('')
     }
-    path = path || config?.app?.webDir
+    path = path || extConfig?.config?.webDir
     if (!appId || !bundle || !path) {
       if (!json)
-        p.log.error('Missing argument, you need to provide a appId and a bundle and a path, or be in a capacitor project')
+        log.error('Missing argument, you need to provide a appId and a bundle and a path, or be in a capacitor project')
       else
         console.error(formatError({ error: 'missing_argument' }))
       program.error('')
     }
     if (!json)
-      p.log.info(`Started from path "${path}"`)
+      log.info(`Started from path "${path}"`)
     const checkNotifyAppReady = options.codeCheck
     if (typeof checkNotifyAppReady === 'undefined' || checkNotifyAppReady) {
       const isPluginConfigured = searchInDirectory(path, 'notifyAppReady')
       if (!isPluginConfigured) {
         if (!json)
-          p.log.error(`notifyAppReady() is missing in the source code. see: https://capgo.app/docs/plugin/api/#notifyappready`)
+          log.error(`notifyAppReady() is missing in the source code. see: https://capgo.app/docs/plugin/api/#notifyappready`)
         else
           console.error(formatError({ error: 'notifyAppReady_not_in_source_code' }))
         program.error('')
@@ -73,7 +75,7 @@ export async function zipBundle(appId: string, options: Options) {
       const foundIndex = checkIndexPosition(path)
       if (!foundIndex) {
         if (!json)
-          p.log.error(`index.html is missing in the root folder or in the only folder in the root folder`)
+          log.error(`index.html is missing in the root folder or in the only folder in the root folder`)
         else
           console.error(formatError({ error: 'index_html_not_found' }))
         program.error('')
@@ -81,8 +83,8 @@ export async function zipBundle(appId: string, options: Options) {
     }
     const zipped = await zipFile(path)
     if (!json)
-      p.log.info(`Zipped ${zipped.byteLength} bytes`)
-    const s = p.spinner()
+      log.info(`Zipped ${zipped.byteLength} bytes`)
+    const s = spinner()
     if (!json)
       s.start(`Calculating checksum`)
     const checksum = await getChecksum(zipped, 'crc32')
@@ -91,8 +93,8 @@ export async function zipBundle(appId: string, options: Options) {
     const mbSize = Math.floor(zipped.byteLength / 1024 / 1024)
     // We do not issue this warning for json
     if (mbSize > alertMb && !json) {
-      p.log.warn(`WARNING !!\nThe app size is ${mbSize} Mb, this may take a while to download for users\n`)
-      p.log.warn(`Learn how to optimize your assets https://capgo.app/blog/optimise-your-images-for-updates/\n`)
+      log.warn(`WARNING !!\nThe app size is ${mbSize} Mb, this may take a while to download for users\n`)
+      log.warn(`Learn how to optimize your assets https://capgo.app/blog/optimise-your-images-for-updates/\n`)
       await snag.track({
         channel: 'app-error',
         event: 'App Too Large',
@@ -103,7 +105,7 @@ export async function zipBundle(appId: string, options: Options) {
         notify: false,
       }).catch()
     }
-    const s2 = p.spinner()
+    const s2 = spinner()
     const name = options.name || `${appId}_${bundle}.zip`
     if (!json)
       s2.start(`Saving to ${name}`)
@@ -122,7 +124,7 @@ export async function zipBundle(appId: string, options: Options) {
     }).catch()
 
     if (!json)
-      p.outro(`Done ✅`)
+      outro(`Done ✅`)
 
     if (json) {
       const output = {
@@ -134,10 +136,10 @@ export async function zipBundle(appId: string, options: Options) {
       // eslint-disable-next-line no-console
       console.log(JSON.stringify(output, null, 2))
     }
-    process.exit()
+    exit()
   }
   catch (error) {
-    p.log.error(formatError(error))
+    log.error(formatError(error))
     program.error('')
   }
 }

package/src/channel/add.ts

@@ -1,6 +1,6 @@
-import process from 'node:process'
+import { exit } from 'node:process'
 import { program } from 'commander'
-import * as p from '@clack/prompts'
+import { intro, log, outro } from '@clack/prompts'
 import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
 import { createChannel, findUnknownVersion } from '../api/channels'
 import type { OptionsBase } from '../utils'
@@ -11,18 +11,18 @@ interface Options extends OptionsBase {
 }
 
 export async function addChannel(channelId: string, appId: string, options: Options, shouldExit = true) {
-  p.intro(`Create channel`)
+  intro(`Create channel`)
   options.apikey = options.apikey || findSavedKey()
-  const config = await getConfig()
-  appId = appId || config?.app?.appId
+  const extConfig = await getConfig()
+  appId = appId || extConfig?.config?.appId
   const snag = useLogSnag()
 
   if (!options.apikey) {
-    p.log.error('Missing API key, you need to provide a API key to upload your bundle')
+    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')
+    log.error('Missing argument, you need to provide a appId, or be in a capacitor project')
     program.error('')
   }
   const supabase = await createSupabaseClient(options.apikey)
@@ -31,12 +31,12 @@ export async function addChannel(channelId: string, appId: string, options: Opti
   // Check we have app access to this appId
   await checkAppExistsAndHasPermissionOrgErr(supabase, options.apikey, appId, OrganizationPerm.admin)
 
-  p.log.info(`Creating channel ${appId}#${channelId} to Capgo`)
+  log.info(`Creating channel ${appId}#${channelId} to Capgo`)
   try {
     const data = await findUnknownVersion(supabase, appId)
     const orgId = await getOrganizationId(supabase, appId)
     if (!data) {
-      p.log.error(`Cannot find default version for channel creation, please contact Capgo support 🤨`)
+      log.error(`Cannot find default version for channel creation, please contact Capgo support 🤨`)
       program.error('')
     }
     const res = await createChannel(supabase, {
@@ -47,11 +47,11 @@ export async function addChannel(channelId: string, appId: string, options: Opti
     })
 
     if (res.error) {
-      p.log.error(`Cannot create Channel 🙀\n${formatError(res.error)}`)
+      log.error(`Cannot create Channel 🙀\n${formatError(res.error)}`)
       program.error('')
     }
 
-    p.log.success(`Channel created ✅`)
+    log.success(`Channel created ✅`)
     await snag.track({
       channel: 'channel',
       event: 'Create channel',
@@ -65,12 +65,12 @@ export async function addChannel(channelId: string, appId: string, options: Opti
     }).catch()
   }
   catch (error) {
-    p.log.error(`Cannot create Channel 🙀`)
+    log.error(`Cannot create Channel 🙀`)
     return false
   }
   if (shouldExit) {
-    p.outro(`Done ✅`)
-    process.exit()
+    outro(`Done ✅`)
+    exit()
   }
   return true
 }