@capgo/cli 5.0.0-alpha.7 → 7.0.1

package/src/app/set.ts

@@ -1,94 +0,0 @@
-import { randomUUID } from 'node:crypto'
-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 type { Options } from '../api/app'
-import { checkAppExistsAndHasPermissionOrgErr, newIconPath } from '../api/app'
-import { OrganizationPerm, createSupabaseClient, findSavedKey, formatError, getConfig, verifyUser } from '../utils'
-
-export async function setApp(appId: string, options: Options) {
-  p.intro(`Set app`)
-  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(``)
-  }
-  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.admin)
-
-  const { name, icon, retention } = options
-
-  if (retention && Number.isNaN(Number(retention))) {
-    p.log.error(`retention value must be a number`)
-    program.error(``)
-  }
-  else if (retention && retention < 0) {
-    p.log.error(`retention value cannot be less than 0`)
-    program.error(``)
-  }
-
-  let iconBuff
-  let iconType
-  const fileName = `icon_${randomUUID()}`
-  let signedURL = 'https://xvwzpoazmxkqosrdewyv.supabase.co/storage/v1/object/public/images/capgo.png'
-
-  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}`)
-  }
-  if (iconBuff && iconType) {
-    const { error } = await supabase.storage
-      .from(`images/${userId}/${appId}`)
-      .upload(fileName, iconBuff, {
-        contentType: iconType,
-      })
-    if (error) {
-      p.log.error(`Could not set app ${formatError(error)}`)
-      program.error(``)
-    }
-    const { data: signedURLData } = await supabase
-      .storage
-      .from(`images/${userId}/${appId}`)
-      .getPublicUrl(fileName)
-    signedURL = signedURLData?.publicUrl || signedURL
-  }
-  // retention is in seconds in the database but received as days here
-  const { error: dbError } = await supabase
-    .from('apps')
-    .update({
-      icon_url: signedURL,
-      name,
-      retention: !retention ? undefined : retention * 24 * 60 * 60,
-    })
-    .eq('app_id', appId)
-    .eq('user_id', userId)
-  if (dbError) {
-    p.log.error(`Could not set app ${formatError(dbError)}`)
-    program.error(``)
-  }
-  p.outro(`Done ✅`)
-  process.exit()
-}

package/src/bundle/check.ts

@@ -1,42 +0,0 @@
-import fs from 'node:fs'
-import path from 'node:path'
-
-function searchInFile(filePath: string, searchString: string) {
-  const content = fs.readFileSync(filePath, 'utf8')
-  return content.includes(searchString)
-}
-
-export function searchInDirectory(dirPath: string, searchString: string) {
-  const files = fs.readdirSync(dirPath)
-  for (const file of files) {
-    const filePath = path.join(dirPath, file)
-    const stats = fs.statSync(filePath)
-
-    if (stats.isDirectory()) {
-      if (searchInDirectory(filePath, searchString))
-        return true
-    }
-    else if (stats.isFile() && path.extname(filePath) === '.js') {
-      if (searchInFile(filePath, searchString))
-        return true
-    }
-  }
-
-  return false
-}
-
-export function checkIndexPosition(dirPath: string): boolean {
-  // look for index.html in the root folder or if there only one folder in the root folder look for index.html in this folder
-  const files = fs.readdirSync(dirPath)
-  if (files.length === 1) {
-    const filePath = path.join(dirPath, files[0])
-    const stats = fs.statSync(filePath)
-    if (stats.isDirectory())
-      return checkIndexPosition(filePath)
-  }
-  const index = files.indexOf('index.html')
-  if (index > -1)
-    return true
-
-  return false
-}

package/src/bundle/cleanup.ts

@@ -1,127 +0,0 @@
-import process from 'node:process'
-import { program } from 'commander'
-import semver from 'semver/preload'
-import * as p from '@clack/prompts'
-import promptSync from 'prompt-sync'
-import type { SupabaseClient } from '@supabase/supabase-js'
-import type { Database } from '../types/supabase.types'
-import type { OptionsBase } from '../utils'
-import { OrganizationPerm, createSupabaseClient, findSavedKey, getConfig, getHumanDate, verifyUser } from '../utils'
-import { deleteSpecificVersion, displayBundles, getActiveAppVersions, getChannelsVersion } from '../api/versions'
-import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
-import { checkLatest } from '../api/update'
-
-interface Options extends OptionsBase {
-  version: string
-  bundle: string
-  keep: number
-  force: boolean
-}
-
-const prompt = promptSync()
-
-async function removeVersions(toRemove: Database['public']['Tables']['app_versions']['Row'][], supabase: SupabaseClient<Database>, appid: string, userId: string) {
-  // call deleteSpecificVersion one by one from toRemove sync
-  for await (const row of toRemove) {
-    p.log.warn(`Removing ${row.name} created on ${(getHumanDate(row.created_at))}`)
-    await deleteSpecificVersion(supabase, appid, userId, row.name)
-  }
-}
-
-function getRemovableVersionsInSemverRange(data: Database['public']['Tables']['app_versions']['Row'][], bundle: string, nextMajor: string) {
-  const toRemove: Database['public']['Tables']['app_versions']['Row'][] = []
-
-  data?.forEach((row) => {
-    if (semver.gte(row.name, bundle) && semver.lt(row.name, `${nextMajor}`))
-      toRemove.push(row)
-  })
-  return toRemove
-}
-
-export async function cleanupBundle(appid: string, options: Options) {
-  p.intro(`Cleanup versions in Capgo`)
-  await checkLatest()
-  options.apikey = options.apikey || findSavedKey()
-  const { bundle, keep = 4 } = options
-  const force = options.force || false
-
-  const config = await getConfig()
-  appid = appid || config?.app?.appId
-  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 userId = await verifyUser(supabase, options.apikey, ['write', 'all'])
-
-  // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionOrgErr(supabase, options.apikey, appid, OrganizationPerm.write)
-  p.log.info(`Querying all available versions in Capgo`)
-
-  // Get all active app versions we might possibly be able to cleanup
-  let allVersions: (Database['public']['Tables']['app_versions']['Row'] & { keep?: string })[] = await getActiveAppVersions(supabase, appid, userId)
-
-  const versionInUse = await getChannelsVersion(supabase, appid)
-
-  p.log.info(`Total active versions in Capgo: ${allVersions?.length}`)
-  if (allVersions?.length === 0) {
-    p.log.error('No versions found, aborting cleanup')
-    return
-  }
-  if (bundle) {
-    const nextMajor = `${semver.inc(bundle, 'major')}`
-    p.log.info(`Querying available versions in Capgo between ${bundle} and ${nextMajor}`)
-
-    // Get all app versions that are in the given range
-    allVersions = getRemovableVersionsInSemverRange(allVersions, bundle, nextMajor) as (Database['public']['Tables']['app_versions']['Row'] & { keep: string })[]
-
-    p.log.info(`Active versions in Capgo between ${bundle} and ${nextMajor}: ${allVersions?.length}`)
-  }
-
-  // Slice to keep and remove
-
-  const toRemove: (Database['public']['Tables']['app_versions']['Row'] & { keep?: string })[] = []
-  // Slice to keep and remove
-  let kept = 0
-  allVersions.forEach((v) => {
-    const isInUse = versionInUse.find(vi => vi === v.id)
-    if (kept < keep || isInUse) {
-      if (isInUse)
-        v.keep = '✅ (Linked to channel)'
-      else
-        v.keep = '✅'
-
-      kept += 1
-    }
-    else {
-      v.keep = '❌'
-      toRemove.push(v)
-    }
-  })
-
-  if (toRemove.length === 0) {
-    p.log.warn('Nothing to be removed, aborting removal...')
-    return
-  }
-  displayBundles(allVersions)
-
-  // Check user wants to clean that all up
-  if (!force) {
-    const result = prompt('Do you want to continue removing the versions specified? Type yes to confirm: ')
-    if (result !== 'yes') {
-      p.log.warn('Not confirmed, aborting removal...')
-      return
-    }
-  }
-
-  // Yes, lets clean it up
-  p.log.success('You have confirmed removal, removing versions now')
-  await removeVersions(toRemove, supabase, appid, userId)
-  p.outro(`Done ✅`)
-  process.exit()
-}

package/src/bundle/compatibility.ts

@@ -1,70 +0,0 @@
-import * as p from '@clack/prompts'
-import { program } from 'commander'
-import { Table } from 'console-table-printer'
-import type { OptionsBase } from '../utils'
-import { OrganizationPerm, checkCompatibility, createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils'
-import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
-
-interface Options extends OptionsBase {
-  channel?: string
-  text?: boolean
-}
-
-export async function checkCompatibilityCommand(appId: string, options: Options) {
-  p.intro(`Check compatibility`)
-  options.apikey = options.apikey || findSavedKey()
-  const config = await getConfig()
-  appId = appId || config?.app?.appId
-
-  const { channel } = options
-
-  if (!channel) {
-    p.log.error('Missing argument, you need to provide a channel')
-    program.error('')
-  }
-
-  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)
-  await verifyUser(supabase, options.apikey, ['write', 'all', 'read', 'upload'])
-
-  // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionOrgErr(supabase, options.apikey, appId, OrganizationPerm.read)
-
-  // const hashedLocalDependencies = new Map(dependenciesObject
-  //     .filter((a) => !!a.native && a.native !== undefined)
-  //     .map((a) => [a.name, a]))
-
-  // const nativePackages = Array.from(hashedLocalDependencies, ([name, value]) => ({ name, version: value.version }))
-  // await supabase.from('app_versions').update({ native_packages: nativePackages }).eq('id', '9654')
-
-  const { finalCompatibility } = await checkCompatibility(supabase, appId, channel)
-
-  const t = new Table({
-    title: 'Compatibility',
-    charLength: { '❌': 2, '✅': 2 },
-  })
-
-  const yesSymbol = options.text ? 'Yes' : '✅'
-  const noSymbol = options.text ? 'No' : '❌'
-
-  finalCompatibility.forEach((data) => {
-    const { name, localVersion, remoteVersion } = data
-
-    t.addRow({
-      'Package': name,
-      'Local version': localVersion ?? 'None',
-      'Remote version': remoteVersion ?? 'None',
-      'Compatible': remoteVersion === localVersion ? yesSymbol : noSymbol,
-    })
-  })
-
-  p.log.success(t.render())
-}

package/src/bundle/decrypt.ts

@@ -1,65 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs'
-import process from 'node:process'
-import { program } from 'commander'
-import * as p from '@clack/prompts'
-import { decryptSource } from '../api/crypto'
-import { baseKeyPub, checKOldEncryption, getConfig } from '../utils'
-import { checkLatest } from '../api/update'
-
-interface Options {
-  key?: string
-  keyData?: string
-}
-
-export async function decryptZip(zipPath: string, ivsessionKey: string, options: Options) {
-  p.intro(`Decrypt zip file`)
-  await checkLatest()
-  // write in file .capgo the apikey in home directory
-
-  if (!existsSync(zipPath)) {
-    p.log.error(`Zip not found at the path ${zipPath}`)
-    program.error('')
-  }
-
-  const config = await getConfig()
-  const { extConfig } = config.app
-  // console.log('config - ', config)
-  // console.log('extConfig - ', extConfig)
-
-  await checKOldEncryption()
-  // console.log(`There ${hasPrivateKeyInConfig ? 'IS' : 'IS NOT'} a privateKey in the config`);
-
-  if (!options.key && !existsSync(baseKeyPub) && !extConfig.plugins?.CapacitorUpdater?.publicKey) {
-    p.log.error(`Public key not found at the path ${baseKeyPub} or in ${config.app.extConfigFilePath}`)
-    program.error('')
-  }
-  const keyPath = options.key || baseKeyPub
-  // check if private exist
-
-  let publicKey = extConfig?.plugins?.CapacitorUpdater?.publicKey
-
-  if (!existsSync(keyPath) && !publicKey) {
-    p.log.error(`Cannot find a public key at ${keyPath} or as keyData option or in ${config.app.extConfigFilePath}`)
-    program.error('')
-  }
-  else if (existsSync(keyPath)) {
-    // open with fs publicKey path
-    const keyFile = readFileSync(keyPath)
-    publicKey = keyFile.toString()
-  }
-
-  // let's doublecheck and make sure the key we are using is the right type based on the decryption strategy
-  if (publicKey && !publicKey.startsWith('-----BEGIN RSA PUBLIC KEY-----')) {
-    p.log.error(`the public key provided is not a valid RSA Public key`)
-    program.error('')
-  }
-
-  const zipFile = readFileSync(zipPath)
-
-  const decodedZip = decryptSource(zipFile, ivsessionKey, options.keyData ?? publicKey ?? '')
-  // write decodedZip in a file
-  writeFileSync(`${zipPath}_decrypted.zip`, decodedZip)
-  p.log.success(`Decrypted zip file at ${zipPath}_decrypted.zip`)
-  p.outro(`Done ✅`)
-  process.exit()
-}

package/src/bundle/delete.ts

@@ -1,53 +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, getConfig, verifyUser } from '../utils'
-import { deleteSpecificVersion } from '../api/versions'
-
-interface Options extends OptionsBase {
-  bundle: string
-}
-
-export async function deleteBundle(bundleId: string, appId: string, options: Options) {
-  p.intro(`Delete bundle`)
-  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('')
-  }
-  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.write)
-
-  appId = appId || config?.app?.appId
-  if (!options.apikey) {
-    p.log.error('Missing API key, you need to provide an API key to delete your app')
-    program.error('')
-  }
-  if (!bundleId) {
-    p.log.error('Missing argument, you need to provide a bundleId, or be in a capacitor project')
-    program.error('')
-  }
-  if (!appId) {
-    p.log.error('Missing argument, you need to provide a appId, or be in a capacitor project')
-    program.error('')
-  }
-
-  p.log.info(`Deleting bundle ${appId}@${bundleId} from Capgo`)
-
-  await deleteSpecificVersion(supabase, appId, userId, bundleId)
-  p.log.success(`Bundle ${appId}@${bundleId} deleted in Capgo`)
-  p.outro(`Done`)
-  process.exit()
-}

package/src/bundle/encrypt.ts

@@ -1,69 +0,0 @@
-import { existsSync, readFileSync, writeFileSync } from 'node:fs'
-import process from 'node:process'
-import { program } from 'commander'
-import ciDetect from 'ci-info'
-import * as p from '@clack/prompts'
-import { checkLatest } from '../api/update'
-import { encryptSource } from '../api/crypto'
-import { baseKey, checKOldEncryption, getLocalConfig } from '../utils'
-
-interface Options {
-  key?: string
-  keyData?: string
-}
-
-export async function encryptZip(zipPath: string, options: Options) {
-  p.intro(`Encryption`)
-
-  await checkLatest()
-  const localConfig = await getLocalConfig()
-  // console.log('localConfig - ', localConfig)
-  // console.log('config - ', config)
-
-  await checKOldEncryption()
-
-  if (!existsSync(zipPath)) {
-    p.log.error(`Error: Zip not found at the path ${zipPath}`)
-    program.error('')
-  }
-
-  const keyPath = options.key || baseKey
-  // check if privateKey exist
-
-  let privateKey = options.keyData || ''
-
-  if (!existsSync(keyPath) && !privateKey) {
-    p.log.warning(`Cannot find a private key at ${keyPath} or as a keyData option`)
-    if (ciDetect.isCI) {
-      p.log.error(`Error: Missing key`)
-      program.error('')
-    }
-    const res = await p.confirm({ message: `Do you want to use our private key?` })
-    if (!res) {
-      p.log.error(`Error: Missing private key`)
-      program.error('')
-    }
-
-    privateKey = localConfig.signKey || ''
-  }
-  else if (existsSync(keyPath)) {
-    // open with fs key path
-    const keyFile = readFileSync(keyPath)
-    privateKey = keyFile.toString()
-  }
-
-  // let's doublecheck and make sure the key we are using is the right type based on the decryption strategy
-  if (privateKey && !privateKey.startsWith('-----BEGIN RSA PRIVATE KEY-----')) {
-    p.log.error(`the private key provided is not a valid RSA Private key`)
-    program.error('')
-  }
-
-  const zipFile = readFileSync(zipPath)
-  const encodedZip = encryptSource(zipFile, privateKey)
-  p.log.success(`ivSessionKey: ${encodedZip.ivSessionKey}`)
-  // write decodedZip in a file
-  writeFileSync(`${zipPath}_encrypted.zip`, encodedZip.encryptedData)
-  p.log.success(`Encrypted zip saved at ${zipPath}_encrypted.zip`)
-  p.outro(`Done ✅`)
-  process.exit()
-}

package/src/bundle/list.ts

@@ -1,43 +0,0 @@
-import process from 'node:process'
-import { program } from 'commander'
-import * as p from '@clack/prompts'
-import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
-import { displayBundles, getActiveAppVersions } from '../api/versions'
-import type { OptionsBase } from '../utils'
-import { OrganizationPerm, createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils'
-import { checkLatest } from '../api/update'
-
-export async function listBundle(appId: string, options: OptionsBase) {
-  p.intro(`List bundles`)
-  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('')
-  }
-
-  const supabase = await createSupabaseClient(options.apikey)
-
-  const userId = await verifyUser(supabase, options.apikey, ['write', 'all', 'read', 'upload'])
-
-  p.log.info(`Querying available versions of: ${appId} in Capgo`)
-
-  // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionOrgErr(supabase, options.apikey, appId, OrganizationPerm.read)
-
-  // Get all active app versions we might possibly be able to cleanup
-  const allVersions = await getActiveAppVersions(supabase, appId, userId)
-
-  p.log.info(`Active versions in Capgo: ${allVersions?.length}`)
-
-  displayBundles(allVersions)
-  p.outro(`Done ✅`)
-  process.exit()
-}

package/src/bundle/unlink.ts

@@ -1,86 +0,0 @@
-import process from 'node:process'
-import { program } from 'commander'
-import * as p from '@clack/prompts'
-import { getVersionData } from '../api/versions'
-import { checkVersionNotUsedInDeviceOverride } from '../api/devices_override'
-import { checkVersionNotUsedInChannel } from '../api/channels'
-import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
-import type {
-  OptionsBase,
-} from '../utils'
-import {
-  OrganizationPerm,
-  checkPlanValid,
-  createSupabaseClient,
-  findSavedKey,
-  formatError,
-  getConfig,
-  getOrganizationId,
-  useLogSnag,
-  verifyUser,
-} from '../utils'
-
-interface Options extends OptionsBase {
-  bundle?: string
-}
-
-export async function unlinkDevice(channel: string, appId: string, options: Options) {
-  p.intro(`Unlink bundle ${options.apikey}`)
-  options.apikey = options.apikey || findSavedKey()
-  const config = await getConfig()
-  appId = appId || config?.app?.appId
-  const snag = useLogSnag()
-  let { bundle } = options
-
-  bundle = bundle || config?.app?.package?.version
-
-  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 (!bundle) {
-    p.log.error('Missing argument, you need to provide a bundle, or be in a capacitor project')
-    program.error('')
-  }
-  const supabase = await createSupabaseClient(options.apikey)
-
-  const [userId, orgId] = await Promise.all([
-    verifyUser(supabase, options.apikey, ['all', 'write']),
-    getOrganizationId(supabase, appId),
-  ])
-
-  // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionOrgErr(supabase, options.apikey, appId, OrganizationPerm.write)
-
-  if (!channel) {
-    p.log.error('Missing argument, you need to provide a channel')
-    program.error('')
-  }
-  try {
-    await checkPlanValid(supabase, orgId, options.apikey, appId)
-
-    const versionData = await getVersionData(supabase, appId, bundle)
-    await checkVersionNotUsedInChannel(supabase, appId, versionData)
-    await checkVersionNotUsedInDeviceOverride(supabase, appId, versionData)
-    await snag.track({
-      channel: 'bundle',
-      event: 'Unlink bundle',
-      icon: '✅',
-      user_id: userId,
-      tags: {
-        'app-id': appId,
-      },
-      notify: false,
-    }).catch()
-  }
-  catch (err) {
-    p.log.error(`Unknow error ${formatError(err)}`)
-    program.error('')
-  }
-  p.outro('Done ✅')
-  process.exit()
-}