@typinghare/trick 2.0.0 → 2.1.0

package/dist/index.d.ts

@@ -1,4 +1,7 @@
 export * from './app.js';
+export * from './color.js';
 export * from './config.js';
+export * from './console.js';
 export * from './encrypt.js';
+export * from './error.js';
 export * from './passphrase.js';

package/dist/index.js

@@ -1,4 +1,7 @@
 export * from './app.js';
+export * from './color.js';
 export * from './config.js';
+export * from './console.js';
 export * from './encrypt.js';
+export * from './error.js';
 export * from './passphrase.js';

package/dist/passphrase.d.ts

@@ -1,10 +1,18 @@
 import { Config } from './config.js';
+/**
+ * Gets the passphrase directory from the configuration.
+ *
+ * This function replaces any tilde (`~`) in the directory path with the user's home directory.
+ *
+ * @param config The configuration to use.
+ * @return The resolved passphrase directory path.
+ */
+export declare function getPassphraseDirectory(config: Config): string;
 /**
  * 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.
+ * The passphrase file is located in the directory specified by `config.passphraseDirectory`
+ * and is named after the `targetName`.
  *
  * @param config The configuration to use.
  * @param targetName The name of the target.

package/dist/passphrase.js

@@ -1,26 +1,32 @@
 import fsExtra from 'fs-extra';
-import { PassphraseFileNotFoundError, PassphraseNotFoundError, } from './error.js';
+import { PassphraseFileNotFoundError } from './error.js';
 import os from 'node:os';
+import path from 'node:path';
+/**
+ * Gets the passphrase directory from the configuration.
+ *
+ * This function replaces any tilde (`~`) in the directory path with the user's home directory.
+ *
+ * @param config The configuration to use.
+ * @return The resolved passphrase directory path.
+ */
+export function getPassphraseDirectory(config) {
+    return config.passphraseDirectory.replaceAll(/~/g, os.homedir());
+}
 /**
  * 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.
+ * The passphrase file is located in the directory specified by `config.passphraseDirectory`
+ * and is named after the `targetName`.
  *
  * @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());
+    const passphraseFilePath = path.join(getPassphraseDirectory(config), targetName);
     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;
+    return fsExtra.readFileSync(passphraseFilePath, 'utf-8').trim();
 }

package/env.sh

@@ -0,0 +1 @@
+PATH="$PWD/bin:$PATH"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@typinghare/trick",
   "description": "Save credential files to remote safely and easily.",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "type": "module",
@@ -15,26 +15,26 @@
   "homepage": "https://github.com/typinghare/trick",
   "license": "MIT",
   "dependencies": {
-    "chalk": "^5.4.1",
-    "commander": "^14.0.0",
-    "execa": "^9.5.3",
-    "fs-extra": "^11.3.0"
+    "chalk": "^5.6.2",
+    "commander": "^14.0.2",
+    "execa": "^9.6.1",
+    "fs-extra": "^11.3.3"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
-    "eslint": "^9.27.0",
-    "eslint-plugin-jsonc": "^2.20.1",
-    "jsonc-eslint-parser": "^2.4.0",
-    "prettier": "^3.5.3",
-    "typescript": "^5.8.3"
+    "eslint": "^9.39.2",
+    "eslint-plugin-jsonc": "^2.21.0",
+    "jsonc-eslint-parser": "^2.4.2",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3"
   },
   "prettier": {
     "trailingComma": "es5",
-    "tabWidth": 4,
+    "tabWidth": 2,
     "semi": false,
     "singleQuote": true,
     "endOfLine": "lf",
-    "printWidth": 80
+    "printWidth": 100
   },
   "scripts": {
     "build": "node_modules/typescript/bin/tsc"

package/src/app.ts

@@ -1,188 +1,265 @@
 import { Command } from 'commander'
-import { Config, getTargetFromConfig, Target, updateConfig } from './config.js'
+import {
+  CONFIG_FILE_NAME,
+  getRootDirectory,
+  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'
+import { getPassphrase, getPassphraseDirectory } from './passphrase.js'
+import { resolveError } from './error.js'
+import path from 'path'
+import { colorFilePath, colorTargetName } from './color.js'
+import { success, warning } from './console.js'
 
 const program = new Command()
-program.version('2.0.0')
+program.version('2.1.0')
 program.description('Save credential files to remote safely and easily.')
 
 program
-    .command('add')
-    .description('Add files to a target.')
-    .argument('<name>', '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, targetName)
-                target.files.push(...files)
-            } catch (err) {
-                config.default_target_name = targetName
-                config.targets[targetName] = { files }
-            }
-
-            return true
-        })
+  .command('config')
+  .description('Display the current configuration.')
+  .action(function (): void {
+    updateConfig((config) => {
+      console.log(JSON.stringify(config, null, 2))
     })
+  })
 
 program
-    .command('remove')
-    .description('Remove files from a target.')
-    .argument('<name>', 'The name of the target')
-    .argument('[files...]', 'Files to remove')
-    .option('-t, --target', 'Remove the target instead.')
-    .action(
-        async (
-            targetName: string,
-            files: string[],
-            options: {
-                target: boolean
-            }
-        ): Promise<void> => {
-            if (options.target) {
-                // Remove the target
-                return await updateConfig((config) => {
-                    getTargetFromConfig(config, targetName)
-                    delete config.targets[targetName]
-                    console.log(`[SUCCESS] Removed target: ${targetName}`)
-
-                    return true
-                })
-            }
-
-            // Remove files from the target
-            await updateConfig((config) => {
-                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)
-                    }
-                }
-
-                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
-            })
+  .command('init')
+  .description('Initialize the configuration file.')
+  .option('-r, --root', 'Create the configuration file in the root directory.', false)
+  .action(function (options: { root: boolean }): void {
+    const configFilePath = options.root
+      ? path.join(getRootDirectory(), CONFIG_FILE_NAME)
+      : path.join(process.cwd(), CONFIG_FILE_NAME)
+
+    if (fsExtra.existsSync(configFilePath)) {
+      console.log(warning(`Configuration file already exists: ${configFilePath}`))
+      return
+    } else {
+      updateConfig(() => true, options.root)
+      console.log(success(`Initialized configuration file: ${configFilePath}`))
+    }
+  })
+
+program
+  .command('add')
+  .description('Add files to a target.')
+  .argument('<target>', 'The name of the target to add to')
+  .argument('[files...]', 'Files that are added to the target')
+  .action(function (targetName: string, files: string[]): void {
+    updateConfig((config) => {
+      const target = config.targets[targetName]
+      if (!target) {
+        config.targets[targetName] = { files }
+        console.log(success(`Added files to target: ${targetName}`))
+      } else {
+        for (const file of files) {
+          if (target.files.includes(file)) {
+            console.log(warning(`File already exists in the target: ${file}`))
+          } else {
+            target.files.push(file)
+            console.log(success(`Added file to target: ${file}`))
+          }
         }
-    )
-
-function getTargetName(
-    targetNameOrNull: string | null,
-    defaultTargetName: Config['default_target_name']
-): string {
-    const targetName: string | null =
-        targetNameOrNull === null ? defaultTargetName : targetNameOrNull
-
-    if (targetName === null) {
-        throw new Error(
-            'Target is not specified and the default target name is null!'
-        )
+      }
+
+      return true
+    })
+  })
+
+program
+  .command('remove')
+  .description('Remove files from a target.')
+  .argument('<target>', 'The name of the target to remove from')
+  .argument('[files...]', 'Files to remove from the target')
+  .option('-t, --target', 'Remove the target instead.')
+  .action(function (
+    targetName: string,
+    files: string[],
+    options: {
+      target: boolean
     }
+  ): void {
+    if (options.target) {
+      // Remove the target
+      return updateConfig((config) => {
+        getTargetFromConfig(config, targetName)
+        delete config.targets[targetName]
+        console.log(`[SUCCESS] Removed target: ${targetName}`)
 
-    return targetName
-}
+        return true
+      })
+    }
+
+    // Remove files from the target
+    updateConfig((config) => {
+      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)
+        }
+      }
+
+      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
+    })
+  })
 
 program
-    .command('encrypt')
-    .description('Encrypt the credential files.')
-    .argument('[target]', 'The name of the target', null)
-    .action(async (targetNameOrNull: string | null): Promise<void> => {
-        await updateConfig((config) => {
-            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(config.root_directory)
-            encryptFiles(
-                srcFilePaths,
-                config.root_directory,
-                passphrase,
-                config.encryption.iteration_count
-            )
-        })
+  .command('encrypt')
+  .description('Encrypt the credential files.')
+  .argument('[targetNames...]', 'The names of targets')
+  .action(function (targetNames: string[]): void {
+    updateConfig((config) => {
+      if (targetNames.length === 0) {
+        targetNames.push(...config.defaultTargetNames)
+      }
+
+      if (targetNames.length === 0) {
+        console.log(warning('No target names specified and no default targets set.'))
+        return
+      }
+
+      const rootDirectory = getRootDirectory()
+      const trickRootDirectory = path.resolve(rootDirectory, config.trickRootDirectory)
+      for (const targetName of targetNames) {
+        const target: Target = getTargetFromConfig(config, targetName)
+        const passphrase: string = getPassphrase(config, targetName)
+        const srcFilePaths: string[] = target.files
+
+        fsExtra.ensureDir(trickRootDirectory)
+        encryptFiles(srcFilePaths, trickRootDirectory, passphrase, config.encryption.iterationCount)
+      }
+    })
+  })
+
+program
+  .command('decrypt')
+  .description('Decrypt the credential files.')
+  .argument('[targetNames...]', 'The names of the targets')
+  .action(function (targetNames: string[]): void {
+    updateConfig((config) => {
+      if (targetNames.length === 0) {
+        targetNames.push(...config.defaultTargetNames)
+      }
+
+      if (targetNames.length === 0) {
+        console.log(warning('No target names specified and no default targets set.'))
+        return
+      }
+
+      const rootDirectory = getRootDirectory()
+      const trickRootDirectory = path.resolve(rootDirectory, config.trickRootDirectory)
+      for (const targetName of targetNames) {
+        const target: Target = getTargetFromConfig(config, targetName)
+        const passphrase: string = getPassphrase(config, targetName)
+        const srcFilePaths: string[] = target.files
+
+        fsExtra.ensureDir(trickRootDirectory)
+        decryptFiles(srcFilePaths, trickRootDirectory, passphrase, config.encryption.iterationCount)
+      }
     })
+  })
 
 program
-    .command('decrypt')
-    .description('Decrypt the credential files.')
-    .argument('[target]', 'The name of the target', null)
-    .action(async (targetNameOrNull: string | null): Promise<void> => {
-        await updateConfig((config) => {
-            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(config.root_directory)
-            decryptFiles(
-                srcFilePaths,
-                config.root_directory,
-                passphrase,
-                config.encryption.iteration_count
-            )
-        })
+  .command('add-default')
+  .description('Add default target names.')
+  .argument('[targetNames...]', 'The names of targets to add')
+  .action(function (targetNames: string[]): void {
+    updateConfig((config) => {
+      let addedAny = false
+      for (const targetName of targetNames) {
+        if (!config.targets[targetName]) {
+          console.log(warning(`Target not found: ${targetName}`))
+          continue
+        }
+
+        if (config.defaultTargetNames.includes(targetName)) {
+          console.log(warning(`Target name already in default list: ${targetName}`))
+          continue
+        }
+
+        config.defaultTargetNames.push(targetName)
+        console.log(success(`Added default target name: ${targetName}`))
+        addedAny = true
+      }
+
+      return addedAny
     })
+  })
 
 program
-    .command('set-default')
-    .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_target_name = targetName
-            return true
-        })
+  .command('list-defaults')
+  .description('Display  the default target name.')
+  .action(function (): void {
+    updateConfig((config) => {
+      for (const targetName of config.defaultTargetNames) {
+        console.log(colorTargetName(targetName))
+      }
     })
+  })
 
 program
-    .command('get-default')
-    .description('Get the default target name.')
-    .action(async (): Promise<void> => {
-        await updateConfig((config) => {
-            console.log(config.default_target_name)
-        })
+  .command('list')
+  .description('Display a list of targets.')
+  .action(function (): void {
+    updateConfig((config) => {
+      for (const [targetName, target] of Object.entries(config.targets)) {
+        console.log(colorTargetName(targetName))
+        for (const file of target.files) {
+          console.log('    ' + colorFilePath(file))
+        }
+      }
     })
+  })
 
 program
-    .command('list')
-    .description('Display a list of targets.')
-    .action(async (): Promise<void> => {
-        await updateConfig((config) => {
-            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))
-                }
-            }
-        })
+  .command('set-passphrase')
+  .description('Set passphrase for a target.')
+  .argument('<target>', 'The name of the target to set passphrase for')
+  .action(function (targetName: string): void {
+    updateConfig((config) => {
+      const passphraseDirectory = getPassphraseDirectory(config)
+      if (!fsExtra.existsSync(passphraseDirectory)) {
+        fsExtra.ensureDirSync(passphraseDirectory)
+        console.log(success(`Created passphrase directory: ${passphraseDirectory}`))
+      }
+
+      const passphraseFile = path.join(passphraseDirectory, targetName)
+      if (!fsExtra.existsSync(passphraseFile)) {
+        fsExtra.createFileSync(passphraseFile)
+        fsExtra.chmodSync(passphraseFile, 0o600)
+        console.log(success(`Created passphrase file: ${passphraseFile}`))
+        console.log(success(`You have to edit the file to set the passphrase.`))
+      } else {
+        console.log(warning(`Passphrase file already exists: ${passphraseFile}`))
+      }
     })
+  })
 
-program.parse()
+try {
+  program.parse()
+} catch (err) {
+  resolveError(err)
+  process.exit(1)
+}
 
 process.on('uncaughtException', (err) => {
-    resolve_error(err)
-    process.exit(1)
+  resolveError(err)
+  process.exit(1)
 })

package/src/color.ts

@@ -0,0 +1,9 @@
+import chalk from 'chalk'
+
+export function colorTargetName(targetName: string): string {
+  return chalk.cyan(targetName)
+}
+
+export function colorFilePath(filePath: string): string {
+  return chalk.yellow(filePath)
+}