@typinghare/trick 1.0.7 → 2.0.1

package/dist/encrypt.js

@@ -1,25 +1,25 @@
 import { execa } from 'execa';
 import * as path from 'node:path';
 import fsExtra from 'fs-extra';
-export class FailToEncryptFileError extends Error {
-    srcFilePath;
-    opensslErrMessage;
-    constructor(srcFilePath, opensslErrMessage) {
-        super(`Fail to encrypt source file: ${srcFilePath}`);
-        this.srcFilePath = srcFilePath;
-        this.opensslErrMessage = opensslErrMessage;
-    }
-}
-export class FailToDecryptFileError extends Error {
-    destFilePath;
-    opensslErrMessage;
-    constructor(destFilePath, opensslErrMessage) {
-        super(`Fail to decrypt destination file: ${destFilePath}`);
-        this.destFilePath = destFilePath;
-        this.opensslErrMessage = opensslErrMessage;
-    }
-}
-export async function encryptFile(srcFilePath, destFilePath, secret, iteration_count) {
+import { FailToDecryptFileError, FailToEncryptFileError } from './error.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.
+ *
+ * @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.
+ * @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.
+ */
+export async function encryptFile(srcFilePath, destFilePath, passphrase, iteration_count) {
     if (!(await fsExtra.pathExists(srcFilePath))) {
         throw new FailToEncryptFileError(srcFilePath);
     }
@@ -30,13 +30,13 @@ export async function encryptFile(srcFilePath, destFilePath, secret, iteration_c
         '-salt',
         '-pbkdf2',
         '-iter',
-        iteration_count,
+        Number(iteration_count),
         '-in',
         srcFilePath,
         '-out',
         destFilePath,
         '-pass',
-        `'pass:${secret}'`,
+        `'pass:${passphrase}'`,
     ].join(' ');
     await fsExtra.ensureDir(path.dirname(destFilePath));
     try {
@@ -44,14 +44,32 @@ export async function encryptFile(srcFilePath, destFilePath, secret, iteration_c
     }
     catch (err) {
         if (typeof err == 'object' && err && Object.hasOwn(err, 'stderr')) {
-            throw new FailToEncryptFileError(srcFilePath, err.stderr);
+            const error = err;
+            throw new FailToEncryptFileError(srcFilePath, error.stderr);
         }
         else {
             throw new FailToDecryptFileError(srcFilePath, 'Unknown error when encrypting the file.');
         }
     }
 }
-export async function decryptFile(srcFilePath, destFilePath, secret, iteration_count) {
+/**
+ * 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.
+ *
+ * @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.
+ * @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.
+ */
+export async function decryptFile(srcFilePath, destFilePath, passphrase, iteration_count) {
     if (!(await fsExtra.pathExists(destFilePath))) {
         throw new FailToDecryptFileError(destFilePath);
     }
@@ -63,13 +81,13 @@ export async function decryptFile(srcFilePath, destFilePath, secret, iteration_c
         '-salt',
         '-pbkdf2',
         '-iter',
-        iteration_count,
+        Number(iteration_count),
         '-in',
         destFilePath,
         '-out',
         srcFilePath,
         '-pass',
-        `'pass:${secret}'`,
+        `'pass:${passphrase}'`,
     ].join(' ');
     await fsExtra.ensureDir(path.dirname(srcFilePath));
     try {
@@ -77,24 +95,55 @@ export async function decryptFile(srcFilePath, destFilePath, secret, iteration_c
     }
     catch (err) {
         if (typeof err == 'object' && err && Object.hasOwn(err, 'stderr')) {
-            throw new FailToDecryptFileError(srcFilePath, err['stderr']);
+            const error = err;
+            throw new FailToDecryptFileError(srcFilePath, error.stderr);
         }
         else {
             throw new FailToDecryptFileError(srcFilePath, 'Unknown error when decrypting the file.');
         }
     }
 }
-export async function encryptFiles(srcFilePaths, destDir, secret, iteration_count) {
+/**
+ * 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.
+ *
+ * @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.
+ * @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) {
     for (const srcFilePath of srcFilePaths) {
         const destFilePath = path.join(destDir, srcFilePath + '.enc');
-        await encryptFile(srcFilePath, destFilePath, secret, iteration_count);
+        await encryptFile(srcFilePath, destFilePath, passphrase, iteration_count);
         console.log(`[ENCRYPTED] ${srcFilePath} -> ${destFilePath}`);
     }
 }
-export async function decryptFiles(srcFilePaths, destDir, secret, iteration_count) {
+/**
+ * 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.
+ *
+ * @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.
+ * @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) {
     for (const srcFilePath of srcFilePaths) {
         const destFilePath = path.join(destDir, srcFilePath + '.enc');
-        await decryptFile(srcFilePath, destFilePath, secret, iteration_count);
+        await decryptFile(srcFilePath, destFilePath, passphrase, iteration_count);
         console.log(`[DECRYPTED] ${destFilePath} -> ${srcFilePath}`);
     }
 }

package/dist/error.d.ts

@@ -0,0 +1,30 @@
+export declare class WriteConfigError extends Error {
+    constructor(err: any);
+}
+export declare class ReadConfigError extends Error {
+    constructor(err: any);
+}
+export declare class TargetNotFoundError extends Error {
+    readonly targetName: string;
+    constructor(targetName: string);
+}
+export declare class FailToEncryptFileError extends Error {
+    readonly srcFilePath: string;
+    readonly opensslErrMessage?: string | undefined;
+    constructor(srcFilePath: string, opensslErrMessage?: string | undefined);
+}
+export declare class FailToDecryptFileError extends Error {
+    readonly destFilePath: string;
+    readonly opensslErrMessage?: string | undefined;
+    constructor(destFilePath: string, opensslErrMessage?: string | undefined);
+}
+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;

package/dist/error.js

@@ -0,0 +1,69 @@
+import chalk from 'chalk';
+export class WriteConfigError extends Error {
+    constructor(err) {
+        super(`Fail to write the configuration file. ${err}`);
+    }
+}
+export class ReadConfigError extends Error {
+    constructor(err) {
+        super(`Fail to read the configuration file: ${err}`);
+    }
+}
+export class TargetNotFoundError extends Error {
+    targetName;
+    constructor(targetName) {
+        super(`Target not found: ${targetName}`);
+        this.targetName = targetName;
+    }
+}
+export class FailToEncryptFileError extends Error {
+    srcFilePath;
+    opensslErrMessage;
+    constructor(srcFilePath, opensslErrMessage) {
+        super(`Fail to encrypt source file: ${srcFilePath}`);
+        this.srcFilePath = srcFilePath;
+        this.opensslErrMessage = opensslErrMessage;
+    }
+}
+export class FailToDecryptFileError extends Error {
+    destFilePath;
+    opensslErrMessage;
+    constructor(destFilePath, opensslErrMessage) {
+        super(`Fail to decrypt destination file: ${destFilePath}`);
+        this.destFilePath = destFilePath;
+        this.opensslErrMessage = opensslErrMessage;
+    }
+}
+export class PassphraseFileNotFoundError extends Error {
+    passphraseFilePath;
+    constructor(passphraseFilePath) {
+        super(`Passphrase file not found: ${passphraseFilePath}`);
+        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) {
+    if (!(err instanceof Error)) {
+        console.error(`Unknown error: ${err}`);
+        process.exit(2);
+    }
+    if (err.message) {
+        console.log(chalk.red(err.message));
+    }
+    if (err instanceof FailToEncryptFileError ||
+        err instanceof FailToDecryptFileError) {
+        if (err.opensslErrMessage) {
+            console.error(chalk.red(err.opensslErrMessage));
+        }
+        console.error(chalk.yellow('Make sure the file exists and you have enough permission to access it.'));
+    }
+    process.exit(1);
+}

package/dist/index.d.ts

@@ -1,5 +1,4 @@
 export * from './app.js';
 export * from './config.js';
-export * from './constant.js';
 export * from './encrypt.js';
-export * from './secret.js';
+export * from './passphrase.js';

package/dist/index.js

@@ -1,5 +1,4 @@
 export * from './app.js';
 export * from './config.js';
-export * from './constant.js';
 export * from './encrypt.js';
-export * from './secret.js';
+export * from './passphrase.js';

package/dist/passphrase.d.ts

@@ -0,0 +1,13 @@
+import { Config } from './config.js';
+/**
+ * Retrieves the passphrase from the passphrase file.
+ *
+ * First, gets the passphrase object from the passphrase file path specified in
+ * the configuration object. Second, gets and returns the passphrase associated
+ * with the given target name.
+ *
+ * @param config The configuration to use.
+ * @param targetName The name of the target.
+ * @return The passphrase associated with the target name.
+ */
+export declare function getPassphrase(config: Config, targetName: string): string;

package/dist/passphrase.js

@@ -0,0 +1,26 @@
+import fsExtra from 'fs-extra';
+import { PassphraseFileNotFoundError, PassphraseNotFoundError, } from './error.js';
+import os from 'node:os';
+/**
+ * Retrieves the passphrase from the passphrase file.
+ *
+ * First, gets the passphrase object from the passphrase file path specified in
+ * the configuration object. Second, gets and returns the passphrase associated
+ * with the given target name.
+ *
+ * @param config The configuration to use.
+ * @param targetName The name of the target.
+ * @return The passphrase associated with the target name.
+ */
+export function getPassphrase(config, targetName) {
+    const passphraseFilePath = config.passphrase_file_path.replaceAll(/~/g, os.homedir());
+    if (!fsExtra.existsSync(passphraseFilePath)) {
+        throw new PassphraseFileNotFoundError(passphraseFilePath);
+    }
+    const passphraseObject = fsExtra.readJsonSync(passphraseFilePath);
+    const passphrase = passphraseObject[targetName] || null;
+    if (passphrase === null) {
+        throw new PassphraseNotFoundError(passphraseFilePath, targetName);
+    }
+    return passphrase;
+}

package/eslint.config.js

@@ -0,0 +1,41 @@
+import pluginJsonc from 'eslint-plugin-jsonc';
+import jsoncParser from 'jsonc-eslint-parser';
+
+export default [
+  {
+    files: ['**/*.json'],
+    languageOptions: {
+      parser: jsoncParser
+    },
+    plugins: {
+      jsonc: pluginJsonc
+    },
+    rules: {
+      'jsonc/indent': ['error', 4],
+      'jsonc/key-spacing': ['error', { beforeColon: false, afterColon: true }],
+      'jsonc/comma-dangle': ['error', 'never'],
+      'jsonc/object-curly-spacing': ['error', 'always'] },
+    },
+    {
+    files: ['**/*.ts', '**/*.tsx'],
+    languageOptions: {
+      parser: tsParser,
+      parserOptions: {
+        project: ['./tsconfig.json'],
+        sourceType: 'module',
+        ecmaVersion: 'latest'
+      }
+    },
+    plugins: {
+      '@typescript-eslint': tsPlugin
+    },
+    rules: {
+      '@typescript-eslint/no-unused-vars': ['warn'],
+      '@typescript-eslint/no-explicit-any': ['warn'],
+      '@typescript-eslint/explicit-function-return-type': ['off'],
+      semi: ['error', 'always'],
+      quotes: ['error', 'single']
+    }
+  }
+];
+

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@typinghare/trick",
-  "description": "Save credential files to remote safely.",
-  "version": "1.0.7",
+  "description": "Save credential files to remote safely and easily.",
+  "version": "2.0.1",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -15,15 +15,18 @@
   "homepage": "https://github.com/typinghare/trick",
   "license": "MIT",
   "dependencies": {
-    "chalk": "^5.3.0",
-    "commander": "^12.1.0",
-    "execa": "^9.3.0",
-    "fs-extra": "^11.2.0"
+    "chalk": "^5.4.1",
+    "commander": "^14.0.0",
+    "execa": "^9.5.3",
+    "fs-extra": "^11.3.0"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
-    "prettier": "^3.3.3",
-    "typescript": "^5.8.2"
+    "eslint": "^9.27.0",
+    "eslint-plugin-jsonc": "^2.20.1",
+    "jsonc-eslint-parser": "^2.4.0",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3"
   },
   "prettier": {
     "trailingComma": "es5",