@capgo/cli 5.0.0-alpha.3 → 5.0.0-alpha.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/cli",
-  "version": "5.0.0-alpha.3",
+  "version": "5.0.0-alpha.7",
   "description": "A CLI to upload to capgo servers",
   "main": "dist/index.js",
   "bin": {
@@ -43,6 +43,7 @@
   "author": "github.com/riderx",
   "license": "Apache 2.0",
   "dependencies": {
+    "@aws-sdk/client-s3": "^3.540.0",
     "@capacitor/cli": "5.7.0",
     "@capgo/find-package-manager": "0.0.10",
     "@clack/prompts": "^0.7.0",

package/src/api/channels.ts

@@ -6,12 +6,11 @@ import * as p from '@clack/prompts'
 import type { Database } from '../types/supabase.types'
 import { formatError } from '../utils'
 
-export async function checkVersionNotUsedInChannel(supabase: SupabaseClient<Database>, appid: string, userId: string, versionData: Database['public']['Tables']['app_versions']['Row']) {
+export async function checkVersionNotUsedInChannel(supabase: SupabaseClient<Database>, appid: string, versionData: Database['public']['Tables']['app_versions']['Row']) {
   const { data: channelFound, error: errorChannel } = await supabase
     .from('channels')
     .select()
     .eq('app_id', appid)
-    .eq('created_by', userId)
     .eq('version', versionData.id)
   if (errorChannel) {
     p.log.error(`Cannot check Version ${appid}@${versionData.name}`)
@@ -63,13 +62,12 @@ export function createChannel(supabase: SupabaseClient<Database>, update: Databa
     .single()
 }
 
-export function delChannel(supabase: SupabaseClient<Database>, name: string, appId: string, userId: string) {
+export function delChannel(supabase: SupabaseClient<Database>, name: string, appId: string, _userId: string) {
   return supabase
     .from('channels')
     .delete()
     .eq('name', name)
     .eq('app_id', appId)
-    .eq('created_by', userId)
     .single()
 }
 interface version {

package/src/api/versions.ts

@@ -9,7 +9,7 @@ import { getHumanDate } from '../utils'
 import { checkVersionNotUsedInChannel } from './channels'
 import { checkVersionNotUsedInDeviceOverride } from './devices_override'
 
-export async function deleteAppVersion(supabase: SupabaseClient<Database>, appid: string, userId: string, bundle: string) {
+export async function deleteAppVersion(supabase: SupabaseClient<Database>, appid: string, bundle: string) {
   const { error: delAppSpecVersionError } = await supabase
     .from('app_versions')
     .update({
@@ -17,7 +17,6 @@ export async function deleteAppVersion(supabase: SupabaseClient<Database>, appid
     })
     .eq('app_id', appid)
     .eq('deleted', false)
-    .eq('user_id', userId)
     .eq('name', bundle)
   if (delAppSpecVersionError) {
     p.log.error(`App Version ${appid}@${bundle} not found in database`)
@@ -25,15 +24,20 @@ export async function deleteAppVersion(supabase: SupabaseClient<Database>, appid
   }
 }
 
-export async function deleteSpecificVersion(supabase: SupabaseClient<Database>, appid: string, userId: string, bundle: string) {
-  const versionData = await getVersionData(supabase, appid, userId, bundle)
-  await checkVersionNotUsedInChannel(supabase, appid, userId, versionData)
+export async function deleteSpecificVersion(supabase: SupabaseClient<Database>, appid: string, _userId: string, bundle: string) {
+  const versionData = await getVersionData(supabase, appid, bundle)
+  await checkVersionNotUsedInChannel(supabase, appid, versionData)
   await checkVersionNotUsedInDeviceOverride(supabase, appid, versionData)
   // Delete only a specific version in storage
-  await deleteAppVersion(supabase, appid, userId, bundle)
+  await deleteAppVersion(supabase, appid, bundle)
 }
 
 export function displayBundles(data: (Database['public']['Tables']['app_versions']['Row'] & { keep?: string })[]) {
+  if (!data.length) {
+    p.log.error('No bundle found')
+    // eslint-disable-next-line node/prefer-global/process
+    process.exit(1)
+  }
   const t = new Table({
     title: 'Bundles',
     charLength: { '❌': 2, '✅': 2 },
@@ -51,12 +55,12 @@ export function displayBundles(data: (Database['public']['Tables']['app_versions
   p.log.success(t.render())
 }
 
-export async function getActiveAppVersions(supabase: SupabaseClient<Database>, appid: string, userId: string) {
+export async function getActiveAppVersions(supabase: SupabaseClient<Database>, appid: string, _userId: string) {
   const { data, error: vError } = await supabase
     .from('app_versions')
     .select()
     .eq('app_id', appid)
-    .eq('user_id', userId)
+    // .eq('user_id', userId)
     .eq('deleted', false)
     .order('created_at', { ascending: false })
 
@@ -68,7 +72,7 @@ export async function getActiveAppVersions(supabase: SupabaseClient<Database>, a
 }
 
 export async function getChannelsVersion(supabase: SupabaseClient<Database>, appid: string) {
-// get all channels versionID
+  // get all channels versionID
   const { data: channels, error: channelsError } = await supabase
     .from('channels')
     .select('version')
@@ -81,12 +85,11 @@ export async function getChannelsVersion(supabase: SupabaseClient<Database>, app
   return channels.map(c => c.version)
 }
 
-export async function getVersionData(supabase: SupabaseClient<Database>, appid: string, userId: string, bundle: string) {
+export async function getVersionData(supabase: SupabaseClient<Database>, appid: string, bundle: string) {
   const { data: versionData, error: versionIdError } = await supabase
     .from('app_versions')
     .select()
     .eq('app_id', appid)
-    .eq('user_id', userId)
     .eq('name', bundle)
     .eq('deleted', false)
     .single()

package/src/app/add.ts

@@ -35,11 +35,15 @@ export async function addApp(appId: string, options: Options, throwErr = true) {
     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'])
+  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 checkPlanValid(supabase, userId, options.apikey, undefined, false)
+  let userId = await verifyUser(supabase, options.apikey, ['write', 'all'])
 
   // Check we have app access to this appId
   const appExist = await checkAppExists(supabase, appId)
@@ -51,6 +55,39 @@ export async function addApp(appId: string, options: Options, throwErr = true) {
     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'
@@ -106,7 +143,7 @@ export async function addApp(appId: string, options: Options, throwErr = true) {
     .from('apps')
     .insert({
       icon_url: signedURL,
-      user_id: userId,
+      owner_org: organizationUid,
       name,
       app_id: appId,
     })
@@ -117,12 +154,12 @@ export async function addApp(appId: string, options: Options, throwErr = true) {
   const { error: dbVersionError } = await supabase
     .from('app_versions')
     .insert([{
-      user_id: userId,
+      owner_org: organizationUid,
       deleted: true,
       name: 'unknown',
       app_id: appId,
     }, {
-      user_id: userId,
+      owner_org: organizationUid,
       deleted: true,
       name: 'builtin',
       app_id: appId,

package/src/app/debug.ts

@@ -4,9 +4,15 @@ import type { SupabaseClient } from '@supabase/supabase-js'
 import { program } from 'commander'
 import type LogSnag from 'logsnag'
 import type { Database } from '../types/supabase.types'
-import { checkAppExistsAndHasPermissionErr } from '../api/app'
+import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
 import { checkLatest } from '../api/update'
-import { convertAppName, createSupabaseClient, findSavedKey, formatError, getConfig, getLocalConfig, useLogSnag, verifyUser, wait } from '../utils'
+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
@@ -194,7 +200,7 @@ export async function debugApp(appId: string, options: OptionsBaseDebug) {
   p.log.info(`Getting active bundle in Capgo`)
 
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, 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)

package/src/app/delete.ts

@@ -1,9 +1,9 @@
 import process from 'node:process'
 import { program } from 'commander'
 import * as p from '@clack/prompts'
-import { checkAppExistsAndHasPermissionErr } from '../api/app'
+import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
 import type { OptionsBase } from '../utils'
-import { createSupabaseClient, findSavedKey, getConfig, useLogSnag, verifyUser } from '../utils'
+import { OrganizationPerm, createSupabaseClient, findSavedKey, formatError, getConfig, useLogSnag, verifyUser } from '../utils'
 
 export async function deleteApp(appId: string, options: OptionsBase) {
   p.intro(`Deleting`)
@@ -24,7 +24,45 @@ export async function deleteApp(appId: string, options: OptionsBase) {
 
   const userId = await verifyUser(supabase, options.apikey, ['write', 'all'])
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, 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
@@ -37,10 +75,10 @@ export async function deleteApp(appId: string, options: OptionsBase) {
     .storage
     .from(`apps/${appId}/${userId}`)
     .remove(['versions'])
-  if (delError) {
+  if (delError)
     p.log.error('Could not delete app version')
-    program.error('')
-  }
+  // We should not care too much, most is in r2 anyways :/
+  // program.error('')
 
   const { error: dbError } = await supabase
     .from('apps')

package/src/app/list.ts

@@ -9,6 +9,10 @@ import { createSupabaseClient, findSavedKey, getHumanDate, verifyUser } from '..
 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 },

package/src/app/set.ts

@@ -5,8 +5,8 @@ import mime from 'mime'
 import { program } from 'commander'
 import * as p from '@clack/prompts'
 import type { Options } from '../api/app'
-import { checkAppExistsAndHasPermissionErr, newIconPath } from '../api/app'
-import { createSupabaseClient, findSavedKey, formatError, getConfig, verifyUser } from '../utils'
+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`)
@@ -26,11 +26,11 @@ export async function setApp(appId: string, options: Options) {
 
   const userId = await verifyUser(supabase, options.apikey, ['write', 'all'])
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId)
+  await checkAppExistsAndHasPermissionOrgErr(supabase, options.apikey, appId, OrganizationPerm.admin)
 
   const { name, icon, retention } = options
 
-  if (retention && !Number.isNaN(Number(retention))) {
+  if (retention && Number.isNaN(Number(retention))) {
     p.log.error(`retention value must be a number`)
     program.error(``)
   }

package/src/bundle/cleanup.ts

@@ -6,9 +6,9 @@ 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 { createSupabaseClient, findSavedKey, getConfig, getHumanDate, verifyUser } from '../utils'
+import { OrganizationPerm, createSupabaseClient, findSavedKey, getConfig, getHumanDate, verifyUser } from '../utils'
 import { deleteSpecificVersion, displayBundles, getActiveAppVersions, getChannelsVersion } from '../api/versions'
-import { checkAppExistsAndHasPermissionErr } from '../api/app'
+import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
 import { checkLatest } from '../api/update'
 
 interface Options extends OptionsBase {
@@ -57,15 +57,14 @@ export async function cleanupBundle(appid: string, options: Options) {
   }
   const supabase = await createSupabaseClient(options.apikey)
 
-  const userId = await verifyUser(supabase, options.apikey)
+  const userId = await verifyUser(supabase, options.apikey, ['write', 'all'])
 
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, 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)
+  let allVersions: (Database['public']['Tables']['app_versions']['Row'] & { keep?: string })[] = await getActiveAppVersions(supabase, appid, userId)
 
   const versionInUse = await getChannelsVersion(supabase, appid)
 

package/src/bundle/compatibility.ts

@@ -2,8 +2,8 @@ import * as p from '@clack/prompts'
 import { program } from 'commander'
 import { Table } from 'console-table-printer'
 import type { OptionsBase } from '../utils'
-import { checkCompatibility, createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils'
-import { checkAppExistsAndHasPermissionErr } from '../api/app'
+import { OrganizationPerm, checkCompatibility, createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils'
+import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
 
 interface Options extends OptionsBase {
   channel?: string
@@ -36,7 +36,7 @@ export async function checkCompatibilityCommand(appId: string, options: Options)
   await verifyUser(supabase, options.apikey, ['write', 'all', 'read', 'upload'])
 
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId)
+  await checkAppExistsAndHasPermissionOrgErr(supabase, options.apikey, appId, OrganizationPerm.read)
 
   // const hashedLocalDependencies = new Map(dependenciesObject
   //     .filter((a) => !!a.native && a.native !== undefined)

package/src/bundle/delete.ts

@@ -1,9 +1,9 @@
 import process from 'node:process'
 import { program } from 'commander'
 import * as p from '@clack/prompts'
-import { checkAppExistsAndHasPermissionErr } from '../api/app'
+import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
 import type { OptionsBase } from '../utils'
-import { createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils'
+import { OrganizationPerm, createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils'
 import { deleteSpecificVersion } from '../api/versions'
 
 interface Options extends OptionsBase {
@@ -28,7 +28,7 @@ export async function deleteBundle(bundleId: string, appId: string, options: Opt
 
   const userId = await verifyUser(supabase, options.apikey, ['write', 'all'])
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId)
+  await checkAppExistsAndHasPermissionOrgErr(supabase, options.apikey, appId, OrganizationPerm.write)
 
   appId = appId || config?.app?.appId
   if (!options.apikey) {

package/src/bundle/list.ts

@@ -1,10 +1,10 @@
 import process from 'node:process'
 import { program } from 'commander'
 import * as p from '@clack/prompts'
-import { checkAppExistsAndHasPermissionErr } from '../api/app'
+import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
 import { displayBundles, getActiveAppVersions } from '../api/versions'
 import type { OptionsBase } from '../utils'
-import { createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils'
+import { OrganizationPerm, createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils'
 import { checkLatest } from '../api/update'
 
 export async function listBundle(appId: string, options: OptionsBase) {
@@ -30,7 +30,7 @@ export async function listBundle(appId: string, options: OptionsBase) {
   p.log.info(`Querying available versions of: ${appId} in Capgo`)
 
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, 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)

package/src/bundle/unlink.ts

@@ -4,16 +4,18 @@ import * as p from '@clack/prompts'
 import { getVersionData } from '../api/versions'
 import { checkVersionNotUsedInDeviceOverride } from '../api/devices_override'
 import { checkVersionNotUsedInChannel } from '../api/channels'
-import { checkAppExistsAndHasPermissionErr } from '../api/app'
+import { checkAppExistsAndHasPermissionOrgErr } from '../api/app'
 import type {
   OptionsBase,
 } from '../utils'
 import {
+  OrganizationPerm,
   checkPlanValid,
   createSupabaseClient,
   findSavedKey,
   formatError,
   getConfig,
+  getOrganizationId,
   useLogSnag,
   verifyUser,
 } from '../utils'
@@ -23,7 +25,7 @@ interface Options extends OptionsBase {
 }
 
 export async function unlinkDevice(channel: string, appId: string, options: Options) {
-  p.intro(`Unlink bundle`)
+  p.intro(`Unlink bundle ${options.apikey}`)
   options.apikey = options.apikey || findSavedKey()
   const config = await getConfig()
   appId = appId || config?.app?.appId
@@ -46,19 +48,23 @@ export async function unlinkDevice(channel: string, appId: string, options: Opti
   }
   const supabase = await createSupabaseClient(options.apikey)
 
-  const userId = await verifyUser(supabase, options.apikey, ['write', 'all'])
+  const [userId, orgId] = await Promise.all([
+    verifyUser(supabase, options.apikey, ['all', 'write']),
+    getOrganizationId(supabase, appId),
+  ])
+
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, 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, userId, options.apikey, appId)
+    await checkPlanValid(supabase, orgId, options.apikey, appId)
 
-    const versionData = await getVersionData(supabase, appId, userId, bundle)
-    await checkVersionNotUsedInChannel(supabase, appId, userId, versionData)
+    const versionData = await getVersionData(supabase, appId, bundle)
+    await checkVersionNotUsedInChannel(supabase, appId, versionData)
     await checkVersionNotUsedInDeviceOverride(supabase, appId, versionData)
     await snag.track({
       channel: 'bundle',