@capgo/cli 3.14.21 → 3.14.22

package/src/api/app.ts

@@ -1,21 +1,32 @@
 import { SupabaseClient } from '@supabase/supabase-js';
+import * as p from '@clack/prompts';
 import { program } from 'commander';
 import { Database } from 'types/supabase.types';
-import { OptionsBase } from './utils';
+import { isAllowedApp, OptionsBase } from '../utils';
 
-export const checkAppExistsAndHasPermission = async (supabase: SupabaseClient<Database>, appid: string,
-  shouldExist = true) => {
-  const { data: app, error: dbError0 } = await supabase
+export const checkAppExists = async (supabase: SupabaseClient<Database>, appid: string) => {
+  const { data: app } = await supabase
     .rpc('exist_app_v2', { appid })
     .single();
-  return app !== shouldExist || dbError0;
+  return !!app;
 }
 
-export const checkAppExistsAndHasPermissionErr = async (supabase: SupabaseClient<Database>, appid: string,
+export const checkAppExistsAndHasPermissionErr = async (supabase: SupabaseClient<Database>, apikey: string, appid: string,
   shouldExist = true) => {
-  const res = await checkAppExistsAndHasPermission(supabase, appid, shouldExist);
-  if (res) {
-    program.error(`App ${appid} does not exist or you don't have permission to access it`);
+  const res = await checkAppExists(supabase, appid);
+  const perm = await isAllowedApp(supabase, apikey, appid);
+
+  if (res && !shouldExist) {
+    p.log.error(`App ${appid} already exist`);
+    program.error('');
+  }
+  if (!res && shouldExist) {
+    p.log.error(`App ${appid} does not exist`);
+    program.error('');
+  }
+  if (res && !perm) {
+    p.log.error(`App ${appid} exist and you don't have permission to access it`);
+    program.error('');
   }
 }
 

package/src/api/channels.ts

@@ -13,8 +13,10 @@ export const checkVersionNotUsedInChannel = async (supabase: SupabaseClient<Data
     .eq('app_id', appid)
     .eq('created_by', userId)
     .eq('version', versionData.id)
-  if (errorChannel)
-    program.error(`Cannot check Version ${appid}@${versionData.name} ${formatError(errorChannel)}`);
+  if (errorChannel) {
+    p.log.error(`Cannot check Version ${appid}@${versionData.name}`);
+    program.error('');
+  }
   if (channelFound && channelFound.length > 0) {
     p.intro(`❌ Version ${appid}@${versionData.name} is used in ${channelFound.length} channel`)
     if (await p.confirm({ message: 'unlink it?' })) {
@@ -36,7 +38,8 @@ export const checkVersionNotUsedInChannel = async (supabase: SupabaseClient<Data
       }
     }
     else {
-      program.error(`unlink it first`);
+      p.log.error(`Unlink it first`);
+      program.error('');
     }
     p.outro(`Version unlinked from ${channelFound.length} channel`)
   }
@@ -93,7 +96,8 @@ export const getActiveChannels = async (supabase: SupabaseClient<Database>, appi
     .order('created_at', { ascending: false });
 
   if (vError) {
-    program.error(`App ${appid} not found in database ${formatError(vError)} `);
+    p.log.error(`App ${appid} not found in database`);
+    program.error('');
   }
   return data;
-}
+}

package/src/api/devices_override.ts

@@ -12,8 +12,10 @@ export const checkVersionNotUsedInDeviceOverride = async (supabase: SupabaseClie
     .select()
     .eq('app_id', appid)
     .eq('version', versionData.id)
-  if (errorDevice)
-    program.error(`Cannot check Device override ${appid}@${versionData.name} ${formatError(errorDevice)}`);
+  if (errorDevice) {
+    p.log.error(`Cannot check Device override ${appid}@${versionData.name}`);
+    program.error('');
+  }
   if (deviceFound && deviceFound.length > 0) {
     p.intro(`❌ Version ${appid}@${versionData.name} is used in ${deviceFound.length} device override`)
     if (await p.confirm({ message: 'unlink it?' })) {
@@ -33,7 +35,8 @@ export const checkVersionNotUsedInDeviceOverride = async (supabase: SupabaseClie
       }
     }
     else {
-      program.error(`unlink it first`);
+      p.log.error(`Unlink it first`);
+      program.error('');
     }
   }
-}
+}

package/src/api/versions.ts

@@ -7,7 +7,6 @@ import { Database } from 'types/supabase.types';
 import { formatError, getHumanDate } from '../utils';
 import { checkVersionNotUsedInChannel } from './channels';
 import { checkVersionNotUsedInDeviceOverride } from './devices_override';
-import { deleteFromStorage } from './storage';
 
 export const deleteAppVersion = async (supabase: SupabaseClient<Database>, appid: string, userId: string, bundle: string) => {
   const { error: delAppSpecVersionError } = await supabase
@@ -20,7 +19,8 @@ export const deleteAppVersion = async (supabase: SupabaseClient<Database>, appid
     .eq('user_id', userId)
     .eq('name', bundle);
   if (delAppSpecVersionError) {
-    program.error(`App Version ${appid}@${bundle} not found in database '${formatError(delAppSpecVersionError)}'`);
+    p.log.error(`App Version ${appid}@${bundle} not found in database`);
+    program.error('');
   }
 }
 
@@ -29,8 +29,6 @@ export const deleteSpecificVersion = async (supabase: SupabaseClient<Database>,
   await checkVersionNotUsedInChannel(supabase, appid, userId, versionData);
   await checkVersionNotUsedInDeviceOverride(supabase, appid, versionData);
   // Delete only a specific version in storage
-  await deleteFromStorage(supabase, userId, appid, versionData, bundle);
-
   await deleteAppVersion(supabase, appid, userId, bundle);
 }
 
@@ -62,7 +60,8 @@ export const getActiveAppVersions = async (supabase: SupabaseClient<Database>, a
     .order('created_at', { ascending: false });
 
   if (vError) {
-    program.error(`App ${appid} not found in database ${formatError(vError)} `);
+    p.log.error(`App ${appid} not found in database`);
+    program.error('');
   }
   return data;
 }
@@ -75,7 +74,8 @@ export const getChannelsVersion = async (supabase: SupabaseClient<Database>, app
     .eq('app_id', appid)
   
   if (channelsError) {
-    program.error(`App ${appid} not found in database ${formatError(channelsError)} `);
+    p.log.error(`App ${appid} not found in database`);
+    program.error('');
   }
   return channels.map(c => c.version);
 }
@@ -90,7 +90,8 @@ export const getVersionData = async (supabase: SupabaseClient<Database>, appid:
     .eq('deleted', false)
     .single();
   if (!versionData || versionIdError) {
-    program.error(`App Version ${appid}@${bundle} doesn't exist ${formatError(versionIdError)}`);
+    p.log.error(`App Version ${appid}@${bundle} doesn't exist`);
+    program.error('');
   }
   return versionData;
 }

package/src/app/add.ts

@@ -4,14 +4,14 @@ import { program } from 'commander';
 import * as p from '@clack/prompts';
 import { existsSync, readFileSync } from 'fs-extra';
 import { checkLatest } from '../api/update';
-import { checkAppExistsAndHasPermissionErr, checkAppExistsAndHasPermission, newIconPath, Options } from '../api/app';
+import { newIconPath, Options, checkAppExists } from '../api/app';
 import {
   getConfig, createSupabaseClient,
   findSavedKey, useLogSnag, verifyUser, formatError
 } from '../utils';
 
-export const addApp = async (appId: string, options: Options, shouldExit = true) => {
-  if (shouldExit) {
+export const addApp = async (appId: string, options: Options, throwErr = true) => {
+  if (throwErr) {
     p.intro(`Adding`);
   }
   await checkLatest();
@@ -32,13 +32,12 @@ export const addApp = async (appId: string, options: Options, shouldExit = true)
 
   const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
   // Check we have app access to this appId
-  if (shouldExit) {
-    await checkAppExistsAndHasPermissionErr(supabase, appId, false);
-  } else {
-    const res = await checkAppExistsAndHasPermission(supabase, appId, false);
-    if (res) {
-      return false
-    }
+  const appExist = await checkAppExists(supabase, appId);
+  if (throwErr && appExist) {
+    p.log.error(`App ${appId} already exist`);
+    program.error('');
+  } else if (appExist) {
+    return true
   }
 
   let { name, icon } = options;
@@ -49,7 +48,7 @@ export const addApp = async (appId: string, options: Options, shouldExit = true)
     p.log.error("Missing argument, you need to provide a appId and a name, or be in a capacitor project");
     program.error('');
   }
-  if (shouldExit) {
+  if (throwErr) {
     p.log.info(`Adding ${appId} to Capgo`);
   }
   let iconBuff;
@@ -130,8 +129,8 @@ export const addApp = async (appId: string, options: Options, shouldExit = true)
     },
     notify: false,
   }).catch()
-  p.log.success(`App ${appId} added to Capgo. ${shouldExit ? 'You can upload a bundle now' : ''}`);
-  if (shouldExit) {
+  p.log.success(`App ${appId} added to Capgo. ${throwErr ? 'You can upload a bundle now' : ''}`);
+  if (throwErr) {
     p.outro(`Done ✅`);
     process.exit()
   }

package/src/app/debug.ts

@@ -164,7 +164,7 @@ export const debugApp = async (appId: string, options: OptionsBaseDebug) => {
   p.log.info(`Getting active bundle in Capgo`);
 
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, appId);
+  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId);
 
   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,8 +1,7 @@
 import { program } from "commander";
 import * as p from '@clack/prompts';
-import { OptionsBase } from "../api/utils";
 import { checkAppExistsAndHasPermissionErr } from '../api/app';
-import { createSupabaseClient, findSavedKey, formatError, getConfig, useLogSnag, verifyUser } from "../utils";
+import { createSupabaseClient, findSavedKey, formatError, getConfig, useLogSnag, verifyUser, OptionsBase } from "../utils";
 
 export const deleteApp = async (appId: string, options: OptionsBase) => {
     p.intro(`Deleting`);
@@ -12,30 +11,33 @@ export const deleteApp = async (appId: string, options: OptionsBase) => {
     const snag = useLogSnag()
 
     if (!options.apikey) {
-        program.error("Missing API key, you need to provide a API key to upload your bundle");
+        p.log.error('Missing API key, you need to provide a API key to upload your bundle');
+        program.error('');
     }
     if (!appId) {
-        program.error("Missing argument, you need to provide a appId, or be in a capacitor project");
+        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 checkAppExistsAndHasPermissionErr(supabase, appId);
+    await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId);
 
     const { error } = await supabase
         .storage
         .from(`images/${userId}`)
         .remove([appId])
     if (error) {
-        program.error(`Could not add app ${formatError(error)}`);
+        p.log.error('Could not delete app logo');
     }
     const { error: delError } = await supabase
         .storage
         .from(`apps/${appId}/${userId}`)
         .remove(['versions'])
     if (delError) {
-        program.error(`Could not delete app version ${formatError(delError)}`);
+        p.log.error('Could not delete app version');
+        program.error('');
     }
 
     const { error: dbError } = await supabase
@@ -45,7 +47,8 @@ export const deleteApp = async (appId: string, options: OptionsBase) => {
         .eq('user_id', userId)
 
     if (dbError) {
-        program.error(`Could not delete app ${formatError(dbError)}`);
+        p.log.error('Could not delete app');
+        program.error('');
     }
     await snag.track({
         channel: 'app',

package/src/app/list.ts

@@ -3,8 +3,7 @@ import { Table } from 'console-table-printer';
 import { SupabaseClient } from '@supabase/supabase-js';
 import * as p from '@clack/prompts';
 import { Database } from 'types/supabase.types';
-import { OptionsBase } from '../api/utils';
-import { createSupabaseClient, findSavedKey, formatError, getHumanDate, verifyUser } from '../utils';
+import { OptionsBase, createSupabaseClient, findSavedKey, formatError, getHumanDate, verifyUser } from '../utils';
 import { checkLatest } from '../api/update';
 
 const displayApp = (data: Database['public']['Tables']['apps']['Row'][]) => {
@@ -32,7 +31,8 @@ export const getActiveApps = async (supabase: SupabaseClient<Database>, userId:
     .order('created_at', { ascending: false });
 
   if (vError) {
-    program.error(`Apps not found in database ${formatError(vError)} `);
+    p.log.error('Apps not found');
+    program.error('');
   }
   return data;
 }

package/src/app/set.ts

@@ -24,7 +24,7 @@ export const setApp = async (appId: string, options: Options) => {
 
     const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
     // Check we have app access to this appId
-    await checkAppExistsAndHasPermissionErr(supabase, appId);
+    await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId);
 
     const { name, icon, retention } = options;
 

package/src/bundle/cleanup.ts

@@ -4,8 +4,7 @@ import * as p from '@clack/prompts';
 import promptSync from 'prompt-sync';
 import { SupabaseClient } from '@supabase/supabase-js';
 import { Database } from 'types/supabase.types';
-import { OptionsBase } from '../api/utils';
-import { createSupabaseClient, findSavedKey, getConfig, getHumanDate, verifyUser } from '../utils';
+import { OptionsBase, createSupabaseClient, findSavedKey, getConfig, getHumanDate, verifyUser } from '../utils';
 import { deleteSpecificVersion, displayBundles, getActiveAppVersions, getChannelsVersion } from '../api/versions';
 import { checkAppExistsAndHasPermissionErr } from '../api/app';
 import { checkLatest } from '../api/update';
@@ -52,17 +51,19 @@ export const cleanupBundle = async (appid: string, options: Options) => {
   const config = await getConfig();
   appid = appid || config?.app?.appId
   if (!apikey) {
-    program.error('Missing API key, you need to provide an API key to delete your app');
+    p.log.error('Missing API key, you need to provide an API key to delete your app');
+    program.error('');
   }
   if (!appid) {
-    program.error('Missing argument, you need to provide a appid, or be in a capacitor project');
+    p.log.error('Missing argument, you need to provide a appid, or be in a capacitor project');
+    program.error('');
   }
   const supabase = await createSupabaseClient(apikey)
 
   const userId = await verifyUser(supabase, apikey);
 
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, appid);
+  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appid);
   p.log.info(`Querying all available versions in Capgo`);
 
   // Get all active app versions we might possibly be able to cleanup

package/src/bundle/decrypt.ts

@@ -16,14 +16,16 @@ export const decryptZip = async (zipPath: string, ivsessionKey: string, options:
   // write in file .capgo the apikey in home directory
 
   if (!existsSync(zipPath)) {
-    program.error(`Zip not found at the path ${zipPath}`);
+    p.log.error(`Zip not found at the path ${zipPath}`);
+    program.error('');
   }
 
   const config = await getConfig();
   const { extConfig } = config.app;
 
   if (!options.key && !existsSync(baseKey) && !extConfig.plugins?.CapacitorUpdater?.privateKey) {
-    program.error(`Private Key not found at the path ${baseKey} or in ${config.app.extConfigFilePath}`);
+    p.log.error(`Private Key not found at the path ${baseKey} or in ${config.app.extConfigFilePath}`);
+    program.error('');
   }
   const keyPath = options.key || baseKey
   // check if publicKey exist
@@ -31,7 +33,8 @@ export const decryptZip = async (zipPath: string, ivsessionKey: string, options:
   let privateKey = extConfig?.plugins?.CapacitorUpdater?.privateKey
 
   if (!existsSync(keyPath) && !privateKey) {
-    program.error(`Cannot find public key ${keyPath} or as keyData option or in ${config.app.extConfigFilePath}`)
+    p.log.error(`Cannot find public key ${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)

package/src/bundle/delete.ts

@@ -1,8 +1,7 @@
 import { program } from 'commander';
 import * as p from '@clack/prompts';
 import { checkAppExistsAndHasPermissionErr } from '../api/app';
-import { OptionsBase } from '../api/utils';
-import { createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils';
+import { OptionsBase, createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils';
 import { deleteSpecificVersion } from '../api/versions';
 
 interface Options extends OptionsBase {
@@ -27,7 +26,7 @@ export const deleteBundle = async (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, appId);
+  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId);
 
   const apikey = options.apikey || findSavedKey()
 

package/src/bundle/list.ts

@@ -1,9 +1,8 @@
 import { program } from 'commander';
 import * as p from '@clack/prompts';
 import { checkAppExistsAndHasPermissionErr } from '../api/app';
-import { OptionsBase } from '../api/utils';
 import { getActiveAppVersions, displayBundles } from '../api/versions';
-import { createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils';
+import { OptionsBase, createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils';
 import { checkLatest } from '../api/update';
 
 export const listBundle = async (appId: string, options: OptionsBase) => {
@@ -29,7 +28,7 @@ export const listBundle = async (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, appId);
+    await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId);
 
     // Get all active app versions we might possibly be able to cleanup
     const allVersions = await getActiveAppVersions(supabase, appId, userId);

package/src/bundle/unlink.ts

@@ -3,9 +3,9 @@ import * as p from '@clack/prompts';
 import { getVersionData } from 'api/versions';
 import { checkVersionNotUsedInDeviceOverride } from '../api/devices_override';
 import { checkVersionNotUsedInChannel } from '../api/channels';
-import { OptionsBase } from '../api/utils';
 import { checkAppExistsAndHasPermissionErr } from "../api/app";
 import {
+    OptionsBase, 
     getConfig, createSupabaseClient,
     formatError, findSavedKey, checkPlanValid, useLogSnag, verifyUser
 } from '../utils';
@@ -40,7 +40,7 @@ export const unlinkDevice = async (channel: string, appId: string, options: Opti
 
     const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
     // Check we have app access to this appId
-    await checkAppExistsAndHasPermissionErr(supabase, appId);
+    await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId);
 
     if (!channel) {
         p.log.error("Missing argument, you need to provide a channel");

package/src/bundle/upload.ts

@@ -7,10 +7,10 @@ import { checksum as getChecksum } from '@tomasklaen/checksum';
 import ciDetect from 'ci-info';
 import axios from "axios";
 import { checkLatest } from '../api/update';
-import { OptionsBase } from '../api/utils';
 import { checkAppExistsAndHasPermissionErr } from "../api/app";
 import { encryptSource } from '../api/crypto';
 import {
+  OptionsBase,
   getConfig, createSupabaseClient,
   uploadUrl,
   updateOrCreateChannel, updateOrCreateVersion,
@@ -95,7 +95,7 @@ export const uploadBundle = async (appid: string, options: Options, shouldExit =
   const userId = await verifyUser(supabase, apikey, ['write', 'all', 'upload']);
   await checkPlanValid(supabase, userId, false)
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, appid);
+  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appid);
 
   const updateMetadataRequired = await requireUpdateMetadata(supabase, channel)
   if (updateMetadataRequired && !minUpdateVersion) {

package/src/bundle/zip.ts

@@ -5,8 +5,8 @@ import { program } from 'commander';
 import * as p from '@clack/prompts';
 import { checksum as getChecksum } from '@tomasklaen/checksum';
 import { checkLatest } from '../api/update';
-import { OptionsBase } from '../api/utils';
 import {
+    OptionsBase,
     getConfig,
     useLogSnag,
     regexSemver,

package/src/channel/add.ts

@@ -2,8 +2,7 @@ import { program } from "commander";
 import * as p from '@clack/prompts';
 import { checkAppExistsAndHasPermissionErr } from "../api/app";
 import { createChannel, findUnknownVersion } from "../api/channels";
-import { OptionsBase } from "../api/utils";
-import { findSavedKey, getConfig, useLogSnag, createSupabaseClient, verifyUser } from "../utils";
+import { OptionsBase, findSavedKey, getConfig, useLogSnag, createSupabaseClient, verifyUser } from "../utils";
 
 interface Options extends OptionsBase {
     default?: boolean;
@@ -28,7 +27,7 @@ export const addChannel = async (channelId: string, appId: string, options: Opti
 
     const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
     // Check we have app access to this appId
-    await checkAppExistsAndHasPermissionErr(supabase, appId);
+    await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId);
 
     p.log.info(`Creating channel ${appId}#${channelId} to Capgo`);
     try {

package/src/channel/currentBundle.ts

@@ -1,8 +1,7 @@
 import { program } from "commander";
 import * as p from '@clack/prompts';
 import { checkAppExistsAndHasPermissionErr } from "../api/app";
-import { OptionsBase } from "../api/utils";
-import { createSupabaseClient, findSavedKey, getConfig, verifyUser } from "../utils";
+import { OptionsBase, createSupabaseClient, findSavedKey, getConfig, verifyUser } from "../utils";
 
 
 interface Options extends OptionsBase {
@@ -39,7 +38,7 @@ export const currentBundle = async (channel: string, appId: string, options: Opt
   
     const userId = await verifyUser(supabase, options.apikey, ['write', 'all', 'read']);
     // Check we have app access to this appId
-    await checkAppExistsAndHasPermissionErr(supabase, appId);
+    await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId);
 
     if (!channel) {
         p.log.error(`Please provide a channel to get the bundle from.`);

package/src/channel/delete.ts

@@ -2,8 +2,7 @@ import { program } from "commander";
 import * as p from '@clack/prompts';
 import { checkAppExistsAndHasPermissionErr } from "../api/app";
 import { delChannel } from "../api/channels";
-import { OptionsBase } from "../api/utils";
-import { findSavedKey, getConfig, useLogSnag, createSupabaseClient, verifyUser } from "../utils";
+import { OptionsBase, findSavedKey, getConfig, useLogSnag, createSupabaseClient, verifyUser } from "../utils";
 
 export const deleteChannel = async (channelId: string, appId: string, options: OptionsBase) => {
     p.intro(`Delete channel`);
@@ -24,7 +23,7 @@ export const deleteChannel = async (channelId: string, appId: string, options: O
 
     const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
     // Check we have app access to this appId
-    await checkAppExistsAndHasPermissionErr(supabase, appId);
+    await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId);
 
     p.log.info(`Deleting channel ${appId}#${channelId} from Capgo`);
     try {

package/src/channel/list.ts

@@ -2,8 +2,7 @@ import { program } from 'commander';
 import * as p from '@clack/prompts';
 import { checkAppExistsAndHasPermissionErr } from '../api/app';
 import { getActiveChannels, displayChannels } from '../api/channels';
-import { OptionsBase } from '../api/utils';
-import { findSavedKey, getConfig, createSupabaseClient, verifyUser, useLogSnag } from '../utils';
+import { OptionsBase, findSavedKey, getConfig, createSupabaseClient, verifyUser, useLogSnag } from '../utils';
 
 export const listChannels = async (appId: string, options: OptionsBase) => {
   p.intro(`List channels`);
@@ -23,13 +22,10 @@ export const listChannels = async (appId: string, options: OptionsBase) => {
 
   const userId = await verifyUser(supabase, options.apikey, ['write', 'all', 'read', 'upload']);
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, appId);
+  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId);
 
   p.log.info(`Querying available channels in Capgo`);
 
-  // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, appId);
-
   // Get all active app versions we might possibly be able to cleanup
   const allVersions = await getActiveChannels(supabase, appId, userId);
 

package/src/channel/set.ts

@@ -1,9 +1,9 @@
 import { program } from 'commander';
 import * as p from '@clack/prompts';
 import { Database } from 'types/supabase.types';
-import { OptionsBase } from '../api/utils';
 import { checkAppExistsAndHasPermissionErr } from "../api/app";
 import {
+  OptionsBase,
   getConfig, createSupabaseClient, updateOrCreateChannel,
   formatError, findSavedKey, checkPlanValid, useLogSnag, verifyUser
 } from '../utils';
@@ -42,7 +42,7 @@ export const setChannel = async (channel: string, appId: string, options: Option
 
   const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermissionErr(supabase, appId);
+  await checkAppExistsAndHasPermissionErr(supabase, options.apikey, appId);
 
   const { bundle, latest, downgrade, upgrade, ios, android, selfAssign, state, disableAutoUpdate } = options;
   if (!channel) {
@@ -67,8 +67,6 @@ export const setChannel = async (channel: string, appId: string, options: Option
   }
   try {
     await checkPlanValid(supabase, userId)
-    // Check we have app access to this appId
-    await checkAppExistsAndHasPermissionErr(supabase, appId);
     const channelPayload: Database['public']['Tables']['channels']['Insert'] = {
       created_by: userId,
       app_id: appId,

package/src/login.ts

@@ -16,7 +16,8 @@ export const login = async (apikey: string, options: Options, shouldExit = true)
   }
   if (!apikey) {
     if (shouldExit) {
-      program.error("Missing API key, you need to provide a API key to upload your bundle");
+      p.log.error('Missing API key, you need to provide a API key to upload your bundle');
+      program.error('');
     }
     return false
   }