@capgo/cli 3.9.2 → 3.10.1

package/src/app/add.ts

@@ -1,6 +1,7 @@
 import { getType } from 'mime';
 import { program } from 'commander';
 import { randomUUID } from 'crypto';
+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';
@@ -10,6 +11,9 @@ import {
 } from '../utils';
 
 export const addApp = async (appId: string, options: Options, shouldExit = true) => {
+  if (shouldExit) {
+    p.intro(`Adding`);
+  }
   await checkLatest();
   options.apikey = options.apikey || findSavedKey()
   const config = await getConfig();
@@ -17,10 +21,12 @@ export const addApp = async (appId: string, options: Options, shouldExit = true)
   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 = createSupabaseClient(options.apikey)
 
@@ -40,10 +46,11 @@ export const addApp = async (appId: string, options: Options, shouldExit = true)
   name = name || config?.app?.appName || 'Unknown'
   icon = icon || "resources/icon.png" // default path for capacitor app
   if (!icon || !name) {
-    program.error("Missing argument, you need to provide a appId and a name, or be in a capacitor project");
+    p.log.error("Missing argument, you need to provide a appId and a name, or be in a capacitor project");
+    program.error('');
   }
   if (shouldExit) {
-    console.log(`Adding ${appId} to Capgo`);
+    p.log.info(`Adding ${appId} to Capgo`);
   }
   let iconBuff;
   let iconType;
@@ -52,15 +59,15 @@ export const addApp = async (appId: string, options: Options, shouldExit = true)
     iconBuff = readFileSync(icon);
     const contentType = getType(icon);
     iconType = contentType || 'image/png';
-    console.warn(`Found app icon ${icon}`);
+    p.log.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}`);
+    p.log.warn(`Found app icon ${newIconPath}`);
   } else {
-    console.warn(`Cannot find app icon in any of the following locations: ${icon}, ${newIconPath}`);
+    p.log.warn(`Cannot find app icon in any of the following locations: ${icon}, ${newIconPath}`);
   }
 
   // check if app already exist
@@ -68,7 +75,8 @@ export const addApp = async (appId: string, options: Options, shouldExit = true)
     .rpc('exist_app_v2', { appid: appId })
     .single()
   if (app || dbError0) {
-    program.error(`App ${appId} already exists ${formatError(dbError0)}`)
+    p.log.error(`App ${appId} already exists ${formatError(dbError0)}`);
+    program.error('');
   }
 
   const fileName = `icon_${randomUUID()}`
@@ -82,7 +90,8 @@ export const addApp = async (appId: string, options: Options, shouldExit = true)
         contentType: iconType,
       })
     if (error) {
-      program.error(`Could not add app ${formatError(error)}`);
+      p.log.error(`Could not add app ${formatError(error)}`);
+      program.error('');
     }
     const { data: signedURLData } = await supabase
       .storage
@@ -100,7 +109,8 @@ export const addApp = async (appId: string, options: Options, shouldExit = true)
       app_id: appId,
     })
   if (dbError) {
-    program.error(`Could not add app ${formatError(dbError)}`);
+    p.log.error(`Could not add app ${formatError(dbError)}`);
+    program.error('');
   }
   const { error: dbVersionError } = await supabase
     .from('app_versions')
@@ -116,7 +126,8 @@ export const addApp = async (appId: string, options: Options, shouldExit = true)
       app_id: appId,
     }])
   if (dbVersionError) {
-    program.error(`Could not add app ${formatError(dbVersionError)}`);
+    p.log.error(`Could not add app ${formatError(dbVersionError)}`);
+    program.error('');
   }
   await snag.publish({
     channel: 'app',
@@ -128,9 +139,9 @@ export const addApp = async (appId: string, options: Options, shouldExit = true)
     },
     notify: false,
   }).catch()
-  console.log("App added to server, you can upload a bundle now")
+  p.log.success(`App ${appId} added to Capgo. ${shouldExit ? 'You can upload a bundle now' : ''}`);
   if (shouldExit) {
-    console.log(`Done ✅`);
+    p.outro(`Done ✅`);
     process.exit()
   }
   return true

package/src/app/delete.ts

@@ -1,9 +1,11 @@
 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";
 
 export const deleteApp = async (appId: string, options: OptionsBase) => {
+    p.intro(`Deleting`);
     options.apikey = options.apikey || findSavedKey()
     const config = await getConfig();
     appId = appId || config?.app?.appId
@@ -55,7 +57,7 @@ export const deleteApp = async (appId: string, options: OptionsBase) => {
         },
         notify: false,
     }).catch()
-    console.log("App deleted in Capgo")
-    console.log(`Done ✅`);
+    p.log.success(`App deleted in Capgo`);
+    p.outro('Done ✅');
     process.exit()
 }

package/src/app/list.ts

@@ -2,26 +2,27 @@ import { program } from 'commander';
 import { Database } from 'types/supabase.types';
 import { Table } from 'console-table-printer';
 import { SupabaseClient } from '@supabase/supabase-js';
+import * as p from '@clack/prompts';
 import { checkAppExistsAndHasPermissionErr } from '../api/app';
 import { OptionsBase } from '../api/utils';
 import { createSupabaseClient, findSavedKey, formatError, getConfig, getHumanDate, verifyUser } from '../utils';
 import { checkLatest } from '../api/update';
 
 const displayApp = (data: Database['public']['Tables']['apps']['Row'][]) => {
-  const p = new Table({
+  const t = new Table({
     title: "Apps",
     charLength: { "❌": 2, "✅": 2 },
   });
 
   // add rows with color
   data.reverse().forEach(row => {
-    p.addRow({
+    t.addRow({
       Name: row.name,
       Created: getHumanDate(row.created_at)
     });
   });
 
-  p.printTable();
+  p.log.success(t.render());
 }
 
 export const getActiveApps = async (supabase: SupabaseClient<Database>, userId: string) => {
@@ -38,23 +39,27 @@ export const getActiveApps = async (supabase: SupabaseClient<Database>, userId:
 }
 
 export const listApp = async (appId: string, options: OptionsBase) => {
+  p.intro(`List apps in Capgo`);
+
   await checkLatest();
   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 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 = createSupabaseClient(options.apikey)
 
   const userId = await verifyUser(supabase, options.apikey);
 
-  console.log(`Querying available versions in Capgo`);
+  p.log.info(`Getting active bundle in Capgo`);
 
   // Check we have app access to this appId
   await checkAppExistsAndHasPermissionErr(supabase, appId, options.apikey);
@@ -62,9 +67,9 @@ export const listApp = async (appId: string, options: OptionsBase) => {
   // Get all active app versions we might possibly be able to cleanup
   const allApps = await getActiveApps(supabase, userId);
 
-  console.log(`Active app in Capgo: ${allApps?.length}`);
+  p.log.info(`Active app in Capgo: ${allApps?.length}`);
 
   displayApp(allApps);
-  console.log(`Done ✅`);
+  p.outro(`Done ✅`);
   process.exit()
 }

package/src/app/set.ts

@@ -1,20 +1,24 @@
 import { getType } from 'mime';
 import { program } from "commander";
 import { randomUUID } from "crypto";
+import * as p from '@clack/prompts';
 import { existsSync, readFileSync } from "fs-extra";
 import { checkAppExistsAndHasPermissionErr, newIconPath, Options } from '../api/app';
 import { createSupabaseClient, findSavedKey, formatError, getConfig, verifyUser } from "../utils";
 
 export const setApp = async (appId: string, options: Options) => {
+    p.intro(`Set app`);
     options.apikey = options.apikey || findSavedKey()
     const config = await getConfig();
     appId = appId || config?.app?.appId
 
     if (!options.apikey) {
-        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 = createSupabaseClient(options.apikey)
 
@@ -33,15 +37,15 @@ export const setApp = async (appId: string, options: Options) => {
         iconBuff = readFileSync(icon);
         const contentType = getType(icon);
         iconType = contentType || 'image/png';
-        console.warn(`Found app icon ${icon}`);
+        p.log.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}`);
+        p.log.warn(`Found app icon ${newIconPath}`);
     } else {
-        console.warn(`Cannot find app icon in any of the following locations: ${icon}, ${newIconPath}`);
+        p.log.warn(`Cannot find app icon in any of the following locations: ${icon}, ${newIconPath}`);
     }
     if (iconBuff && iconType) {
         const { error } = await supabase.storage
@@ -50,7 +54,8 @@ export const setApp = async (appId: string, options: Options) => {
                 contentType: iconType,
             })
         if (error) {
-            program.error(`Could not add app ${formatError(error)}`);
+            p.log.error(`Could not add app ${formatError(error)}`);
+            program.error(``);
         }
         const { data: signedURLData } = await supabase
             .storage
@@ -67,8 +72,9 @@ export const setApp = async (appId: string, options: Options) => {
         .eq('app_id', appId)
         .eq('user_id', userId)
     if (dbError) {
-        program.error(`Could not add app ${formatError(dbError)}`);
+        p.log.error(`Could not add app ${formatError(dbError)}`);
+        program.error(``);
     }
-    console.log(`Done ✅`);
+    p.outro(`Done ✅`);
     process.exit()
 }

package/src/app/watch.ts

@@ -79,7 +79,7 @@ export const watch = async (port: string, options: Options, shouldExit = true) =
     process.exit(1);
   }
   if (shouldExit) {
-    console.log(`Done ✅`);
+    p.outro(`Done ✅`);
     process.exit()
   }
   return true

package/src/bundle/cleanup.ts

@@ -1,5 +1,6 @@
 import { program } from 'commander';
 import semver from 'semver/preload';
+import * as p from '@clack/prompts';
 import promptSync from 'prompt-sync';
 import { SupabaseClient } from '@supabase/supabase-js';
 import { Database } from 'types/supabase.types';
@@ -25,7 +26,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.created_at))}`);
+    p.log.warn(`Removing ${row.name} created on ${(getHumanDate(row.created_at))}`);
     await deleteSpecificVersion(supabase, appid, userId, row.name);
   }
 }
@@ -43,6 +44,7 @@ const getRemovableVersionsInSemverRange = (data: Database['public']['Tables']['a
 }
 
 export const cleanupBundle = async (appid: string, options: Options) => {
+  p.intro(`Cleanup versions in Capgo`);
   await checkLatest();
   const apikey = options.apikey || findSavedKey()
   const { bundle, keep = 4 } = options;
@@ -62,26 +64,26 @@ export const cleanupBundle = async (appid: string, options: Options) => {
 
   // Check we have app access to this appId
   await checkAppExistsAndHasPermissionErr(supabase, appid, apikey);
-  console.log(`Querying all available versions in Capgo`);
+  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);
 
-  console.log(`Total active versions in Capgo: ${allVersions?.length}`);
+  p.log.info(`Total active versions in Capgo: ${allVersions?.length}`);
   if (allVersions?.length === 0) {
-    console.log('No versions found, aborting cleanup');
+    p.log.error('No versions found, aborting cleanup');
     return;
   }
   if (bundle) {
     const nextMajor = `${semver.inc(bundle, 'major')}`;
-    console.log(`Querying available versions in Capgo between ${bundle} and ${nextMajor}`);
+    p.log.info(`Querying available versions in Capgo between ${bundle} and ${nextMajor}`);
 
     // Get all app versions that are in the given range
     allVersions = getRemovableVersionsInSemverRange(allVersions, bundle,
       nextMajor) as (Database['public']['Tables']['app_versions']['Row'] & { keep: string })[];
 
-    console.log(`Active versions in Capgo between ${bundle} and ${nextMajor}: ${allVersions?.length}`);
+    p.log.info(`Active versions in Capgo between ${bundle} and ${nextMajor}: ${allVersions?.length}`);
   }
 
   // Slice to keep and remove
@@ -98,7 +100,7 @@ export const cleanupBundle = async (appid: string, options: Options) => {
   })
 
   if (toRemove.length === 0) {
-    console.log("Nothing to be removed, aborting removal...")
+    p.log.warn("Nothing to be removed, aborting removal...")
     return;
   }
   displayBundles(allVersions);
@@ -107,14 +109,14 @@ export const cleanupBundle = async (appid: string, options: Options) => {
   if (!force) {
     const result = prompt("Do you want to continue removing the versions specified? Type yes to confirm: ");
     if (result !== "yes") {
-      console.log("Not confirmed, aborting removal...");
+      p.log.warn("Not confirmed, aborting removal...");
       return;
     }
   }
 
   // Yes, lets clean it up
-  console.log("You have confirmed removal, removing versions now");
+  p.log.success("You have confirmed removal, removing versions now");
   await removeVersions(toRemove, supabase, appid, userId);
-  console.log(`Done ✅`);
+  p.outro(`Done ✅`);
   process.exit()
 }

package/src/bundle/decrypt.ts

@@ -1,4 +1,5 @@
 import { program } from 'commander'
+import * as p from '@clack/prompts';
 import { existsSync, readFileSync, writeFileSync } from 'fs'
 import { decryptSource } from '../api/crypto';
 import { baseKey, getConfig } from '../utils';
@@ -10,6 +11,7 @@ interface Options {
 }
 
 export const decryptZip = async (zipPath: string, ivsessionKey: string, options: Options) => {
+  p.intro(`Decrypt zip file`);
   await checkLatest();
   // write in file .capgo the apikey in home directory
 
@@ -41,6 +43,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 ✅`);
+  p.outro(`Decrypted zip file at ${zipPath}_decrypted.zip`);
   process.exit()
 }

package/src/bundle/delete.ts

@@ -1,4 +1,5 @@
 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';
@@ -9,15 +10,18 @@ interface Options extends OptionsBase {
 }
 
 export const deleteBundle = async (appId: string, bundleId: string, options: Options) => {
+  p.intro(`Delete bundle`);
   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");
+    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 = createSupabaseClient(options.apikey)
 
@@ -29,19 +33,22 @@ export const deleteBundle = async (appId: string, bundleId: string, options: Opt
 
   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 (!bundleId) {
-    program.error('Missing argument, you need to provide a bundleId, or be in a capacitor project');
+    p.log.error('Missing argument, you need to provide a bundleId, or be in a capacitor project');
+    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('');
   }
 
-  console.log(`Delete ${appId}@${bundleId} from Capgo`);
+  p.log.info(`Deleting bundle ${appId}@${bundleId} from Capgo`);
 
   await deleteSpecificVersion(supabase, appId, userId, bundleId);
-  console.log(`${appId}@${bundleId} deleted from server`)
-  console.log(`Done ✅`);
+  p.log.success(`Bundle ${appId}@${bundleId} deleted in Capgo`);
+  p.outro(`Done`);
   process.exit()
 }

package/src/bundle/encrypt.ts

@@ -1,8 +1,10 @@
 import { program } from 'commander'
 import { existsSync, readFileSync, writeFileSync } from 'fs'
+import ciDetect from '@npmcli/ci-detect';
+import * as p from '@clack/prompts';
 import { checkLatest } from '../api/update';
 import { encryptSource } from '../api/crypto';
-import { baseKeyPub } from '../utils';
+import { baseKeyPub, defaulPublicKey } from '../utils';
 
 interface Options {
   key?: string
@@ -10,11 +12,14 @@ interface Options {
 }
 
 export const encryptZip = async (zipPath: string, options: Options) => {
+  p.intro(`Encryption`);
+
   await checkLatest();
   // write in file .capgo the apikey in home directory
 
   if (!existsSync(zipPath)) {
-    program.error(`Zip not found at the path ${zipPath}`);
+    p.log.error(`Error: Zip not found at the path ${zipPath}`);
+    program.error('');
   }
 
   const keyPath = options.key || baseKeyPub
@@ -23,7 +28,17 @@ export const encryptZip = async (zipPath: string, options: Options) => {
   let publicKey = options.keyData || "";
 
   if (!existsSync(keyPath) && !publicKey) {
-    program.error(`Cannot find public key ${keyPath} or as keyData option`)
+    p.log.warning(`Cannot find public key ${keyPath} or as keyData option`);
+    if (ciDetect()) {
+      p.log.error(`Error: Missing public key`);
+      program.error('');
+    }
+    const res = await p.confirm({ message: 'Do you want to use our public key ?' })
+    if (!res) {
+      p.log.error(`Error: Missing public key`);
+      program.error('');
+    }
+    publicKey = defaulPublicKey
   } else if (existsSync(keyPath)) {
     // open with fs publicKey path
     const keyFile = readFileSync(keyPath)
@@ -32,9 +47,10 @@ export const encryptZip = async (zipPath: string, options: Options) => {
 
   const zipFile = readFileSync(zipPath)
   const encodedZip = encryptSource(zipFile, publicKey)
-  console.log('ivSessionKey', encodedZip.ivSessionKey)
+  p.log.success(`ivSessionKey: ${encodedZip.ivSessionKey}`);
   // write decodedZip in a file
   writeFileSync(`${zipPath}_encrypted.zip`, encodedZip.encryptedData)
-  console.log(`Done ✅`);
+  p.log.success(`Encrypted zip saved at ${zipPath}_encrypted.zip`);
+  p.outro(`Done ✅`);
   process.exit()
 }

package/src/bundle/list.ts

@@ -1,4 +1,5 @@
 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';
@@ -6,23 +7,26 @@ import { createSupabaseClient, findSavedKey, getConfig, verifyUser } from '../ut
 import { checkLatest } from '../api/update';
 
 export const listBundle = async (appId: string, options: OptionsBase) => {
+    p.intro(`List bundles`);
     await checkLatest();
     options.apikey = options.apikey || findSavedKey()
     const config = await getConfig();
 
     appId = appId || config?.app?.appId
     if (!options.apikey) {
-        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 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 = createSupabaseClient(options.apikey)
 
     const userId = await verifyUser(supabase, options.apikey);
 
-    console.log(`Querying available versions in Capgo`);
+    p.log.info(`Querying available versions of: ${appId} in Capgo`);
 
     // Check we have app access to this appId
     await checkAppExistsAndHasPermissionErr(supabase, appId, options.apikey);
@@ -30,9 +34,9 @@ export const listBundle = async (appId: string, options: OptionsBase) => {
     // Get all active app versions we might possibly be able to cleanup
     const allVersions = await getActiveAppVersions(supabase, appId, userId);
 
-    console.log(`Active versions in Capgo: ${allVersions?.length}`);
+    p.log.info(`Active versions in Capgo: ${allVersions?.length}`);
 
     displayBundles(allVersions);
-    console.log(`Done ✅`);
+    p.outro(`Done ✅`);
     process.exit()
 }

package/src/bundle/unlink.ts

@@ -1,5 +1,6 @@
 import { program } from 'commander';
 import { getVersionData } from 'api/versions';
+import * as p from '@clack/prompts';
 import { checkVersionNotUsedInDeviceOverride } from '../api/devices_override';
 import { checkVersionNotUsedInChannel } from '../api/channels';
 import { OptionsBase } from '../api/utils';
@@ -14,6 +15,7 @@ interface Options extends OptionsBase {
 }
 
 export const unlinkDevice = async (channel: string, appId: string, options: Options) => {
+    p.intro(`Unlink bundle`);
     options.apikey = options.apikey || findSavedKey()
     const config = await getConfig();
     appId = appId || config?.app?.appId
@@ -23,13 +25,16 @@ export const unlinkDevice = async (channel: string, appId: string, options: Opti
     bundle = bundle || config?.app?.package?.version
 
     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('');
     }
     if (!bundle) {
-        program.error("Missing argument, you need to provide a bundle, or be in a capacitor project");
+        p.log.error("Missing argument, you need to provide a bundle, or be in a capacitor project");
+        program.error('');
     }
     const supabase = createSupabaseClient(options.apikey)
 
@@ -38,7 +43,8 @@ export const unlinkDevice = async (channel: string, appId: string, options: Opti
     await checkAppExistsAndHasPermissionErr(supabase, appId, options.apikey);
 
     if (!channel) {
-        program.error("Missing argument, you need to provide a channel");
+        p.log.error("Missing argument, you need to provide a channel");
+        program.error('');
     }
     try {
         await checkPlanValid(supabase, userId)
@@ -57,8 +63,9 @@ export const unlinkDevice = async (channel: string, appId: string, options: Opti
             notify: false,
         }).catch()
     } catch (err) {
-        program.error(`Unknow error ${formatError(err)}`);
+        p.log.error(`Unknow error ${formatError(err)}`);
+        program.error('');
     }
-    console.log(`Done ✅`);
+    p.outro('Done ✅');
     process.exit()
 }