@capgo/cli 4.0.11 → 4.0.13

package/eslint.config.js

@@ -0,0 +1,3 @@
+const antfu = require('@antfu/eslint-config').default
+
+module.exports = antfu()

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@capgo/cli",
-  "version": "4.0.11",
+  "version": "4.0.13",
   "description": "A CLI to upload to capgo servers",
   "main": "dist/index.js",
   "bin": {
@@ -38,7 +38,7 @@
     "pack": "pkg",
     "types": "npx --yes supabase gen types typescript --project-id=xvwzpoazmxkqosrdewyv > src/types/supabase.types.ts",
     "test_rls": "ts-node ./test/test_headers_rls.ts",
-    "lint": "eslint . --ext .ts --fix"
+    "lint": "eslint \"src/**/*.ts\" --fix"
   },
   "author": "github.com/riderx",
   "license": "Apache 2.0",
@@ -65,6 +65,7 @@
     "semver": "^7.6.0"
   },
   "devDependencies": {
+    "@antfu/eslint-config": "^2.6.4",
     "@types/adm-zip": "0.5.5",
     "@types/mime": "^3.0.4",
     "@types/node": "^20.11.17",

package/src/api/app.ts

@@ -1,56 +1,50 @@
-import { SupabaseClient } from '@supabase/supabase-js';
-import * as p from '@clack/prompts';
-import { program } from 'commander';
-import { Database } from '../types/supabase.types';
-import { isAllowedApp, isAllowedAppOrg, OptionsBase, OrganizationPerm } from '../utils';
+import type { SupabaseClient } from '@supabase/supabase-js'
+import * as p from '@clack/prompts'
+import { program } from 'commander'
+import type { Database } from '../types/supabase.types'
+import type { OptionsBase } from '../utils'
+import { OrganizationPerm, isAllowedApp, isAllowedAppOrg } from '../utils'
 
-export const checkAppExists = async (supabase: SupabaseClient<Database>, appid: string) => {
+export async function checkAppExists(supabase: SupabaseClient<Database>, appid: string) {
   const { data: app } = await supabase
     .rpc('exist_app_v2', { appid })
-    .single();
-  return !!app;
+    .single()
+  return !!app
 }
 
-export const checkAppExistsAndHasPermissionErr = async (supabase: SupabaseClient<Database>, apikey: string, appid: string,
-  shouldExist = true) => {
-  const res = await checkAppExists(supabase, appid);
-  const perm = await isAllowedApp(supabase, apikey, appid);
+export async function checkAppExistsAndHasPermissionErr(supabase: SupabaseClient<Database>, apikey: string, appid: string, shouldExist = true) {
+  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('');
+    p.log.error(`App ${appid} already exist`)
+    program.error('')
   }
   if (!res && shouldExist) {
-    p.log.error(`App ${appid} does not exist`);
-    program.error('');
+    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`);
-    if (appid === 'io.ionic.starter') {
-      p.log.info('Modify your appid in your capacitor.config.json file to something unique, this is a default appid for ionic starter app');
-    }
-    program.error('');
+    p.log.error(`App ${appid} exist and you don't have permission to access it`)
+    if (appid === 'io.ionic.starter')
+      p.log.info('Modify your appid in your capacitor.config.json file to something unique, this is a default appid for ionic starter app')
+
+    program.error('')
   }
 }
 
-export const checkAppExistsAndHasPermissionOrgErr = async (
-  supabase: SupabaseClient<Database>, 
-  apikey: string, 
-  appid: string, 
-  requiredPermission: OrganizationPerm
-) => {
+export async function checkAppExistsAndHasPermissionOrgErr(supabase: SupabaseClient<Database>, apikey: string, appid: string, requiredPermission: OrganizationPerm) {
   const permissions = await isAllowedAppOrg(supabase, apikey, appid)
   if (!permissions.okay) {
-    // eslint-disable-next-line default-case
     switch (permissions.error) {
       case 'INVALID_APIKEY': {
         p.log.error('Invalid apikey, such apikey does not exists!')
-        program.error('');
+        program.error('')
         break
       }
       case 'NO_APP': {
-        p.log.error(`App ${appid} does not exist`);
-        program.error('');
+        p.log.error(`App ${appid} does not exist`)
+        program.error('')
         break
       }
       case 'NO_ORG': {
@@ -65,7 +59,6 @@ export const checkAppExistsAndHasPermissionOrgErr = async (
   const requiredPermNumber = requiredPermission as number
 
   if (requiredPermNumber > remotePermNumber) {
-    // eslint-disable-next-line max-len
     p.log.error(`Insuficcent permissions for app ${appid}. Current permission: ${OrganizationPerm[permissions.data]}, required for this action: ${OrganizationPerm[requiredPermission]}.`)
     program.error('')
   }
@@ -74,9 +67,9 @@ export const checkAppExistsAndHasPermissionOrgErr = async (
 }
 
 export interface Options extends OptionsBase {
-  name?: string;
-  icon?: string;
-  retention?: number;
+  name?: string
+  icon?: string
+  retention?: number
 }
 
-export const newIconPath = "assets/icon.png"
+export const newIconPath = 'assets/icon.png'

package/src/api/channels.ts

@@ -1,12 +1,12 @@
-import { SupabaseClient } from '@supabase/supabase-js';
-import { program } from 'commander';
-import { Table } from 'console-table-printer';
-import * as p from '@clack/prompts';
-import { Database } from '../types/supabase.types';
-import { formatError, getHumanDate } from '../utils';
+import process from 'node:process'
+import type { SupabaseClient } from '@supabase/supabase-js'
+import { program } from 'commander'
+import { Table } from 'console-table-printer'
+import * as p from '@clack/prompts'
+import type { Database } from '../types/supabase.types'
+import { formatError, getHumanDate } from '../utils'
 
-export const checkVersionNotUsedInChannel = async (supabase: SupabaseClient<Database>,
-  appid: string, userId: string, versionData: Database['public']['Tables']['app_versions']['Row']) => {
+export async function checkVersionNotUsedInChannel(supabase: SupabaseClient<Database>, appid: string, userId: string, versionData: Database['public']['Tables']['app_versions']['Row']) {
   const { data: channelFound, error: errorChannel } = await supabase
     .from('channels')
     .select()
@@ -14,20 +14,20 @@ export const checkVersionNotUsedInChannel = async (supabase: SupabaseClient<Data
     .eq('created_by', userId)
     .eq('version', versionData.id)
   if (errorChannel) {
-    p.log.error(`Cannot check Version ${appid}@${versionData.name}`);
-    program.error('');
+    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?' })) {
       // loop on all channels and set version to unknown
       for (const channel of channelFound) {
-        const s = p.spinner();
+        const s = p.spinner()
         s.start(`Unlinking channel ${channel.name}`)
         const { error: errorChannelUpdate } = await supabase
           .from('channels')
           .update({
-            version: (await findUnknownVersion(supabase, appid))?.id
+            version: (await findUnknownVersion(supabase, appid))?.id,
           })
           .eq('id', channel.id)
         if (errorChannelUpdate) {
@@ -38,66 +38,70 @@ export const checkVersionNotUsedInChannel = async (supabase: SupabaseClient<Data
       }
     }
     else {
-      p.log.error(`Unlink it first`);
-      program.error('');
+      p.log.error(`Unlink it first`)
+      program.error('')
     }
     p.outro(`Version unlinked from ${channelFound.length} channel`)
   }
 }
 
-export const findUnknownVersion = (supabase: SupabaseClient<Database>, appId: string) => supabase
-  .from('app_versions')
-  .select('id')
-  .eq('app_id', appId)
-  .eq('name', 'unknown')
-  .throwOnError()
-  .single().then(({ data }) => data)
-
-
-export const createChannel = (supabase: SupabaseClient<Database>, update: Database['public']['Tables']['channels']['Insert']) => supabase
-  .from('channels')
-  .insert(update)
-  .select()
-  .single()
+export function findUnknownVersion(supabase: SupabaseClient<Database>, appId: string) {
+  return supabase
+    .from('app_versions')
+    .select('id')
+    .eq('app_id', appId)
+    .eq('name', 'unknown')
+    .throwOnError()
+    .single().then(({ data }) => data)
+}
 
-export const delChannel = (supabase: SupabaseClient<Database>, name: string, appId: string, userId: string) => supabase
-  .from('channels')
-  .delete()
-  .eq('name', name)
-  .eq('app_id', appId)
-  .eq('created_by', userId)
-  .single()
+export function createChannel(supabase: SupabaseClient<Database>, update: Database['public']['Tables']['channels']['Insert']) {
+  return supabase
+    .from('channels')
+    .insert(update)
+    .select()
+    .single()
+}
 
+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()
+}
 
-export const displayChannels = (data: (Database['public']['Tables']['channels']['Row'] & { keep?: string })[]) => {
+export function displayChannels(data: (Database['public']['Tables']['channels']['Row'] & { keep?: string })[]) {
   const t = new Table({
-    title: "Channels",
-    charLength: { "❌": 2, "✅": 2 },
-  });
+    title: 'Channels',
+    charLength: { '❌': 2, '✅': 2 },
+  })
 
   // add rows with color
-  data.reverse().forEach(row => {
+  data.reverse().forEach((row) => {
     t.addRow({
       Name: row.name,
       Created: getHumanDate(row.created_at),
-      Public: row.public ? '✅' : '❌'
-    });
-  });
+      Public: row.public ? '✅' : '❌',
+    })
+  })
 
-  p.log.success(t.render());
+  p.log.success(t.render())
 }
 
-export const getActiveChannels = async (supabase: SupabaseClient<Database>, appid: string) => {
+export async function getActiveChannels(supabase: SupabaseClient<Database>, appid: string) {
   const { data, error: vError } = await supabase
     .from('channels')
     .select()
     .eq('app_id', appid)
     // .eq('created_by', userId)
-    .order('created_at', { ascending: false });
+    .order('created_at', { ascending: false })
 
   if (vError) {
-    p.log.error(`App ${appid} not found in database`);
-    program.error('');
+    p.log.error(`App ${appid} not found in database`)
+    program.error('')
   }
-  return data;
+  return data
 }

package/src/api/crypto.ts

@@ -1,97 +1,100 @@
-
 import {
-    generateKeyPairSync,
-    constants,
-    publicEncrypt, privateDecrypt,
-    randomBytes, createCipheriv, createDecipheriv
-} from 'node:crypto';
+  constants,
+  createCipheriv,
+  createDecipheriv,
+  generateKeyPairSync,
+  privateDecrypt,
+  publicEncrypt,
+  randomBytes,
+} from 'node:crypto'
+import { Buffer } from 'node:buffer'
 
-const algorithm = "aes-128-cbc";
-const oaepHash = 'sha256';
-const formatB64 = 'base64';
-const padding = constants.RSA_PKCS1_OAEP_PADDING;
+const algorithm = 'aes-128-cbc'
+const oaepHash = 'sha256'
+const formatB64 = 'base64'
+const padding = constants.RSA_PKCS1_OAEP_PADDING
 
-export const decryptSource = (source: Buffer, ivSessionKey: string, privateKey: string): Buffer => {
-    // console.log('\nivSessionKey', ivSessionKey)
-    const [ivB64, sessionb64Encrypted] = ivSessionKey.split(':');
-    // console.log('\nsessionb64Encrypted', sessionb64Encrypted)
-    // console.log('\nivB64', ivB64)
-    const sessionKey = privateDecrypt(
-        {
-            key: privateKey,
-            padding,
-            oaepHash,
-        },
-        Buffer.from(sessionb64Encrypted, formatB64)
-    )
-    // ivB64 to uft-8
-    const initVector = Buffer.from(ivB64, formatB64);
-    // console.log('\nSessionB64', sessionB64)
+export function decryptSource(source: Buffer, ivSessionKey: string, privateKey: string): Buffer {
+  // console.log('\nivSessionKey', ivSessionKey)
+  const [ivB64, sessionb64Encrypted] = ivSessionKey.split(':')
+  // console.log('\nsessionb64Encrypted', sessionb64Encrypted)
+  // console.log('\nivB64', ivB64)
+  const sessionKey = privateDecrypt(
+    {
+      key: privateKey,
+      padding,
+      oaepHash,
+    },
+    Buffer.from(sessionb64Encrypted, formatB64),
+  )
+  // ivB64 to uft-8
+  const initVector = Buffer.from(ivB64, formatB64)
+  // console.log('\nSessionB64', sessionB64)
 
-    const decipher = createDecipheriv(algorithm, sessionKey, initVector);
-    decipher.setAutoPadding(true);
-    const decryptedData = Buffer.concat([decipher.update(source), decipher.final()]);
+  const decipher = createDecipheriv(algorithm, sessionKey, initVector)
+  decipher.setAutoPadding(true)
+  const decryptedData = Buffer.concat([decipher.update(source), decipher.final()])
 
-    return decryptedData
+  return decryptedData
 }
 export interface Encoded {
-    ivSessionKey: string,
-    encryptedData: Buffer
+  ivSessionKey: string
+  encryptedData: Buffer
 }
-export const encryptSource = (source: Buffer, publicKey: string): Encoded => {
-    // encrypt zip with key
-    const initVector = randomBytes(16);
-    const sessionKey = randomBytes(16);
-    // encrypt session key with public key
-    // console.log('\nencrypted.key', encrypted.key.toString(CryptoJS.enc.Base64))
-    const cipher = createCipheriv(algorithm, sessionKey, initVector);
-    cipher.setAutoPadding(true);
-    // console.log('\nsessionKey', sessionKey.toString())
-    // const sessionB64 = sessionKey.toString(formatB64)
-    // console.log('\nsessionB64', sessionB64)
-    const ivB64 = initVector.toString(formatB64);
-    // console.log('\nivB64', ivB64)
-    const sessionb64Encrypted = publicEncrypt(
-        {
-            key: publicKey,
-            padding,
-            oaepHash,
-        },
-        sessionKey
-    ).toString(formatB64)
-    // console.log('\nsessionb64Encrypted', sessionb64Encrypted)
-    const ivSessionKey = `${ivB64}:${sessionb64Encrypted}`
-    // console.log('\nivSessionKey', sessionKey)
-    // encrypted to buffer
+export function encryptSource(source: Buffer, publicKey: string): Encoded {
+  // encrypt zip with key
+  const initVector = randomBytes(16)
+  const sessionKey = randomBytes(16)
+  // encrypt session key with public key
+  // console.log('\nencrypted.key', encrypted.key.toString(CryptoJS.enc.Base64))
+  const cipher = createCipheriv(algorithm, sessionKey, initVector)
+  cipher.setAutoPadding(true)
+  // console.log('\nsessionKey', sessionKey.toString())
+  // const sessionB64 = sessionKey.toString(formatB64)
+  // console.log('\nsessionB64', sessionB64)
+  const ivB64 = initVector.toString(formatB64)
+  // console.log('\nivB64', ivB64)
+  const sessionb64Encrypted = publicEncrypt(
+    {
+      key: publicKey,
+      padding,
+      oaepHash,
+    },
+    sessionKey,
+  ).toString(formatB64)
+  // console.log('\nsessionb64Encrypted', sessionb64Encrypted)
+  const ivSessionKey = `${ivB64}:${sessionb64Encrypted}`
+  // console.log('\nivSessionKey', sessionKey)
+  // encrypted to buffer
 
-    const encryptedData = Buffer.concat([cipher.update(source), cipher.final()]);
+  const encryptedData = Buffer.concat([cipher.update(source), cipher.final()])
 
-    return {
-        encryptedData,
-        ivSessionKey
-    }
+  return {
+    encryptedData,
+    ivSessionKey,
+  }
 }
 export interface RSAKeys {
-    publicKey: string,
-    privateKey: string
+  publicKey: string
+  privateKey: string
 }
-export const createRSA = (): RSAKeys => {
-    const { publicKey, privateKey } = generateKeyPairSync("rsa", {
-        // The standard secure default length for RSA keys is 2048 bits
-        modulusLength: 2048,
-    })
+export function createRSA(): RSAKeys {
+  const { publicKey, privateKey } = generateKeyPairSync('rsa', {
+    // The standard secure default length for RSA keys is 2048 bits
+    modulusLength: 2048,
+  })
 
-    // Generate RSA key pair
-    return {
-        publicKey: publicKey.export({
-            type: "pkcs1",
-            format: "pem",
-        }) as string,
-        privateKey: privateKey.export({
-            type: "pkcs1",
-            format: "pem",
-        }) as string,
-    }
+  // Generate RSA key pair
+  return {
+    publicKey: publicKey.export({
+      type: 'pkcs1',
+      format: 'pem',
+    }) as string,
+    privateKey: privateKey.export({
+      type: 'pkcs1',
+      format: 'pem',
+    }) as string,
+  }
 }
 //  test AES
 

package/src/api/devices_override.ts

@@ -1,27 +1,26 @@
-import { SupabaseClient } from '@supabase/supabase-js';
-import { program } from 'commander';
-import * as p from '@clack/prompts';
-import { Database } from '../types/supabase.types';
-import { formatError } from '../utils';
-
-export const checkVersionNotUsedInDeviceOverride = async (supabase: SupabaseClient<Database>,
-  appid: string, versionData: Database['public']['Tables']['app_versions']['Row']) => {
+import process from 'node:process'
+import type { SupabaseClient } from '@supabase/supabase-js'
+import { program } from 'commander'
+import * as p from '@clack/prompts'
+import type { Database } from '../types/supabase.types'
+import { formatError } from '../utils'
 
+export async function checkVersionNotUsedInDeviceOverride(supabase: SupabaseClient<Database>, appid: string, versionData: Database['public']['Tables']['app_versions']['Row']) {
   const { data: deviceFound, error: errorDevice } = await supabase
     .from('devices_override')
     .select()
     .eq('app_id', appid)
     .eq('version', versionData.id)
   if (errorDevice) {
-    p.log.error(`Cannot check Device override ${appid}@${versionData.name}`);
-    program.error('');
+    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?' })) {
       // loop on all devices and set version to unknown
       for (const device of deviceFound) {
-        const s = p.spinner();
+        const s = p.spinner()
         s.start(`Unlinking device ${device.device_id}`)
         const { error: errorDeviceDel } = await supabase
           .from('devices_override')
@@ -35,8 +34,8 @@ export const checkVersionNotUsedInDeviceOverride = async (supabase: SupabaseClie
       }
     }
     else {
-      p.log.error(`Unlink it first`);
-      program.error('');
+      p.log.error(`Unlink it first`)
+      program.error('')
     }
   }
 }

package/src/api/update.ts

@@ -1,12 +1,12 @@
-import getLatest from "get-latest-version"
-import * as p from '@clack/prompts';
+import getLatest from 'get-latest-version'
+import * as p from '@clack/prompts'
 import pack from '../../package.json'
 
-export const checkLatest = async () => {
-    const latest = await getLatest('@capgo/cli')
-    if (latest !== pack.version) {
-        p.log.warning(`🚨 You are using @capgo/cli@${pack.version} it's not the latest version.
-Please use @capgo/cli@${latest}" or @capgo/cli@latest to keep up to date with the latest features and bug fixes.`
-        )
-    }
-}
+export async function checkLatest() {
+  const latest = await getLatest('@capgo/cli')
+  if (latest !== pack.version) {
+    p.log.warning(`🚨 You are using @capgo/cli@${pack.version} it's not the latest version.
+Please use @capgo/cli@${latest}" or @capgo/cli@latest to keep up to date with the latest features and bug fixes.`,
+    )
+  }
+}