@capgo/cli 5.0.0-alpha.7 → 5.0.0

package/src/app/add.ts

@@ -1,191 +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 { checkLatest } from '../api/update'
-import type { Options } from '../api/app'
-import { checkAppExists, newIconPath } from '../api/app'
-import {
-  checkPlanValid,
-  createSupabaseClient,
-  findSavedKey,
-  formatError,
-  getConfig,
-  useLogSnag,
-  verifyUser,
-} from '../utils'
-
-export async function addApp(appId: string, options: Options, throwErr = true) {
-  if (throwErr)
-    p.intro(`Adding`)
-
-  await checkLatest()
-  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('')
-  }
-
-  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)
-
-  let userId = await verifyUser(supabase, options.apikey, ['write', 'all'])
-
-  // Check we have app access to this appId
-  const appExist = await checkAppExists(supabase, appId)
-  if (throwErr && appExist) {
-    p.log.error(`App ${appId} already exist`)
-    program.error('')
-  }
-  else if (appExist) {
-    return true
-  }
-
-  const { error: orgError, data: allOrganizations } = await supabase
-    .rpc('get_orgs_v5')
-
-  if (orgError) {
-    p.log.error('Cannot get the list of organizations - exiting')
-    p.log.error(`Error ${JSON.stringify(orgError)}`)
-    program.error('')
-  }
-
-  const adminOrgs = allOrganizations.filter(org => org.role === 'admin' || org.role === 'super_admin')
-
-  const organizationUidRaw = (adminOrgs.length > 1)
-    ? await p.select({
-      message: 'Please pick the organization that you want to insert to',
-      options: adminOrgs.map((org) => {
-        return { value: org.gid, label: org.name }
-      }),
-    })
-    : adminOrgs[0].gid
-
-  if (p.isCancel(organizationUidRaw)) {
-    p.log.error('Canceled organization selection, exiting')
-    program.error('')
-  }
-
-  const organizationUid = organizationUidRaw as string
-  const organization = allOrganizations.find(org => org.gid === organizationUid)!
-  userId = organization.created_by
-
-  p.log.info(`Using the organization "${organization.name}" as the app owner`)
-
-  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_${randomUUID()}`
-  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/${userId}/${appId}`)
-      .upload(fileName, iconBuff, {
-        contentType: iconType,
-      })
-    if (error) {
-      p.log.error(`Could not add app ${formatError(error)}`)
-      program.error('')
-    }
-    const { data: signedURLData } = await supabase
-      .storage
-      .from(`images/${userId}/${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('')
-  }
-  await snag.track({
-    channel: 'app',
-    event: 'App Added',
-    icon: '🎉',
-    user_id: userId,
-    tags: {
-      'app-id': appId,
-    },
-    notify: false,
-  }).catch()
-  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,220 +0,0 @@
-import process from 'node:process'
-import * as p from '@clack/prompts'
-import type { SupabaseClient } from '@supabase/supabase-js'
-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, findSavedKey, formatError, getConfig, getLocalConfig, 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, userId: string, snag: LogSnag, event: string, icon = '✅') {
-  await snag.track({
-    channel,
-    event,
-    icon,
-    user_id: userId,
-    notify: false,
-  }).catch()
-}
-
-export async function cancelCommand(channel: string, command: boolean | symbol, userId: string, snag: LogSnag) {
-  if (p.isCancel(command)) {
-    await markSnag(channel, userId, snag, 'canceled', '🤷')
-    process.exit()
-  }
-}
-
-interface Order {
-  key: string
-  sortable?: 'asc' | 'desc'
-}
-
-interface QueryStats {
-  appId: string
-  devicesId?: string[]
-  search?: string
-  order?: Order[]
-  rangeStart?: number
-  rangeEnd?: number
-  after?: string
-}
-
-export async function getStats(supabase: SupabaseClient<Database>, query: QueryStats): Promise<Database['public']['Tables']['stats']['Row'] | null> {
-  try {
-    const pathStats = 'private/stats'
-    const res = await supabase.functions.invoke(pathStats, { body: JSON.stringify(query) })
-    const listData = res.data.data as Database['public']['Tables']['stats']['Row'][]
-    if (listData?.length > 0)
-      return listData[0]
-  }
-  catch (error) {
-    p.log.error(`Cannot get stats ${formatError(error)}`)
-  }
-  return null
-}
-
-export async function waitLog(channel: string, supabase: SupabaseClient<Database>, appId: string, snag: LogSnag, userId: string, deviceId?: string) {
-  let loop = true
-  let now = new Date().toISOString()
-  const appIdUrl = convertAppName(appId)
-  const config = await getLocalConfig()
-  const baseUrl = `${config.hostWeb}/app/p/${appIdUrl}`
-  await markSnag(channel, userId, snag, 'Use waitlog')
-  const query: QueryStats = {
-    appId,
-    devicesId: deviceId ? [deviceId] : undefined,
-    order: [{
-      key: 'created_at',
-      sortable: 'desc',
-    }],
-    rangeStart: 0,
-    rangeEnd: 1,
-    after: now,
-  }
-  while (loop) {
-    const data = await getStats(supabase, query)
-    //   console.log('data', data)
-    if (data) {
-      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, userId, 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, userId, 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 ❤️')
-        loop = false
-        await markSnag(channel, userId, snag, 'set')
-        return Promise.resolve(data)
-      }
-      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(`Your version in ${data.platform} is the same as your version uploaded, change it to see the update`)
-      }
-      else if (data.action === 'disablePlatformIos') {
-        p.log.error(`iOS is disabled  in the default channel and your device is an iOS device ${baseUrl}`)
-      }
-      else if (data.action === 'disablePlatformAndroid') {
-        p.log.error(`Android is disabled  in the default channel and your device is an Android device ${baseUrl}`)
-      }
-      else if (data.action === 'disableAutoUpdateToMajor') {
-        p.log.error('Auto update to major version is disabled in the default channel.')
-        p.log.error('Set your app to the same major version as the default channel')
-      }
-      else if (data.action === 'disableAutoUpdateUnderNative') {
-        p.log.error('Auto update under native version is disabled in the default channel.')
-        p.log.error('Set your app to the same native version as the default channel.')
-      }
-      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 you added  notifyAppReady in your code?')
-      }
-      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}`)
-      }
-      now = new Date().toISOString()
-      query.after = now
-    }
-    await wait(1000)
-  }
-  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 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, Put the app in background and open it again.`)
-    p.log.info('Waiting...')
-    await waitLog('debug', supabase, appId, snag, userId, 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,106 +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, 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 )`)
-    .eq('app_id', appId)
-    .single()
-
-  const appOwner = appOwnerRaw as { owner_org: { created_by: 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/${userId}`)
-    .remove([appId])
-  if (error)
-    p.log.error('Could not delete app logo')
-
-  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('')
-  }
-  await snag.track({
-    channel: 'app',
-    event: 'App Deleted',
-    icon: '🗑️',
-    user_id: userId,
-    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,87 +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 Spinnies from '@trufflesuite/spinnies'
-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/')) {
-      // 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 spinnies = new Spinnies()
-  spinnies.add('loading', { text: '  Loading latest dependencies' })
-  const latestDependencies = await getLatestDependencies(installedDependencies)
-  spinnies.succeed('loading', { text: '  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()
-}