@typinghare/trick 1.0.1 → 1.0.2

package/.trick/encrypted/test/resources/really.json

@@ -0,0 +1 @@
+Salted__�;��a��S�K�9ℑ���2�����4�'Q���\0]�G~G01�߯G���

package/.trick/encrypted/test/resources/task.yml

@@ -0,0 +1 @@
+Salted__�)�"�K7�bk��aQ��ܰ^�B9��������.3.�
g�!g�$�XjM�q�~q�c76C�i����0�S

package/dist/app.d.ts

@@ -1 +1 @@
-export {};
+export declare function resolve_error(err: any): void;

package/dist/app.js

@@ -1,10 +1,10 @@
 import { Command } from 'commander';
-import { getTargetFromConfig, updateConfig } from './config.js';
-import { decryptFiles, encryptFiles } from './encrypt.js';
-import { getSecret } from './secret.js';
+import { getTargetFromConfig, ReadConfigError, 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 fsExtra from 'fs-extra';
-import { resolve_error } from './utility.js';
+import chalk from 'chalk';
 const program = new Command();
 program.version('Trick v1.0.0 \nby James Chen (jameschan312.cn@gmail.com)');
 program.description('Save credential files to remote safely.');
@@ -19,6 +19,7 @@ program
             getTargetFromConfig(config, secretName);
         }
         catch (err) {
+            config.default_secret_name = secretName;
             config.targets.push({
                 secret_name: secretName,
                 files,
@@ -30,12 +31,22 @@ program
         process.exit(1);
     });
 });
+function checkSecretName(secretName, defaultSecretName) {
+    if (!secretName) {
+        secretName = defaultSecretName;
+    }
+    if (!secretName) {
+        throw new Error('No secret name given, and the default secret name is not set.');
+    }
+    return secretName;
+}
 program
     .command('encrypt')
     .description('Encrypt the credential files.')
-    .argument('<secret-name>', 'The name of secret in the environment')
+    .argument('[secret-name]', 'The name of secret in the environment', undefined)
     .action(async (secretName) => {
     await updateConfig((config) => {
+        secretName = checkSecretName(secretName, config.default_secret_name);
         const target = getTargetFromConfig(config, secretName);
         const secret = getSecret(target.secret_name);
         const srcFilePaths = target.files;
@@ -47,9 +58,10 @@ program
 program
     .command('decrypt')
     .description('Decrypt the credential files.')
-    .argument('<secret-name>', 'The name of secret in the environment')
+    .argument('[secret-name]', 'The name of secret in the environment', undefined)
     .action(async (secretName) => {
     await updateConfig((config) => {
+        secretName = checkSecretName(secretName, config.default_secret_name);
         const target = getTargetFromConfig(config, secretName);
         const secret = getSecret(target.secret_name);
         const srcFilePaths = target.files;
@@ -58,8 +70,64 @@ program
         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) => {
+    await updateConfig((config) => {
+        config.default_secret_name = secretName;
+        return false;
+    });
+});
+program
+    .command('get-default')
+    .description('Get the default secret name.')
+    .action(async () => {
+    await updateConfig((config) => {
+        console.log(config.default_secret_name);
+        return false;
+    });
+});
 program.parse();
 process.on('uncaughtException', (err) => {
     resolve_error(err);
     process.exit(1);
 });
+export function resolve_error(err) {
+    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/dist/config.d.ts

@@ -1,6 +1,7 @@
 export declare const CONFIG_FILE_NAME: string;
 export interface Config {
     iteration_count: number;
+    default_secret_name?: string;
     targets: Target[];
 }
 export interface Target {

package/dist/encrypt.d.ts

@@ -1,10 +1,12 @@
 export declare class FailToEncryptFileError extends Error {
     readonly srcFilePath: string;
-    constructor(srcFilePath: string);
+    readonly opensslErrMessage?: string | undefined;
+    constructor(srcFilePath: string, opensslErrMessage?: string | undefined);
 }
 export declare class FailToDecryptFileError extends Error {
     readonly destFilePath: string;
-    constructor(destFilePath: string);
+    readonly opensslErrMessage?: string | undefined;
+    constructor(destFilePath: string, opensslErrMessage?: string | undefined);
 }
 export declare function encryptFile(srcFilePath: string, destFilePath: string, secret: string, iteration_count: number): Promise<void>;
 export declare function decryptFile(srcFilePath: string, destFilePath: string, secret: string, iteration_count: number): Promise<void>;

package/dist/encrypt.js

@@ -3,16 +3,20 @@ import * as path from 'node:path';
 import fsExtra from 'fs-extra';
 export class FailToEncryptFileError extends Error {
     srcFilePath;
-    constructor(srcFilePath) {
+    opensslErrMessage;
+    constructor(srcFilePath, opensslErrMessage) {
         super(`Fail to encrypt source file: ${srcFilePath}`);
         this.srcFilePath = srcFilePath;
+        this.opensslErrMessage = opensslErrMessage;
     }
 }
 export class FailToDecryptFileError extends Error {
     destFilePath;
-    constructor(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) {
@@ -39,7 +43,12 @@ export async function encryptFile(srcFilePath, destFilePath, secret, iteration_c
         await execa(`${command}`, { shell: true });
     }
     catch (err) {
-        throw new FailToEncryptFileError(srcFilePath);
+        if (typeof err == 'object' && err && Object.hasOwn(err, 'stderr')) {
+            throw new FailToEncryptFileError(srcFilePath, err.stderr);
+        }
+        else {
+            throw new FailToDecryptFileError(srcFilePath, "Unknown error when encrypting the file.");
+        }
     }
 }
 export async function decryptFile(srcFilePath, destFilePath, secret, iteration_count) {
@@ -67,7 +76,12 @@ export async function decryptFile(srcFilePath, destFilePath, secret, iteration_c
         await execa(`${command}`, { shell: true });
     }
     catch (err) {
-        throw new FailToDecryptFileError(destFilePath);
+        if (typeof err == 'object' && err && Object.hasOwn(err, 'stderr')) {
+            throw new FailToDecryptFileError(srcFilePath, err['stderr']);
+        }
+        else {
+            throw new FailToDecryptFileError(srcFilePath, "Unknown error when decrypting the file.");
+        }
     }
 }
 export async function encryptFiles(srcFilePaths, destDir, secret, iteration_count) {

package/dist/index.d.ts

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

package/dist/index.js

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

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@typinghare/trick",
   "description": "Save credential files to remote safely.",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -24,6 +24,7 @@
     "@types/fs-extra": "^11.0.4",
     "prettier": "^3.3.3"
   },
+  "packageManager": "pnpm@8.15.1+sha1.8adba2d20330c02d3856e18c4eb3819d1d3ca6aa",
   "scripts": {
     "build": "tsc"
   }

package/src/app.ts

@@ -1,10 +1,22 @@
 import { Command } from 'commander'
-import { getTargetFromConfig, Target, updateConfig } from './config.js'
-import { decryptFiles, encryptFiles } from './encrypt.js'
-import { getSecret } from './secret.js'
+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 fsExtra from 'fs-extra'
-import { resolve_error } from './utility.js'
+import chalk from 'chalk'
 
 const program = new Command()
 
@@ -21,6 +33,7 @@ program
             try {
                 getTargetFromConfig(config, secretName)
             } catch (err) {
+                config.default_secret_name = secretName
                 config.targets.push({
                     secret_name: secretName,
                     files,
@@ -36,12 +49,34 @@ program
         })
     })
 
+function checkSecretName(
+    secretName?: string,
+    defaultSecretName?: string
+): string {
+    if (!secretName) {
+        secretName = defaultSecretName
+    }
+
+    if (!secretName) {
+        throw new Error(
+            'No secret name given, and the default secret name is not set.'
+        )
+    }
+
+    return secretName
+}
+
 program
     .command('encrypt')
     .description('Encrypt the credential files.')
-    .argument('<secret-name>', 'The name of secret in the environment')
-    .action(async (secretName: string): Promise<void> => {
+    .argument(
+        '[secret-name]',
+        'The name of secret in the environment',
+        undefined
+    )
+    .action(async (secretName?: string): 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 srcFilePaths: string[] = target.files
@@ -59,9 +94,14 @@ program
 program
     .command('decrypt')
     .description('Decrypt the credential files.')
-    .argument('<secret-name>', 'The name of secret in the environment')
-    .action(async (secretName: string): Promise<void> => {
+    .argument(
+        '[secret-name]',
+        'The name of secret in the environment',
+        undefined
+    )
+    .action(async (secretName?: string): 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 srcFilePaths: string[] = target.files
@@ -76,9 +116,72 @@ program
         })
     })
 
+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> => {
+        await updateConfig((config) => {
+            config.default_secret_name = secretName
+
+            return false
+        })
+    })
+
+program
+    .command('get-default')
+    .description('Get the default secret name.')
+    .action(async (): Promise<void> => {
+        await updateConfig((config) => {
+            console.log(config.default_secret_name)
+            return false
+        })
+    })
+
 program.parse()
 
 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

@@ -4,6 +4,7 @@ export const CONFIG_FILE_NAME: string = 'trick.config.json'
 
 export interface Config {
     iteration_count: number
+    default_secret_name?: string
     targets: Target[]
 }
 
@@ -17,9 +18,11 @@ const defaultConfig: Config = {
     targets: [],
 }
 
-export class WriteConfigError extends Error {}
+export class WriteConfigError extends Error {
+}
 
-export class ReadConfigError extends Error {}
+export class ReadConfigError extends Error {
+}
 
 export async function writeConfig(config: Config): Promise<void> {
     try {

package/src/encrypt.ts

@@ -1,15 +1,15 @@
-import { execa } from 'execa'
+import {execa} from 'execa'
 import * as path from 'node:path'
 import fsExtra from 'fs-extra'
 
 export class FailToEncryptFileError extends Error {
-    public constructor(public readonly srcFilePath: string) {
+    public constructor(public readonly srcFilePath: string, public readonly opensslErrMessage?: string) {
         super(`Fail to encrypt source file: ${srcFilePath}`)
     }
 }
 
 export class FailToDecryptFileError extends Error {
-    public constructor(public readonly destFilePath: string) {
+    public constructor(public readonly destFilePath: string, public readonly opensslErrMessage?: string) {
         super(`Fail to decrypt destination file: ${destFilePath}`)
     }
 }
@@ -43,9 +43,13 @@ export async function encryptFile(
     await fsExtra.ensureDir(path.dirname(destFilePath))
 
     try {
-        await execa(`${command}`, { shell: true })
+        await execa(`${command}`, {shell: true})
     } catch (err) {
-        throw new FailToEncryptFileError(srcFilePath)
+        if (typeof err == 'object' && err && Object.hasOwn(err, 'stderr')) {
+            throw new FailToEncryptFileError(srcFilePath, (err as { stderr: string }).stderr)
+        } else {
+            throw new FailToDecryptFileError(srcFilePath, "Unknown error when encrypting the file.")
+        }
     }
 }
 
@@ -79,9 +83,13 @@ export async function decryptFile(
     await fsExtra.ensureDir(path.dirname(srcFilePath))
 
     try {
-        await execa(`${command}`, { shell: true })
+        await execa(`${command}`, {shell: true})
     } catch (err) {
-        throw new FailToDecryptFileError(destFilePath)
+        if (typeof err == 'object' && err && Object.hasOwn(err, 'stderr')) {
+            throw new FailToDecryptFileError(srcFilePath, (err as { stderr: string })['stderr'])
+        } else {
+            throw new FailToDecryptFileError(srcFilePath, "Unknown error when decrypting the file.")
+        }
     }
 }
 

package/src/index.ts

@@ -2,5 +2,4 @@ export * from './app.js'
 export * from './config.js'
 export * from './constant.js'
 export * from './encrypt.js'
-export * from './utility.js'
 export * from './secret.js'

package/trick.config.json

@@ -2,11 +2,12 @@
   "iteration_count": 114514,
   "targets": [
     {
-      "secret_name": "TEST_SECRET",
+      "secret_name": "ROBLOX_PROJECT_TRICK_SECRET",
       "files": [
         "test/resources/really.json",
         "test/resources/task.yml"
       ]
     }
-  ]
+  ],
+  "default_secret_name": "ROBLOX_PROJECT_TRICK_SECRET"
 }

package/dist/utility.d.ts

@@ -1 +0,0 @@
-export declare function resolve_error(err: any): void;

package/dist/utility.js

@@ -1,27 +0,0 @@
-import { ReadConfigError, TargetNotFoundError, WriteConfigError, } from './config.js';
-import { FailToDecryptFileError, FailToEncryptFileError } from './encrypt.js';
-import chalk from 'chalk';
-export function resolve_error(err) {
-    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 TargetNotFoundError) {
-        console.error(chalk.red(err.message));
-    }
-    else if (err instanceof FailToEncryptFileError) {
-        console.error(chalk.red(err.message));
-        console.error(chalk.yellow('Make sure the file exists and you have enough permission to access'));
-    }
-    else if (err instanceof FailToDecryptFileError) {
-        console.error(chalk.red(err.message));
-        console.error(chalk.yellow('Make sure the file exists and you have enough permission to access'));
-    }
-    process.exit(1);
-}

package/src/utility.ts

@@ -1,38 +0,0 @@
-import {
-    ReadConfigError,
-    TargetNotFoundError,
-    WriteConfigError,
-} from './config.js'
-import { FailToDecryptFileError, FailToEncryptFileError } from './encrypt.js'
-import chalk from 'chalk'
-
-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 TargetNotFoundError) {
-        console.error(chalk.red(err.message))
-    } else if (err instanceof FailToEncryptFileError) {
-        console.error(chalk.red(err.message))
-        console.error(
-            chalk.yellow(
-                'Make sure the file exists and you have enough permission to access'
-            )
-        )
-    } else if (err instanceof FailToDecryptFileError) {
-        console.error(chalk.red(err.message))
-        console.error(
-            chalk.yellow(
-                'Make sure the file exists and you have enough permission to access'
-            )
-        )
-    }
-
-    process.exit(1)
-}