@typinghare/trick 1.0.7 → 2.0.1

package/src/app.ts

@@ -1,107 +1,82 @@
 import { Command } from 'commander'
-import {
-    getTargetFromConfig,
-    ReadConfigError,
-    Target,
-    TargetNotFoundError,
-    updateConfig,
-    WriteConfigError,
-} from './config.js'
-import {
-    decryptFiles,
-    encryptFiles,
-    FailToDecryptFileError,
-    FailToEncryptFileError,
-} from './encrypt.js'
-import { getSecret, SecretNotFoundError } from './secret.js'
-import { TRICK_ENCRYPTED_DIR } from './constant.js'
+import { Config, getTargetFromConfig, Target, updateConfig } from './config.js'
+import { decryptFiles, encryptFiles } from './encrypt.js'
 import fsExtra from 'fs-extra'
 import chalk from 'chalk'
+import { getPassphrase } from './passphrase.js'
+import { resolve_error } from './error.js'
 
 const program = new Command()
-
-program.version('1.0.7')
-program.description('Save credential files to remote safely.')
+program.version('2.0.1')
+program.description('Save credential files to remote safely and easily.')
 
 program
     .command('add')
-    .description('Add a target or add files to an existing target.')
-    .argument('<secret-name>', 'The name of secret in the environment')
-    .argument('[files...]', 'Files this target will encrypt')
-    .action(async (secretName: string, files: string[]): Promise<void> => {
+    .description('Add files to a target.')
+    .argument('<target>', 'The name of the target')
+    .argument('[files...]', 'Files that are encrypted')
+    .action(async (targetName: string, files: string[]): Promise<void> => {
         await updateConfig((config) => {
             try {
-                const target = getTargetFromConfig(config, secretName)
+                const target = getTargetFromConfig(config, targetName)
                 target.files.push(...files)
-
-                return true
             } catch (err) {
-                config.default_secret_name = secretName
-                config.targets.push({ secret_name: secretName, files })
-
-                return true
+                config.default_target_name = targetName
+                config.targets[targetName] = { files }
             }
+
+            return true
         })
     })
 
 program
     .command('remove')
-    .description('Remove files from a specific target.')
-    .argument('<secret-name>', 'The name of secret in the environment.')
-    .argument('[files...]', 'Files to remove.')
+    .description('Remove files from a target.')
+    .argument('<target>', 'The name of the target')
+    .argument('[files...]', 'Files to remove')
     .option('-t, --target', 'Remove the target instead.')
     .action(
         async (
-            secretName: string,
+            targetName: string,
             files: string[],
             options: {
                 target: boolean
             }
         ): Promise<void> => {
             if (options.target) {
-                await updateConfig((config) => {
-                    const index: number = config.targets.findIndex(
-                        (target) => target.secret_name === secretName
-                    )
-
-                    if (index == -1) {
-                        console.log(
-                            chalk.yellow(
-                                `[WARNING] Target not found: ${secretName}`
-                            )
-                        )
-
-                        return false
-                    }
-
-                    config.targets.splice(index, 1)
-                    console.log(`[SUCCESS] Removed target: ${secretName}`)
+                // Remove the target
+                return await updateConfig((config) => {
+                    getTargetFromConfig(config, targetName)
+                    delete config.targets[targetName]
+                    console.log(`[SUCCESS] Removed target: ${targetName}`)
 
                     return true
                 })
-                return
             }
 
+            // Remove files from the target
             await updateConfig((config) => {
-                try {
-                    const target = getTargetFromConfig(config, secretName)
-                    const target_files = target.files
-                    for (const file of files) {
-                        const index = target_files.indexOf(file)
-                        if (index != -1) {
-                            target_files.splice(index, 1)
-                            console.log(`[SUCCESS] Removed file: ${file}`)
-                            continue
-                        }
-
-                        console.log(
-                            chalk.yellow(
-                                `[WARNING] File does not exist in the target: ${file}`
-                            )
-                        )
+                const target = getTargetFromConfig(config, targetName)
+                const removedFiles: string[] = []
+                const remainingFiles: string[] = []
+                for (const file of target.files) {
+                    if (files.includes(file)) {
+                        removedFiles.push(file)
+                        console.log(`[SUCCESS] Removed file: ${file}`)
+                    } else {
+                        remainingFiles.push(file)
                     }
-                } catch (err: unknown) {
-                    config.default_secret_name = secretName
+                }
+
+                target.files = remainingFiles
+                const notFoundFiles = files.filter(
+                    (it) => !removedFiles.includes(it)
+                )
+
+                for (const notFoundFile of notFoundFiles) {
+                    console.log(
+                        `[WARNING] File not found in the target: ${notFoundFile}`
+                    )
                 }
 
                 return true
@@ -109,92 +84,85 @@ program
         }
     )
 
-function checkSecretName(
-    secretName?: string,
-    defaultSecretName?: string
+function getTargetName(
+    targetNameOrNull: string | null,
+    defaultTargetName: Config['default_target_name']
 ): string {
-    if (!secretName) {
-        secretName = defaultSecretName
-    }
+    const targetName: string | null =
+        targetNameOrNull === null ? defaultTargetName : targetNameOrNull
 
-    if (!secretName) {
+    if (targetName === null) {
         throw new Error(
-            'No secret name given, and the default secret name is not set.'
+            'Target is not specified and the default target name is null!'
         )
     }
 
-    return secretName
+    return targetName
 }
 
 program
     .command('encrypt')
     .description('Encrypt the credential files.')
-    .argument(
-        '[secret-name]',
-        'The name of secret in the environment',
-        undefined
-    )
-    .action(async (secretName?: string): Promise<void> => {
+    .argument('[target]', 'The name of the target', null)
+    .action(async (targetNameOrNull: string | null): Promise<void> => {
         await updateConfig((config) => {
-            secretName = checkSecretName(secretName, config.default_secret_name)
-            const target: Target = getTargetFromConfig(config, secretName)
-            const secret: string = getSecret(target.secret_name)
+            const targetName: string = getTargetName(
+                targetNameOrNull,
+                config.default_target_name
+            )
+            const target: Target = getTargetFromConfig(config, targetName)
+            const passphrase: string = getPassphrase(config, targetName)
             const srcFilePaths: string[] = target.files
-            fsExtra.ensureDir(TRICK_ENCRYPTED_DIR)
+            fsExtra.ensureDir(config.root_directory)
             encryptFiles(
                 srcFilePaths,
-                TRICK_ENCRYPTED_DIR,
-                secret,
-                config.iteration_count
+                config.root_directory,
+                passphrase,
+                config.encryption.iteration_count
             )
-            return false
         })
     })
 
 program
     .command('decrypt')
     .description('Decrypt the credential files.')
-    .argument(
-        '[secret-name]',
-        'The name of secret in the environment',
-        undefined
-    )
-    .action(async (secretName?: string): Promise<void> => {
+    .argument('[target]', 'The name of the target', null)
+    .action(async (targetNameOrNull: string | null): Promise<void> => {
         await updateConfig((config) => {
-            secretName = checkSecretName(secretName, config.default_secret_name)
-            const target: Target = getTargetFromConfig(config, secretName)
-            const secret: string = getSecret(target.secret_name)
+            const targetName: string = getTargetName(
+                targetNameOrNull,
+                config.default_target_name
+            )
+            const target: Target = getTargetFromConfig(config, targetName)
+            const passphrase: string = getPassphrase(config, targetName)
             const srcFilePaths: string[] = target.files
-            fsExtra.ensureDir(TRICK_ENCRYPTED_DIR)
+            fsExtra.ensureDir(config.root_directory)
             decryptFiles(
                 srcFilePaths,
-                TRICK_ENCRYPTED_DIR,
-                secret,
-                config.iteration_count
+                config.root_directory,
+                passphrase,
+                config.encryption.iteration_count
             )
-            return false
         })
     })
 
 program
     .command('set-default')
-    .description('Set the default secret name.')
-    .argument('<secret-name>', 'The name of secret in the environment')
-    .action(async (secretName: string): Promise<void> => {
+    .description('Set the default target name.')
+    .argument('<target>', 'The name of the target to set')
+    .action(async (targetName: string): Promise<void> => {
         await updateConfig((config) => {
-            config.default_secret_name = secretName
-
+            config.default_target_name = targetName
             return true
         })
     })
 
 program
     .command('get-default')
-    .description('Get the default secret name.')
+    .description('Get the default target name.')
     .action(async (): Promise<void> => {
         await updateConfig((config) => {
-            console.log(config.default_secret_name)
-            return false
+            console.log(config.default_target_name)
         })
     })
 
@@ -203,14 +171,12 @@ program
     .description('Display a list of targets.')
     .action(async (): Promise<void> => {
         await updateConfig((config) => {
-            for (const target of config.targets) {
-                console.log(chalk.cyan(target.secret_name))
+            for (const [targetName, target] of Object.entries(config.targets)) {
+                console.log(chalk.cyan(targetName))
                 for (const file of target.files) {
                     console.log('    ' + chalk.yellow(file))
                 }
             }
-
-            return false
         })
     })
 
@@ -220,44 +186,3 @@ process.on('uncaughtException', (err) => {
     resolve_error(err)
     process.exit(1)
 })
-
-export function resolve_error(err: any): void {
-    if (!(err instanceof Error)) {
-        console.error(`Unknown error: ${err}`)
-        process.exit(2)
-    }
-
-    if (err instanceof WriteConfigError) {
-        console.error(chalk.red('Fail to write Trick config file'))
-    } else if (err instanceof ReadConfigError) {
-        console.error(chalk.red('Fail to read Trick config file'))
-    } else if (err instanceof SecretNotFoundError) {
-        console.error(chalk.red(err.message))
-    } else if (err instanceof TargetNotFoundError) {
-        console.error(chalk.red(err.message))
-    } else if (err instanceof FailToEncryptFileError) {
-        console.error(chalk.red(err.message))
-        if (err.opensslErrMessage) {
-            console.error(chalk.red(err.opensslErrMessage))
-        } else {
-            console.error(
-                chalk.yellow(
-                    'Make sure the file exists and you have enough permission to access it'
-                )
-            )
-        }
-    } else if (err instanceof FailToDecryptFileError) {
-        console.error(chalk.red(err.message))
-        if (err.opensslErrMessage) {
-            console.error(chalk.red(err.opensslErrMessage))
-        } else {
-            console.error(
-                chalk.yellow(
-                    'Make sure the file exists and you have enough permission to access it'
-                )
-            )
-        }
-    }
-
-    process.exit(1)
-}

package/src/config.ts

@@ -1,27 +1,70 @@
 import fsExtra from 'fs-extra'
+import {
+    ReadConfigError,
+    TargetNotFoundError,
+    WriteConfigError,
+} from './error.js'
 
+/**
+ * The name of the configuration file to look for in the root directory.
+ */
 export const CONFIG_FILE_NAME: string = 'trick.config.json'
 
+/**
+ * Config type.
+ *
+ * @property targets Mapping from target names to target objects.
+ * @property default_target_name The name of the default target.
+ * @property root_directory The root directory.
+ * @property passphrase_file_path The path to the passphrase file.
+ * @property encryption Encryption configuration.
+ */
 export interface Config {
-    iteration_count: number
-    default_secret_name?: string
-    targets: Target[]
+    targets: { [name: string]: Target }
+    default_target_name: string | null
+    root_directory: string
+    passphrase_file_path: string
+    encryption: Encryption
 }
 
+/**
+ * Target type.
+ *
+ * @property files A list of files to encrypt/decrypt.
+ */
 export interface Target {
-    secret_name: string
     files: string[]
 }
 
-const defaultConfig: Config = {
-    iteration_count: 114514,
-    targets: [],
+/**
+ * Encryption configuration.
+ *
+ * @property iteration_count The number of iteration.
+ */
+export interface Encryption {
+    iteration_count: number
 }
 
-export class WriteConfigError extends Error {}
-
-export class ReadConfigError extends Error {}
+/**
+ * Default configuration.
+ */
+const DEFAULT_CONFIG: Config = {
+    targets: {},
+    default_target_name: null,
+    root_directory: '.trick',
+    passphrase_file_path: '~/.config/trick_passphrase.json',
+    encryption: {
+        iteration_count: 100_000,
+    },
+}
 
+/**
+ * Writes a configuration object to the configuration file.
+ *
+ * @param config The configuration to write.
+ * @throws {WriteConfigError} If error occurs when writing to the configuration
+ *         file.
+ */
 export async function writeConfig(config: Config): Promise<void> {
     try {
         await fsExtra.writeFile(
@@ -29,10 +72,18 @@ export async function writeConfig(config: Config): Promise<void> {
             JSON.stringify(config, null, 2)
         )
     } catch (err) {
-        throw new WriteConfigError()
+        throw new WriteConfigError(err)
     }
 }
 
+/**
+ * Retrieves the configuration object from the configuration file.
+ *
+ * @return The configuration object retrieved from the configuration object;
+ *         null if the configuration file doesn't exist.
+ * @throws {ReadConfigError} If error occurs when reading the configuration
+ *         file.
+ */
 export async function readConfig(): Promise<Config | null> {
     if (!fsExtra.existsSync(CONFIG_FILE_NAME)) {
         return null
@@ -41,37 +92,50 @@ export async function readConfig(): Promise<Config | null> {
     try {
         return (await fsExtra.readJSON(CONFIG_FILE_NAME)) as Config
     } catch (err) {
-        throw new ReadConfigError()
+        throw new ReadConfigError(err)
     }
 }
 
+/**
+ * Updates the configuration object.
+ *
+ * This function first retrieves the configuration object fromthe configuration
+ * file. If the configuration file doesn't exist, the default configuration will
+ * be used instead.
+ *
+ * Then it calls the callback function by passing on the configuration object.
+ * If the callback function returns `true`, then the object will be written to
+ * the configuration file.
+ *
+ * @param callback The callback function taking the configuraition object
+ *                 retrieved from the configuration file.
+ * @see DEFAULT_CONFIG
+ */
 export async function updateConfig(
-    callback: UpdateConfigCallback
+    callback: (Config: Config) => boolean | void
 ): Promise<void> {
-    const config: Config = (await readConfig()) || defaultConfig
+    const config: Config = (await readConfig()) || DEFAULT_CONFIG
     if (callback(config)) {
         await writeConfig(config)
     }
 }
 
-export type UpdateConfigCallback = (config: Config) => boolean
-
-export class TargetNotFoundError extends Error {
-    public constructor(public readonly secretName: string) {
-        super(`Target not found: ${secretName}`)
-    }
-}
-
+/**
+ * Gets a target object from a specified configuration object.
+ *
+ * @param config The configuration object to get the target from.
+ * @param targetName The name of the target to get.
+ * @return The target object associated with the given name.
+ * @throws {TargetNotFoundError} If the target object is not found.
+ */
 export function getTargetFromConfig(
     config: Config,
-    secretName: string
+    targetName: string
 ): Target {
-    const targets = config.targets
-    for (const target of targets) {
-        if (target.secret_name === secretName) {
-            return target
-        }
+    const target = config.targets[targetName]
+    if (!target) {
+        throw new TargetNotFoundError(targetName)
     }
 
-    throw new TargetNotFoundError(secretName)
+    return target
 }