@typinghare/trick 2.0.1 → 2.1.0

package/dist/config.d.ts

@@ -3,21 +3,26 @@
  */
 export declare const CONFIG_FILE_NAME: string;
 /**
- * Config type.
+ * A list of root markers.
+ */
+export declare const ROOT_MARKERS: string[];
+/**
+ * Represents Trick configuration 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 trickRootDirectory The name of the Trick root directory under the project root.
+ * @property passphraseDirectory The path to the passphrase directory.
+ * @property defaultTargetNames A list of default target names. If no target name is specified
+ *   when running Trick commands, these target names will be used.
  * @property encryption Encryption configuration.
  */
 export interface Config {
     targets: {
         [name: string]: Target;
     };
-    default_target_name: string | null;
-    root_directory: string;
-    passphrase_file_path: string;
+    trickRootDirectory: string;
+    passphraseDirectory: string;
+    defaultTargetNames: string[];
     encryption: Encryption;
 }
 /**
@@ -31,44 +36,58 @@ export interface Target {
 /**
  * Encryption configuration.
  *
- * @property iteration_count The number of iteration.
+ * @property iterationCount The number of iteration.
  */
 export interface Encryption {
-    iteration_count: number;
+    iterationCount: number;
 }
+/**
+ * Recursively searches for the root directory of a project based on specified root markers.
+ *
+ * @param directory - The current directory to check. Defaults to the current working directory.
+ * @returns The path to the root directory.
+ * @throws {RootDirectoryNotFoundError} If the root directory cannot be found.
+ */
+export declare function getRootDirectory(directory?: string | null): string;
+/**
+ * Gets the full path to the configuration file based on the root directory.
+ *
+ * @return The full path to the configuration file.
+ * @throws {RootDirectoryNotFoundError} If the root directory cannot be found.
+ */
+export declare function getConfigFilePath(): string;
 /**
  * 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.
+ * @param createInRoot Whether to create the configuration file in the root directory if it
+ *   doesn't exist. Defaults to false.
+ * @throws {WriteConfigError} If error occurs when writing to the configuration file.
  */
-export declare function writeConfig(config: Config): Promise<void>;
+export declare function writeConfig(config: Config, createInRoot?: boolean): void;
 /**
  * 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.
+ * @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 declare function readConfig(): Promise<Config | null>;
+export declare function readConfig(): Config | null;
 /**
  * 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.
+ * 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.
  *
- * 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.
  *
- * @param callback The callback function taking the configuraition object
- *                 retrieved from the configuration file.
  * @see DEFAULT_CONFIG
  */
-export declare function updateConfig(callback: (Config: Config) => boolean | void): Promise<void>;
+export declare function updateConfig(callback: (Config: Config) => boolean | void, createInRoot?: boolean): void;
 /**
  * Gets a target object from a specified configuration object.
  *

package/dist/config.js

@@ -1,31 +1,75 @@
 import fsExtra from 'fs-extra';
-import { ReadConfigError, TargetNotFoundError, WriteConfigError, } from './error.js';
+import { ReadConfigError, TargetNotFoundError, WriteConfigError, RootDirectoryNotFoundError, } from './error.js';
+import { join, resolve } from 'path';
 /**
  * The name of the configuration file to look for in the root directory.
  */
 export const CONFIG_FILE_NAME = 'trick.config.json';
+/**
+ * A list of root markers.
+ */
+export const ROOT_MARKERS = ['.git', CONFIG_FILE_NAME];
 /**
  * Default configuration.
  */
 const DEFAULT_CONFIG = {
     targets: {},
-    default_target_name: null,
-    root_directory: '.trick',
-    passphrase_file_path: '~/.config/trick_passphrase.json',
+    trickRootDirectory: '.trick',
+    passphraseDirectory: '~/.config/trick/passphrases',
+    defaultTargetNames: [],
     encryption: {
-        iteration_count: 100_000,
+        iterationCount: 100_000,
     },
 };
+/**
+ * Recursively searches for the root directory of a project based on specified root markers.
+ *
+ * @param directory - The current directory to check. Defaults to the current working directory.
+ * @returns The path to the root directory.
+ * @throws {RootDirectoryNotFoundError} If the root directory cannot be found.
+ */
+export function getRootDirectory(directory = null) {
+    if (!directory) {
+        return getRootDirectory(process.cwd());
+    }
+    if (directory === '/') {
+        throw new RootDirectoryNotFoundError();
+    }
+    for (const marker of ROOT_MARKERS) {
+        if (fsExtra.existsSync(join(directory, marker))) {
+            return directory;
+        }
+    }
+    return getRootDirectory(resolve(join(directory, '..')));
+}
+/**
+ * Gets the full path to the configuration file based on the root directory.
+ *
+ * @return The full path to the configuration file.
+ * @throws {RootDirectoryNotFoundError} If the root directory cannot be found.
+ */
+export function getConfigFilePath() {
+    return resolve(getRootDirectory() + '/' + CONFIG_FILE_NAME);
+}
 /**
  * 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.
+ * @param createInRoot Whether to create the configuration file in the root directory if it
+ *   doesn't exist. Defaults to false.
+ * @throws {WriteConfigError} If error occurs when writing to the configuration file.
  */
-export async function writeConfig(config) {
+export function writeConfig(config, createInRoot = true) {
     try {
-        await fsExtra.writeFile(CONFIG_FILE_NAME, JSON.stringify(config, null, 2));
+        if (createInRoot) {
+            const configFilePath = join(getRootDirectory(), CONFIG_FILE_NAME);
+            fsExtra.writeFileSync(configFilePath, JSON.stringify(config, null, 2));
+        }
+        else {
+            // Always create in the current working directory
+            const configFilePath = join(process.cwd(), CONFIG_FILE_NAME);
+            fsExtra.writeFileSync(configFilePath, JSON.stringify(config, null, 2));
+        }
     }
     catch (err) {
         throw new WriteConfigError(err);
@@ -34,17 +78,17 @@ export async function writeConfig(config) {
 /**
  * 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.
+ * @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() {
-    if (!fsExtra.existsSync(CONFIG_FILE_NAME)) {
+export function readConfig() {
+    const configFilePath = getConfigFilePath();
+    if (!fsExtra.existsSync(configFilePath)) {
         return null;
     }
     try {
-        return (await fsExtra.readJSON(CONFIG_FILE_NAME));
+        return fsExtra.readJSONSync(configFilePath);
     }
     catch (err) {
         throw new ReadConfigError(err);
@@ -53,23 +97,20 @@ export async function readConfig() {
 /**
  * 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.
+ * 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.
  *
- * 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.
  *
- * @param callback The callback function taking the configuraition object
- *                 retrieved from the configuration file.
  * @see DEFAULT_CONFIG
  */
-export async function updateConfig(callback) {
-    const config = (await readConfig()) || DEFAULT_CONFIG;
-    if (callback(config)) {
-        await writeConfig(config);
-    }
+export function updateConfig(callback, createInRoot = true) {
+    const config = readConfig() || DEFAULT_CONFIG;
+    Boolean(callback(config)) && writeConfig(config, createInRoot);
 }
 /**
  * Gets a target object from a specified configuration object.

package/dist/console.d.ts

@@ -0,0 +1,3 @@
+export declare function success(message: string): string;
+export declare function warning(message: string): string;
+export declare function error(message: string): string;

package/dist/console.js

@@ -0,0 +1,9 @@
+export function success(message) {
+    return `🟩 ${message}`;
+}
+export function warning(message) {
+    return `🟨 ${message}`;
+}
+export function error(message) {
+    return `🟥 ${message}`;
+}

package/dist/encrypt.d.ts

@@ -1,68 +1,60 @@
 /**
  * Encrypts a file using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * This function checks whether the source file exists, constructs an OpenSSL
- * command, ensures the destination directory exists, and then executes the
- * encryption command.
+ * This function checks whether the source file exists, constructs an OpenSSL command, ensures the
+ * destination directory exists, and then executes the encryption command.
  *
  * @param srcFilePath The path to the source file that needs to be encrypted.
  * @param destFilePath The path where the encrypted file will be saved.
  * @param passphrase The passphrase used for encryption.
- * @param iteration_count The number of iterations to use for PBKDF2.
+ * @param iterationCount The number of iterations to use for PBKDF2.
  * @returns Resolves when the file is successfully encrypted.
- * @throws {FailToEncryptFileError} If the source file does not exist or if
- *         OpenSSL returns an error during encryption.
- * @throws {FailToDecryptFileError} If an unknown error occurs during
- *         encryption.
+ * @throws {FailToEncryptFileError} If the source file does not exist or if OpenSSL returns an error
+ *   during encryption.
+ * @throws {FailToDecryptFileError} If an unknown error occurs during encryption.
  */
-export declare function encryptFile(srcFilePath: string, destFilePath: string, passphrase: string, iteration_count: number): Promise<void>;
+export declare function encryptFile(srcFilePath: string, destFilePath: string, passphrase: string, iterationCount: number): Promise<void>;
 /**
  * Decrypts a file using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * This function checks whether the encrypted file exists, constructs an OpenSSL
- * decryption command, ensures the destination directory exists, and then
- * executes the decryption command.
+ * This function checks whether the encrypted file exists, constructs an OpenSSL decryption command,
+ * ensures the destination directory exists, and then executes the decryption command.
  *
  * @param srcFilePath The path where the decrypted file will be saved.
  * @param destFilePath The path to the encrypted source file.
  * @param passphrase The passphrase used for decryption.
- * @param iteration_count The number of iterations used for PBKDF2.
+ * @param iterationCount The number of iterations used for PBKDF2.
  * @returns Resolves when the file is successfully decrypted.
- * @throws {FailToDecryptFileError} If the encrypted file does not exist or if
- *         OpenSSL returns an error during decryption.
- * @throws {FailToDecryptFileError} If an unknown error occurs during
- *         decryption.
+ * @throws {FailToDecryptFileError} If the encrypted file does not exist or if OpenSSL returns an
+ *   error during decryption.
+ * @throws {FailToDecryptFileError} If an unknown error occurs during decryption.
  */
-export declare function decryptFile(srcFilePath: string, destFilePath: string, passphrase: string, iteration_count: number): Promise<void>;
+export declare function decryptFile(srcFilePath: string, destFilePath: string, passphrase: string, iterationCount: number): Promise<void>;
 /**
- * Encrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key
- * derivation.
+ * Encrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * For each source file path provided, this function constructs the destination
- * file path by appending `.enc`, then calls `encryptFile` and logs the
- * operation.
+ * For each source file path provided, this function constructs the destination file path by
+ * appending `.enc`, then calls `encryptFile` and logs the operation.
  *
  * @param srcFilePaths An array of file paths to be encrypted.
  * @param destDir The directory where the encrypted files will be saved.
  * @param passphrase The passphrase used for encryption.
- * @param iteration_count The number of iterations to use for PBKDF2.
+ * @param iterationCount The number of iterations to use for PBKDF2.
  * @returns Resolves when all files are successfully encrypted.
  * @throws {FailToEncryptFileError} If any file fails to encrypt.
  */
-export declare function encryptFiles(srcFilePaths: string[], destDir: string, passphrase: string, iteration_count: number): Promise<void>;
+export declare function encryptFiles(srcFilePaths: string[], destDir: string, passphrase: string, iterationCount: number): Promise<void>;
 /**
- * Decrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key
- * derivation.
+ * Decrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * For each source file path provided, this function assumes the corresponding
- * encrypted file has the `.enc` extension and calls `decryptFile`, logging the
- * operation.
+ * For each source file path provided, this function assumes the corresponding encrypted file has
+ * the `.enc` extension and calls `decryptFile`, logging the operation.
  *
  * @param srcFilePaths An array of original file paths that were encrypted.
  * @param destDir The directory containing the encrypted files.
  * @param passphrase The passphrase used for decryption.
- * @param iteration_count The number of iterations used for PBKDF2.
+ * @param iterationCount The number of iterations used for PBKDF2.
  * @returns Resolves when all files are successfully decrypted.
  * @throws {FailToDecryptFileError} If any file fails to decrypt.
  */
-export declare function decryptFiles(srcFilePaths: string[], destDir: string, passphrase: string, iteration_count: number): Promise<void>;
+export declare function decryptFiles(srcFilePaths: string[], destDir: string, passphrase: string, iterationCount: number): Promise<void>;

package/dist/encrypt.js

@@ -2,24 +2,23 @@ import { execa } from 'execa';
 import * as path from 'node:path';
 import fsExtra from 'fs-extra';
 import { FailToDecryptFileError, FailToEncryptFileError } from './error.js';
+import { success } from './console.js';
 /**
  * Encrypts a file using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * This function checks whether the source file exists, constructs an OpenSSL
- * command, ensures the destination directory exists, and then executes the
- * encryption command.
+ * This function checks whether the source file exists, constructs an OpenSSL command, ensures the
+ * destination directory exists, and then executes the encryption command.
  *
  * @param srcFilePath The path to the source file that needs to be encrypted.
  * @param destFilePath The path where the encrypted file will be saved.
  * @param passphrase The passphrase used for encryption.
- * @param iteration_count The number of iterations to use for PBKDF2.
+ * @param iterationCount The number of iterations to use for PBKDF2.
  * @returns Resolves when the file is successfully encrypted.
- * @throws {FailToEncryptFileError} If the source file does not exist or if
- *         OpenSSL returns an error during encryption.
- * @throws {FailToDecryptFileError} If an unknown error occurs during
- *         encryption.
+ * @throws {FailToEncryptFileError} If the source file does not exist or if OpenSSL returns an error
+ *   during encryption.
+ * @throws {FailToDecryptFileError} If an unknown error occurs during encryption.
  */
-export async function encryptFile(srcFilePath, destFilePath, passphrase, iteration_count) {
+export async function encryptFile(srcFilePath, destFilePath, passphrase, iterationCount) {
     if (!(await fsExtra.pathExists(srcFilePath))) {
         throw new FailToEncryptFileError(srcFilePath);
     }
@@ -30,7 +29,7 @@ export async function encryptFile(srcFilePath, destFilePath, passphrase, iterati
         '-salt',
         '-pbkdf2',
         '-iter',
-        Number(iteration_count),
+        Number(iterationCount),
         '-in',
         srcFilePath,
         '-out',
@@ -55,21 +54,19 @@ export async function encryptFile(srcFilePath, destFilePath, passphrase, iterati
 /**
  * Decrypts a file using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * This function checks whether the encrypted file exists, constructs an OpenSSL
- * decryption command, ensures the destination directory exists, and then
- * executes the decryption command.
+ * This function checks whether the encrypted file exists, constructs an OpenSSL decryption command,
+ * ensures the destination directory exists, and then executes the decryption command.
  *
  * @param srcFilePath The path where the decrypted file will be saved.
  * @param destFilePath The path to the encrypted source file.
  * @param passphrase The passphrase used for decryption.
- * @param iteration_count The number of iterations used for PBKDF2.
+ * @param iterationCount The number of iterations used for PBKDF2.
  * @returns Resolves when the file is successfully decrypted.
- * @throws {FailToDecryptFileError} If the encrypted file does not exist or if
- *         OpenSSL returns an error during decryption.
- * @throws {FailToDecryptFileError} If an unknown error occurs during
- *         decryption.
+ * @throws {FailToDecryptFileError} If the encrypted file does not exist or if OpenSSL returns an
+ *   error during decryption.
+ * @throws {FailToDecryptFileError} If an unknown error occurs during decryption.
  */
-export async function decryptFile(srcFilePath, destFilePath, passphrase, iteration_count) {
+export async function decryptFile(srcFilePath, destFilePath, passphrase, iterationCount) {
     if (!(await fsExtra.pathExists(destFilePath))) {
         throw new FailToDecryptFileError(destFilePath);
     }
@@ -81,7 +78,7 @@ export async function decryptFile(srcFilePath, destFilePath, passphrase, iterati
         '-salt',
         '-pbkdf2',
         '-iter',
-        Number(iteration_count),
+        Number(iterationCount),
         '-in',
         destFilePath,
         '-out',
@@ -104,46 +101,42 @@ export async function decryptFile(srcFilePath, destFilePath, passphrase, iterati
     }
 }
 /**
- * Encrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key
- * derivation.
+ * Encrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * For each source file path provided, this function constructs the destination
- * file path by appending `.enc`, then calls `encryptFile` and logs the
- * operation.
+ * For each source file path provided, this function constructs the destination file path by
+ * appending `.enc`, then calls `encryptFile` and logs the operation.
  *
  * @param srcFilePaths An array of file paths to be encrypted.
  * @param destDir The directory where the encrypted files will be saved.
  * @param passphrase The passphrase used for encryption.
- * @param iteration_count The number of iterations to use for PBKDF2.
+ * @param iterationCount The number of iterations to use for PBKDF2.
  * @returns Resolves when all files are successfully encrypted.
  * @throws {FailToEncryptFileError} If any file fails to encrypt.
  */
-export async function encryptFiles(srcFilePaths, destDir, passphrase, iteration_count) {
+export async function encryptFiles(srcFilePaths, destDir, passphrase, iterationCount) {
     for (const srcFilePath of srcFilePaths) {
         const destFilePath = path.join(destDir, srcFilePath + '.enc');
-        await encryptFile(srcFilePath, destFilePath, passphrase, iteration_count);
-        console.log(`[ENCRYPTED] ${srcFilePath} -> ${destFilePath}`);
+        await encryptFile(srcFilePath, destFilePath, passphrase, iterationCount);
+        console.log(success(`Encrypted: ${srcFilePath} -> ${destFilePath}`));
     }
 }
 /**
- * Decrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key
- * derivation.
+ * Decrypts multiple files using OpenSSL with AES-256-CBC and PBKDF2 key derivation.
  *
- * For each source file path provided, this function assumes the corresponding
- * encrypted file has the `.enc` extension and calls `decryptFile`, logging the
- * operation.
+ * For each source file path provided, this function assumes the corresponding encrypted file has
+ * the `.enc` extension and calls `decryptFile`, logging the operation.
  *
  * @param srcFilePaths An array of original file paths that were encrypted.
  * @param destDir The directory containing the encrypted files.
  * @param passphrase The passphrase used for decryption.
- * @param iteration_count The number of iterations used for PBKDF2.
+ * @param iterationCount The number of iterations used for PBKDF2.
  * @returns Resolves when all files are successfully decrypted.
  * @throws {FailToDecryptFileError} If any file fails to decrypt.
  */
-export async function decryptFiles(srcFilePaths, destDir, passphrase, iteration_count) {
+export async function decryptFiles(srcFilePaths, destDir, passphrase, iterationCount) {
     for (const srcFilePath of srcFilePaths) {
         const destFilePath = path.join(destDir, srcFilePath + '.enc');
-        await decryptFile(srcFilePath, destFilePath, passphrase, iteration_count);
-        console.log(`[DECRYPTED] ${destFilePath} -> ${srcFilePath}`);
+        await decryptFile(srcFilePath, destFilePath, passphrase, iterationCount);
+        console.log(success(`Decrypted: ${destFilePath} -> ${srcFilePath}`));
     }
 }

package/dist/error.d.ts

@@ -1,30 +1,49 @@
+/**
+ * Thrown when the root directory is not found.
+ */
+export declare class RootDirectoryNotFoundError extends Error {
+    constructor();
+}
+/**
+ * Thrown when fail to write the configuration file.
+ */
 export declare class WriteConfigError extends Error {
     constructor(err: any);
 }
+/**
+ * Thrown when fail to read the configuration file.
+ */
 export declare class ReadConfigError extends Error {
     constructor(err: any);
 }
+/**
+ * Thrown when the specified target is not found in the configuration.
+ */
 export declare class TargetNotFoundError extends Error {
     readonly targetName: string;
     constructor(targetName: string);
 }
+/**
+ * Thrown when fail to encrypt the source file.
+ */
 export declare class FailToEncryptFileError extends Error {
     readonly srcFilePath: string;
     readonly opensslErrMessage?: string | undefined;
     constructor(srcFilePath: string, opensslErrMessage?: string | undefined);
 }
+/**
+ * Thrown when fail to decrypt the source file.
+ */
 export declare class FailToDecryptFileError extends Error {
     readonly destFilePath: string;
     readonly opensslErrMessage?: string | undefined;
     constructor(destFilePath: string, opensslErrMessage?: string | undefined);
 }
+/**
+ * Thrown when the passphrase file is not found.
+ */
 export declare class PassphraseFileNotFoundError extends Error {
     readonly passphraseFilePath: string;
     constructor(passphraseFilePath: string);
 }
-export declare class PassphraseNotFoundError extends Error {
-    readonly passphraseFilePath: string;
-    readonly targetName: string;
-    constructor(passphraseFilePath: string, targetName: string);
-}
-export declare function resolve_error(err: any): void;
+export declare function resolveError(err: any): void;

package/dist/error.js

@@ -1,14 +1,31 @@
-import chalk from 'chalk';
+import { error, warning } from './console.js';
+/**
+ * Thrown when the root directory is not found.
+ */
+export class RootDirectoryNotFoundError extends Error {
+    constructor() {
+        super('Root directory not found');
+    }
+}
+/**
+ * Thrown when fail to write the configuration file.
+ */
 export class WriteConfigError extends Error {
     constructor(err) {
         super(`Fail to write the configuration file. ${err}`);
     }
 }
+/**
+ * Thrown when fail to read the configuration file.
+ */
 export class ReadConfigError extends Error {
     constructor(err) {
         super(`Fail to read the configuration file: ${err}`);
     }
 }
+/**
+ * Thrown when the specified target is not found in the configuration.
+ */
 export class TargetNotFoundError extends Error {
     targetName;
     constructor(targetName) {
@@ -16,6 +33,9 @@ export class TargetNotFoundError extends Error {
         this.targetName = targetName;
     }
 }
+/**
+ * Thrown when fail to encrypt the source file.
+ */
 export class FailToEncryptFileError extends Error {
     srcFilePath;
     opensslErrMessage;
@@ -25,6 +45,9 @@ export class FailToEncryptFileError extends Error {
         this.opensslErrMessage = opensslErrMessage;
     }
 }
+/**
+ * Thrown when fail to decrypt the source file.
+ */
 export class FailToDecryptFileError extends Error {
     destFilePath;
     opensslErrMessage;
@@ -34,6 +57,9 @@ export class FailToDecryptFileError extends Error {
         this.opensslErrMessage = opensslErrMessage;
     }
 }
+/**
+ * Thrown when the passphrase file is not found.
+ */
 export class PassphraseFileNotFoundError extends Error {
     passphraseFilePath;
     constructor(passphraseFilePath) {
@@ -41,29 +67,22 @@ export class PassphraseFileNotFoundError extends Error {
         this.passphraseFilePath = passphraseFilePath;
     }
 }
-export class PassphraseNotFoundError extends Error {
-    passphraseFilePath;
-    targetName;
-    constructor(passphraseFilePath, targetName) {
-        super(`Passphrase for target ${targetName} is not found in the passphrase file: ${passphraseFilePath}`);
-        this.passphraseFilePath = passphraseFilePath;
-        this.targetName = targetName;
-    }
-}
-export function resolve_error(err) {
+export function resolveError(err) {
     if (!(err instanceof Error)) {
-        console.error(`Unknown error: ${err}`);
+        console.error(error(`Unknown error: ${err}`));
         process.exit(2);
     }
     if (err.message) {
-        console.log(chalk.red(err.message));
+        console.error(error(err.message));
+    }
+    if (err instanceof PassphraseFileNotFoundError) {
+        console.error(warning(`Use the "set-passphrase" command to set the passphrase file.`));
     }
-    if (err instanceof FailToEncryptFileError ||
-        err instanceof FailToDecryptFileError) {
+    if (err instanceof FailToEncryptFileError || err instanceof FailToDecryptFileError) {
         if (err.opensslErrMessage) {
-            console.error(chalk.red(err.opensslErrMessage));
+            console.error(error(err.opensslErrMessage));
         }
-        console.error(chalk.yellow('Make sure the file exists and you have enough permission to access it.'));
+        console.error(warning('Make sure the file exists and you have enough permission to access it.'));
     }
     process.exit(1);
 }