@capgo/cli 2.5.8 → 3.0.0-alpha.0

package/src/{bin → app}/list.ts

@@ -1,22 +1,19 @@
 import { program } from 'commander';
-import { createSupabaseClient, findSavedKey, getConfig, verifyUser } from './utils';
 import { checkAppExistsAndHasPermission } from '../api/app';
-import { displayBundles, getActiveAppVersions } from '../api/versions';
+import { OptionsBase } from '../api/utils';
+import { getActiveAppVersions, displayBundles } from '../api/versions';
+import { createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils';
 
-interface Options {
-  apikey: string;
-  version: string;
-}
-
-export const listApp = async (appid: string, options: Options) => {
+export const listApp = async (appId: string, options: OptionsBase) => {
   const apikey = options.apikey || findSavedKey()
   const config = await getConfig();
 
-  appid = appid || config?.app?.appId
+  console.log('COMMAND DEPRECATED, use "app list" instead')
+  appId = appId || config?.app?.appId
   if (!apikey) {
     program.error('Missing API key, you need to provide an API key to delete your app');
   }
-  if (!appid) {
+  if (!appId) {
     program.error('Missing argument, you need to provide a appid, or be in a capacitor project');
   }
   console.log(`Querying available versions in Capgo`);
@@ -25,14 +22,17 @@ export const listApp = async (appid: string, options: Options) => {
 
   const userId = await verifyUser(supabase, apikey);
 
+  console.log(`Querying available versions in Capgo`);
+
   // Check we have app access to this appId
-  await checkAppExistsAndHasPermission(supabase, appid, apikey);
+  await checkAppExistsAndHasPermission(supabase, appId, options.apikey);
 
   // Get all active app versions we might possibly be able to cleanup
-  const allVersions = await getActiveAppVersions(supabase, appid, userId);
+  const allVersions = await getActiveAppVersions(supabase, appId, userId);
 
   console.log(`Active versions in Capgo: ${allVersions?.length}`);
 
   displayBundles(allVersions);
+  console.log(`Done ✅`);
   process.exit()
 }

package/src/app/set.ts

@@ -0,0 +1,74 @@
+import { getType } from 'mime';
+import { program } from "commander";
+import { randomUUID } from "crypto";
+import { existsSync, readFileSync } from "fs-extra";
+import { checkAppExistsAndHasPermission, newIconPath, Options } from '../api/app';
+import { createSupabaseClient, findSavedKey, formatError, getConfig, verifyUser } from "../utils";
+
+export const setApp = async (appId: string, userId: string, options: Options) => {
+    options.apikey = options.apikey || findSavedKey() || ''
+    const config = await getConfig();
+    appId = appId || config?.app?.appId
+
+    if (!options.apikey) {
+        program.error("Missing API key, you need to provide a API key to upload your bundle");
+    }
+    if (!appId) {
+        program.error("Missing argument, you need to provide a appId, or be in a capacitor project");
+    }
+    const supabase = createSupabaseClient(options.apikey)
+
+    await verifyUser(supabase, options.apikey, ['write', 'all']);
+    // Check we have app access to this appId
+    await checkAppExistsAndHasPermission(supabase, appId, options.apikey);
+
+    const { name, icon } = options;
+
+    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 = getType(icon);
+        iconType = contentType || 'image/png';
+        console.warn(`Found app icon ${icon}`);
+    }
+    else if (existsSync(newIconPath)) {
+        iconBuff = readFileSync(newIconPath);
+        const contentType = getType(newIconPath);
+        iconType = contentType || 'image/png';
+        console.warn(`Found app icon ${newIconPath}`);
+    } else {
+        console.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) {
+            program.error(`Could not add app ${formatError(error)}`);
+        }
+        const { data: signedURLData } = await supabase
+            .storage
+            .from(`images/${userId}/${appId}`)
+            .getPublicUrl(fileName)
+        signedURL = signedURLData?.publicUrl || signedURL
+    }
+    const { error: dbError } = await supabase
+        .from('apps')
+        .update({
+            icon_url: signedURL,
+            name,
+        })
+        .eq('app_id', appId)
+        .eq('user_id', userId)
+    if (dbError) {
+        program.error(`Could not add app ${formatError(dbError)}`);
+    }
+    console.log(`Done ✅`);
+    process.exit()
+}

package/src/{bin → bundle}/cleanup.ts

@@ -3,13 +3,13 @@ import semver from 'semver/preload';
 import promptSync from 'prompt-sync';
 import { SupabaseClient } from '@supabase/supabase-js';
 import { Database } from 'types/supabase.types';
-import { createSupabaseClient, findSavedKey, getConfig, getHumanDate, verifyUser } from './utils';
+import { OptionsBase } from '../api/utils';
+import { createSupabaseClient, findSavedKey, getConfig, getHumanDate, verifyUser } from '../utils';
 import { deleteSpecificVersion, displayBundles, getActiveAppVersions } from '../api/versions';
 import { checkAppExistsAndHasPermission } from '../api/app';
 // import { definitions } from '../types/types_supabase';
 
-interface Options {
-  apikey: string;
+interface Options extends OptionsBase {
   version: string;
   bundle: string;
   keep: number;
@@ -23,7 +23,7 @@ const removeVersions = async (toRemove: Database['public']['Tables']['app_versio
 
   // call deleteSpecificVersion one by one from toRemove sync
   for await (const row of toRemove) {
-    console.log(`Removing ${row.name} created on ${(getHumanDate(row))}`);
+    console.log(`Removing ${row.name} created on ${(getHumanDate(row.created_at))}`);
     await deleteSpecificVersion(supabase, appid, userId, row.name);
   }
 }
@@ -112,5 +112,6 @@ export const cleanupApp = async (appid: string, options: Options) => {
   // Yes, lets clean it up
   console.log("You have confirmed removal, removing versions now");
   await removeVersions(toRemove, supabase, appid, userId);
+  console.log(`Done ✅`);
   process.exit()
 }

package/src/{bin → bundle}/decrypt.ts

@@ -1,7 +1,7 @@
 import { program } from 'commander'
 import { existsSync, readFileSync, writeFileSync } from 'fs'
 import { decryptSource } from '../api/crypto';
-import { baseKey, getConfig } from './utils';
+import { baseKey, getConfig } from '../utils';
 
 interface Options {
   key?: string
@@ -39,5 +39,6 @@ export const decryptZip = async (zipPath: string, ivsessionKey: string, options:
   const decodedZip = decryptSource(zipFile, ivsessionKey, privateKey)
   // write decodedZip in a file
   writeFileSync(`${zipPath}_decrypted.zip`, decodedZip)
+  console.log(`Done ✅`);
   process.exit()
 }

package/src/bundle/delete.ts

@@ -0,0 +1,54 @@
+import { program } from 'commander';
+import { checkAppExistsAndHasPermission } from '../api/app';
+import { OptionsBase } from '../api/utils';
+import { createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../utils';
+import { deleteSpecificVersion } from '../api/versions';
+
+interface Options extends OptionsBase {
+  bundle: string;
+}
+
+export const deleteVersion = async (appId: string, bundleId: string, options: Options) => {
+  options.apikey = options.apikey || findSavedKey() || ''
+  const config = await getConfig();
+  appId = appId || config?.app?.appId
+
+  if (!options.apikey) {
+    program.error("Missing API key, you need to provide a API key to upload your bundle");
+  }
+  if (!appId) {
+    program.error("Missing argument, you need to provide a appId, or be in a capacitor project");
+  }
+  const supabase = createSupabaseClient(options.apikey)
+
+  const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
+  // Check we have app access to this appId
+  await checkAppExistsAndHasPermission(supabase, appId, options.apikey);
+
+  const apikey = options.apikey || findSavedKey()
+
+  appId = appId || config?.app?.appId
+  if (!apikey) {
+    program.error('Missing API key, you need to provide an API key to delete your app');
+  }
+  if (!bundleId) {
+    program.error('Missing argument, you need to provide a bundleId, or be in a capacitor project');
+  }
+  if (!appId) {
+    program.error('Missing argument, you need to provide a appId, or be in a capacitor project');
+  }
+
+  const { data: app, error: dbError0 } = await supabase
+    .rpc('exist_app', { appid: appId, apikey })
+    .single()
+  if (!app || dbError0) {
+    program.error('No permission to delete')
+  }
+
+  console.log(`Delete ${appId}@${bundleId} from Capgo`);
+
+  await deleteSpecificVersion(supabase, appId, userId, bundleId);
+  console.log(`${appId}@${bundleId} deleted from server`)
+  console.log(`Done ✅`);
+  process.exit()
+}

package/src/{bin → bundle}/encrypt.ts

@@ -1,7 +1,7 @@
 import { program } from 'commander'
 import { existsSync, readFileSync, writeFileSync } from 'fs'
 import { encryptSource } from '../api/crypto';
-import { baseKeyPub } from './utils';
+import { baseKeyPub } from '../utils';
 
 interface Options {
   key?: string
@@ -33,5 +33,6 @@ export const encryptZip = async (zipPath: string, options: Options) => {
   console.log('ivSessionKey', encodedZip.ivSessionKey)
   // write decodedZip in a file
   writeFileSync(`${zipPath}_encrypted.zip`, encodedZip.encryptedData)
+  console.log(`Done ✅`);
   process.exit()
 }

package/src/{bin → bundle}/upload.ts

@@ -4,6 +4,7 @@ import { randomUUID } from 'crypto';
 import cliProgress from 'cli-progress';
 import { existsSync, readFileSync } from 'fs';
 import { checksum as getChecksum } from '@tomasklaen/checksum';
+import { OptionsBase } from '../api/utils';
 import { checkAppExistsAndHasPermission } from "../api/app";
 import { encryptSource } from '../api/crypto';
 import {
@@ -11,20 +12,19 @@ import {
   updateOrCreateChannel, updateOrCreateVersion,
   formatError, findSavedKey, checkPlanValid,
   useLogSnag, verifyUser, regexSemver, baseKeyPub, convertAppName
-} from './utils';
+} from '../utils';
 
-interface Options {
+const alertMb = 20;
+
+interface Options extends OptionsBase {
   bundle: string
   path: string
-  apikey: string
   channel?: string
   displayIvSession?: boolean
   external?: string
   key?: boolean | string
 }
 
-const alertMb = 20;
-
 export const uploadVersion = async (appid: string, options: Options) => {
   let { bundle, path, channel } = options;
   const { external, key = false, displayIvSession } = options;
@@ -206,5 +206,6 @@ It will be also visible in your dashboard\n`);
     },
     notify: false,
   }).catch()
+  console.log(`Done ✅`);
   process.exit()
-}
+}

package/src/channel/add.ts

@@ -0,0 +1,49 @@
+import { program } from "commander";
+import { checkAppExistsAndHasPermission } from "../api/app";
+import { createChannel, findUnknownVersion } from "../api/channels";
+import { OptionsBase } from "../api/utils";
+import { findSavedKey, getConfig, useLogSnag, createSupabaseClient, verifyUser } from "../utils";
+
+export const addChannel = async (channelId: string, appId: string, options: OptionsBase) => {
+    options.apikey = options.apikey || findSavedKey() || ''
+    const config = await getConfig();
+    appId = appId || config?.app?.appId
+    const snag = useLogSnag()
+
+    if (!options.apikey) {
+        program.error("Missing API key, you need to provide a API key to upload your bundle");
+    }
+    if (!appId) {
+        program.error("Missing argument, you need to provide a appId, or be in a capacitor project");
+    }
+    const supabase = createSupabaseClient(options.apikey)
+
+    const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
+    // Check we have app access to this appId
+    await checkAppExistsAndHasPermission(supabase, appId, options.apikey);
+
+    console.log(`Create channel ${appId}#${channelId} to Capgo cloud`);
+    try {
+        const { data } = await findUnknownVersion(supabase, appId)
+        if (!data) {
+            program.error(`Cannot find default version for channel creation, please contact Capgo support 🤨`);
+        }
+        await createChannel(supabase, { name: channelId, app_id: appId, version: data.id, created_by: userId });
+        console.log(`Channel created ✅`);
+        await snag.publish({
+            channel: 'app',
+            event: 'Create channel',
+            icon: '✅',
+            tags: {
+                'user-id': userId,
+                'app-id': appId,
+                'channel': channelId,
+            },
+            notify: false,
+        }).catch()
+    } catch (error) {
+        console.log(`Cannot create Channel 🙀`, error);
+    }
+    console.log(`Done ✅`);
+    process.exit()
+}

package/src/channel/delete.ts

@@ -0,0 +1,45 @@
+import { program } from "commander";
+import { checkAppExistsAndHasPermission } from "../api/app";
+import { delChannel } from "../api/channels";
+import { OptionsBase } from "../api/utils";
+import { findSavedKey, getConfig, useLogSnag, createSupabaseClient, verifyUser } from "../utils";
+
+export const deleteChannel = async (channelId: string, appId: string, options: OptionsBase) => {
+    options.apikey = options.apikey || findSavedKey() || ''
+    const config = await getConfig();
+    appId = appId || config?.app?.appId
+    const snag = useLogSnag()
+
+    if (!options.apikey) {
+        program.error("Missing API key, you need to provide a API key to upload your bundle");
+    }
+    if (!appId) {
+        program.error("Missing argument, you need to provide a appId, or be in a capacitor project");
+    }
+    const supabase = createSupabaseClient(options.apikey)
+
+    const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
+    // Check we have app access to this appId
+    await checkAppExistsAndHasPermission(supabase, appId, options.apikey);
+
+    console.log(`Delete channel ${appId}#${channelId} to Capgo cloud`);
+    try {
+        await delChannel(supabase, channelId, appId, userId);
+        console.log(`Channel Delete ✅`);
+        await snag.publish({
+            channel: 'app',
+            event: 'Delete channel',
+            icon: '✅',
+            tags: {
+                'user-id': userId,
+                'app-id': appId,
+                'channel': channelId,
+            },
+            notify: false,
+        }).catch()
+    } catch (error) {
+        console.log(`Cannot delete Channel 🙀`, error);
+    }
+    console.log(`Done ✅`);
+    process.exit()
+}

package/src/channel/list.ts

@@ -0,0 +1,37 @@
+import { program } from 'commander';
+import { checkAppExistsAndHasPermission } from '../api/app';
+import { getActiveChannels, displayChannels } from '../api/channels';
+import { OptionsBase } from '../api/utils';
+import { findSavedKey, getConfig, createSupabaseClient, verifyUser } from '../utils';
+
+export const listChannels = async (appId: string, options: OptionsBase) => {
+  options.apikey = options.apikey || findSavedKey() || ''
+  const config = await getConfig();
+  appId = appId || config?.app?.appId
+
+  if (!options.apikey) {
+    program.error("Missing API key, you need to provide a API key to upload your bundle");
+  }
+  if (!appId) {
+    program.error("Missing argument, you need to provide a appId, or be in a capacitor project");
+  }
+  const supabase = createSupabaseClient(options.apikey)
+
+  const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
+  // Check we have app access to this appId
+  await checkAppExistsAndHasPermission(supabase, appId, options.apikey);
+
+  console.log(`Querying available versions in Capgo`);
+
+  // Check we have app access to this appId
+  await checkAppExistsAndHasPermission(supabase, appId, options.apikey);
+
+  // Get all active app versions we might possibly be able to cleanup
+  const allVersions = await getActiveChannels(supabase, appId, userId);
+
+  console.log(`Active channels in Capgo: ${allVersions?.length}`);
+
+  displayChannels(allVersions);
+  console.log(`Done ✅`);
+  process.exit()
+}

package/src/{bin → channel}/set.ts

@@ -1,15 +1,14 @@
 import { program } from 'commander';
-import LogSnag from 'logsnag';
 import { Database } from 'types/supabase.types';
+import { OptionsBase } from '../api/utils';
 import { checkAppExistsAndHasPermission } from "../api/app";
 import {
   getConfig, createSupabaseClient, updateOrCreateChannel,
   formatError, findSavedKey, checkPlanValid, useLogSnag, verifyUser
-} from './utils';
+} from '../utils';
 // import { definitions } from '../types/types_supabase';
 
-interface Options {
-  apikey: string;
+interface Options extends OptionsBase {
   bundle: string;
   state?: string;
   downgrade?: boolean;
@@ -21,7 +20,24 @@ interface Options {
   channel?: string;
 }
 
-export const setChannelInternal = async (appid: string, apikey: string, defaulVersion: string, snag: LogSnag, options: Options) => {
+export const setChannel = async (appId: string, options: Options) => {
+  options.apikey = options.apikey || findSavedKey() || ''
+  const config = await getConfig();
+  appId = appId || config?.app?.appId
+  const snag = useLogSnag()
+
+  if (!options.apikey) {
+    program.error("Missing API key, you need to provide a API key to upload your bundle");
+  }
+  if (!appId) {
+    program.error("Missing argument, you need to provide a appId, or be in a capacitor project");
+  }
+  const supabase = createSupabaseClient(options.apikey)
+
+  const userId = await verifyUser(supabase, options.apikey, ['write', 'all']);
+  // Check we have app access to this appId
+  await checkAppExistsAndHasPermission(supabase, appId, options.apikey);
+
   const { bundle, latest, downgrade, upgrade, ios, android, selfAssign, channel, state } = options;
   if (!channel) {
     program.error("Missing argument, you need to provide a channel");
@@ -40,61 +56,59 @@ export const setChannelInternal = async (appid: string, apikey: string, defaulVe
     program.error("Missing argument, you need to provide a option to set");
   }
   try {
-    const supabase = createSupabaseClient(apikey)
-    const userId = await verifyUser(supabase, apikey, ['write', 'all']);
     await checkPlanValid(supabase, userId)
     // Check we have app access to this appId
-    await checkAppExistsAndHasPermission(supabase, appid, apikey);
+    await checkAppExistsAndHasPermission(supabase, appId, options.apikey);
     const channelPayload: Database['public']['Tables']['channels']['Insert'] = {
       created_by: userId,
-      app_id: appid,
+      app_id: appId,
       name: channel,
       version: undefined as any,
     }
-    const bundleVersion = latest ? defaulVersion : bundle
+    const bundleVersion = latest ? config?.app?.package?.version : bundle
     if (bundleVersion != null) {
       const { data, error: vError } = await supabase
         .from('app_versions')
         .select()
-        .eq('app_id', appid)
+        .eq('app_id', appId)
         .eq('name', bundleVersion)
         .eq('user_id', userId)
         .eq('deleted', false)
         .single()
       if (vError || !data)
         program.error(`Cannot find version ${bundleVersion}`);
-      console.log(`Set ${appid} channel: ${channel} to @${bundleVersion}`);
+      console.log(`Set ${appId} channel: ${channel} to @${bundleVersion}`);
       channelPayload.version = data.id
     }
     if (state != null) {
       if (state === 'public' || state === 'private') {
-        console.log(`Set ${appid} channel: ${channel} to public or private is deprecated, use default or normal instead`);
+        console.log(`Set ${appId} channel: ${channel} to public or private is deprecated, use default or normal instead`);
       }
-      console.log(`Set ${appid} channel: ${channel} to ${state === 'public' || state === 'default' ? 'default' : 'normal'}`);
+      console.log(`Set ${appId} channel: ${channel} to ${state === 'public' || state === 'default' ? 'default' : 'normal'}`);
       channelPayload.public = state === 'public' || state === 'default'
     }
     if (downgrade != null) {
-      console.log(`Set ${appid} channel: ${channel} to ${downgrade ? 'allow' : 'disallow'} downgrade`);
+      console.log(`Set ${appId} channel: ${channel} to ${downgrade ? 'allow' : 'disallow'} downgrade`);
       channelPayload.disableAutoUpdateUnderNative = !downgrade
     }
     if (upgrade != null) {
-      console.log(`Set ${appid} channel: ${channel} to ${upgrade ? 'allow' : 'disallow'} upgrade`);
+      console.log(`Set ${appId} channel: ${channel} to ${upgrade ? 'allow' : 'disallow'} upgrade`);
       channelPayload.disableAutoUpdateToMajor = !upgrade
     }
     if (ios != null) {
-      console.log(`Set ${appid} channel: ${channel} to ${ios ? 'allow' : 'disallow'} ios update`);
+      console.log(`Set ${appId} channel: ${channel} to ${ios ? 'allow' : 'disallow'} ios update`);
       channelPayload.ios = !!ios
     }
     if (android != null) {
-      console.log(`Set ${appid} channel: ${channel} to ${android ? 'allow' : 'disallow'} android update`);
+      console.log(`Set ${appId} channel: ${channel} to ${android ? 'allow' : 'disallow'} android update`);
       channelPayload.android = !!android
     }
     if (selfAssign != null) {
-      console.log(`Set ${appid} channel: ${channel} to ${selfAssign ? 'allow' : 'disallow'} self assign to this channel`);
+      console.log(`Set ${appId} channel: ${channel} to ${selfAssign ? 'allow' : 'disallow'} self assign to this channel`);
       channelPayload.allow_device_self_set = !!selfAssign
     }
     try {
-      const { error: dbError } = await updateOrCreateChannel(supabase, channelPayload, apikey)
+      const { error: dbError } = await updateOrCreateChannel(supabase, channelPayload, options.apikey)
       if (dbError)
         program.error(`Cannot set channel ${formatError(dbError)}`);
     }
@@ -107,7 +121,7 @@ export const setChannelInternal = async (appid: string, apikey: string, defaulVe
       icon: '✅',
       tags: {
         'user-id': userId,
-        'app-id': appid,
+        'app-id': appId,
       },
       notify: false,
     }).catch()
@@ -115,21 +129,5 @@ export const setChannelInternal = async (appid: string, apikey: string, defaulVe
     program.error(`Unknow error ${formatError(err)}`);
   }
   console.log(`Done ✅`);
-}
-
-export const setChannel = async (appid: string, options: Options) => {
-  const apikey = options.apikey || findSavedKey()
-  const config = await getConfig()
-  const snag = useLogSnag()
-
-  console.log('COMMAND DEPRECATED, use "channel set" instead')
-  appid = appid || config?.app?.appId
-  if (!apikey) {
-    program.error("Missing API key, you need to provide a API key to set your app");
-  }
-  if (!appid) {
-    program.error("Missing argument, you need to provide a appid, or be in a capacitor project");
-  }
-  return setChannelInternal(appid, apikey, config?.app?.package?.version, snag, options)
   process.exit()
-}
+}