@capgo/cli 4.0.12 → 4.0.14

package/src/key.ts

@@ -1,39 +1,41 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs'
 import { program } from 'commander'
-import { writeConfig } from '@capacitor/cli/dist/config';
-import * as p from '@clack/prompts';
-import { createRSA } from './api/crypto';
-import { baseKey, baseKeyPub, getConfig } from './utils';
-import { checkLatest } from './api/update';
+import { writeConfig } from '@capacitor/cli/dist/config'
+import * as p from '@clack/prompts'
+import { createRSA } from './api/crypto'
+import { baseKey, baseKeyPub, getConfig } from './utils'
+import { checkLatest } from './api/update'
 
 interface saveOptions {
   key?: string
   keyData?: string
 }
 interface Options {
-  force?: boolean;
+  force?: boolean
 }
 
-export const saveKey = async (options: saveOptions, log = true) => {
-  if (log) {
-    p.intro(`Save keys 🔑`);
-  }
-  const config = await getConfig();
-  const { extConfig } = config.app;
+export async function saveKey(options: saveOptions, log = true) {
+  if (log)
+    p.intro(`Save keys 🔑`)
+
+  const config = await getConfig()
+  const { extConfig } = config.app
 
   const keyPath = options.key || baseKey
   // check if publicKey exist
 
-  let privateKey = options.keyData || "";
+  let privateKey = options.keyData || ''
 
   if (!existsSync(keyPath) && !privateKey) {
     if (log) {
-      p.log.error(`Cannot find public key ${keyPath} or as keyData option or in ${config.app.extConfigFilePath}`);
-      program.error('');
-    } else {
+      p.log.error(`Cannot find public key ${keyPath} or as keyData option or in ${config.app.extConfigFilePath}`)
+      program.error('')
+    }
+    else {
       return false
     }
-  } else if (existsSync(keyPath)) {
+  }
+  else if (existsSync(keyPath)) {
     // open with fs publicKey path
     const keyFile = readFileSync(keyPath)
     privateKey = keyFile.toString()
@@ -43,65 +45,67 @@ export const saveKey = async (options: saveOptions, log = true) => {
     if (!extConfig.plugins) {
       extConfig.plugins = {
         extConfig: {},
-        CapacitorUpdater: {}
-      };
-    }
-    if (!extConfig.plugins.CapacitorUpdater) {
-      extConfig.plugins.CapacitorUpdater = {};
+        CapacitorUpdater: {},
+      }
     }
-    extConfig.plugins.CapacitorUpdater.privateKey = privateKey;
+    if (!extConfig.plugins.CapacitorUpdater)
+      extConfig.plugins.CapacitorUpdater = {}
+
+    extConfig.plugins.CapacitorUpdater.privateKey = privateKey
     // console.log('extConfig', extConfig)
     writeConfig(extConfig, config.app.extConfigFilePath)
   }
   if (log) {
-    p.log.success(`private key saved into ${config.app.extConfigFilePath} file in local directory`);
-    p.log.success(`your app will decode the zip archive with this key`);
+    p.log.success(`private key saved into ${config.app.extConfigFilePath} file in local directory`)
+    p.log.success(`your app will decode the zip archive with this key`)
   }
   return true
 }
-export const saveKeyCommand = async (options: saveOptions) => {
-  p.intro(`Save keys 🔑`);
-  await checkLatest();
+export async function saveKeyCommand(options: saveOptions) {
+  p.intro(`Save keys 🔑`)
+  await checkLatest()
   await saveKey(options)
 }
 
-export const createKey = async (options: Options, log = true) => {
+export async function createKey(options: Options, log = true) {
   // write in file .capgo the apikey in home directory
-  if (log) {
-    p.intro(`Create keys 🔑`);
-  }
+  if (log)
+    p.intro(`Create keys 🔑`)
+
   const { publicKey, privateKey } = createRSA()
 
   // check if baseName already exist
   if (existsSync(baseKeyPub) && !options.force) {
     if (log) {
-      p.log.error('Public Key already exists, use --force to overwrite');
-      program.error('');
-    } else {
+      p.log.error('Public Key already exists, use --force to overwrite')
+      program.error('')
+    }
+    else {
       return false
     }
   }
-  writeFileSync(baseKeyPub, publicKey);
+  writeFileSync(baseKeyPub, publicKey)
   if (existsSync(baseKey) && !options.force) {
     if (log) {
-      p.log.error('Private Key already exists, use --force to overwrite');
-      program.error('');
-    } else {
+      p.log.error('Private Key already exists, use --force to overwrite')
+      program.error('')
+    }
+    else {
       return false
     }
   }
-  writeFileSync(baseKey, privateKey);
+  writeFileSync(baseKey, privateKey)
 
-  const config = await getConfig();
-  const { extConfig } = config.app;
+  const config = await getConfig()
+  const { extConfig } = config.app
   if (extConfig) {
     if (!extConfig.plugins) {
       extConfig.plugins = {
         extConfig: {},
-        CapacitorUpdater: {}
-      };
+        CapacitorUpdater: {},
+      }
     }
-    extConfig.plugins.CapacitorUpdater.privateKey = privateKey;
+    extConfig.plugins.CapacitorUpdater.privateKey = privateKey
     // console.log('extConfig', extConfig)
     writeConfig(extConfig, config.app.extConfigFilePath)
   }
@@ -112,16 +116,16 @@ export const createKey = async (options: Options, log = true) => {
     p.log.success('This key will be use to encrypt your bundle before sending it to Capgo')
     p.log.success('Keep it safe')
     p.log.success('Than make it unreadable by Capgo and unmodifiable by anyone')
-    p.log.success(`Private key saved in ${config.app.extConfigFilePath}`);
-    p.log.success('Your app will be the only one having it');
-    p.log.success('Only your users can decrypt your update');
-    p.log.success('Only you can send them an update');
-    p.outro(`Done ✅`);
+    p.log.success(`Private key saved in ${config.app.extConfigFilePath}`)
+    p.log.success('Your app will be the only one having it')
+    p.log.success('Only your users can decrypt your update')
+    p.log.success('Only you can send them an update')
+    p.outro(`Done ✅`)
   }
   return true
 }
 
-export const createKeyCommand = async (options: Options) => {
-  await checkLatest();
+export async function createKeyCommand(options: Options) {
+  await checkLatest()
   await createKey(options)
 }

package/src/login.ts

@@ -1,45 +1,46 @@
-import { existsSync, writeFileSync, appendFileSync } from 'node:fs'
+import { appendFileSync, existsSync, writeFileSync } from 'node:fs'
 import { homedir } from 'node:os'
-import { program } from 'commander';
-import * as p from '@clack/prompts';
-import { createSupabaseClient, useLogSnag, verifyUser } from './utils';
-import { checkLatest } from './api/update';
+import process from 'node:process'
+import { program } from 'commander'
+import * as p from '@clack/prompts'
+import { createSupabaseClient, useLogSnag, verifyUser } from './utils'
+import { checkLatest } from './api/update'
 
 interface Options {
-  local: boolean;
+  local: boolean
 }
 
-export const login = async (apikey: string, options: Options, shouldExit = true) => {
+export async function login(apikey: string, options: Options, shouldExit = true) {
+  if (shouldExit)
+    p.intro(`Login to Capgo`)
 
-  if (shouldExit) {
-    p.intro(`Login to Capgo`);
-  }
   if (!apikey) {
     if (shouldExit) {
-      p.log.error('Missing API key, you need to provide a API key to upload your bundle');
-      program.error('');
+      p.log.error('Missing API key, you need to provide a API key to upload your bundle')
+      program.error('')
     }
     return false
   }
-  await checkLatest();
+  await checkLatest()
   // write in file .capgo the apikey in home directory
   try {
-    const { local } = options;
+    const { local } = options
     const snag = useLogSnag()
 
     if (local) {
       if (!existsSync('.git')) {
-        p.log.error('To use local you should be in a git repository');
-        program.error('');
+        p.log.error('To use local you should be in a git repository')
+        program.error('')
       }
-      writeFileSync('.capgo', `${apikey}\n`);
-      appendFileSync('.gitignore', '.capgo\n');
-    } else {
-      const userHomeDir = homedir();
-      writeFileSync(`${userHomeDir}/.capgo`, `${apikey}\n`);
+      writeFileSync('.capgo', `${apikey}\n`)
+      appendFileSync('.gitignore', '.capgo\n')
+    }
+    else {
+      const userHomeDir = homedir()
+      writeFileSync(`${userHomeDir}/.capgo`, `${apikey}\n`)
     }
     const supabase = await createSupabaseClient(apikey)
-    const userId = await verifyUser(supabase, apikey, ['write', 'all', 'upload']);
+    const userId = await verifyUser(supabase, apikey, ['write', 'all', 'upload'])
     await snag.track({
       channel: 'user-login',
       event: 'User CLI login',
@@ -47,18 +48,19 @@ export const login = async (apikey: string, options: Options, shouldExit = true)
       user_id: userId,
       notify: false,
     }).catch()
-    p.log.success(`login saved into .capgo file in ${local ? 'local' : 'home'} directory`);
-  } catch (e) {
-    p.log.error(`Error while saving login`);
-    process.exit(1);
+    p.log.success(`login saved into .capgo file in ${local ? 'local' : 'home'} directory`)
+  }
+  catch (e) {
+    p.log.error(`Error while saving login`)
+    process.exit(1)
   }
   if (shouldExit) {
-    p.outro('Done ✅');
+    p.outro('Done ✅')
     process.exit()
   }
   return true
 }
 
-export const loginCommand = async (apikey: string, options: Options) => {
+export async function loginCommand(apikey: string, options: Options) {
   login(apikey, options, true)
 }

package/src/types/capacitor__cli.d.ts

@@ -1,7 +1,6 @@
 // CapacitorConfig
 
 declare module '@capacitor/cli/dist/config' {
-    export function loadConfig(): CapacitorConfig;
-    export function writeConfig(extConfig: CapacitorConfig, extConfigFilePath: string): void;
+  export function loadConfig(): CapacitorConfig
+  export function writeConfig(extConfig: CapacitorConfig, extConfigFilePath: string): void
 };
-