autho 0.0.8 → 0.0.10

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License Copyright (c) 2024 Nir Adler
+
+Permission is hereby granted, free of
+charge, to any person obtaining a copy of this software and associated
+documentation files (the "Software"), to deal in the Software without
+restriction, including without limitation the rights to use, copy, modify, merge,
+publish, distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to the
+following conditions:
+
+The above copyright notice and this permission notice
+(including the next paragraph) shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO
+EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

package/Readme.md

@@ -33,7 +33,9 @@ This will start the Autho CLI, where you can generate OTPs, manage passwords, an
 
 3. **Managing Passwords**: Autho provides a secure vault for storing and managing your passwords. You can add, view, update, and delete passwords using the CLI interface.
 
-4. **Self-Hosting**: If you prefer self-hosting, deploy Autho on your own server by following the instructions provided in the documentation.
+4. **Secure files**: Autho offers a reliable method for encrypting and decrypting files, ensuring their security and integrity.
+
+5. **Self-Hosting**: If you prefer self-hosting, deploy Autho on your own server by following the instructions provided in the documentation. (TBD)
 
 ## Security Considerations
 
@@ -51,11 +53,11 @@ Autho is an open-source project, and contributions are welcome! Feel free to rep
 
 ## License
 
-Autho is licensed under the [MIT License](link-to-license), allowing for unrestricted use, modification, and distribution.
+Autho is licensed under the [MIT License](LICENSE), allowing for unrestricted use, modification, and distribution.
 
 ## Support
 
-For support or inquiries, please reach out to the [official Autho community](link-to-community) for assistance.
+For support or inquiries, please open an issue for assistance.
 
 ## Acknowledgments
 

package/build/bin.js

@@ -54924,7 +54924,7 @@ var {
 } = import_index.default;
 
 // packages/cli/bin.js
-var import_path = __toESM(require("path"), 1);
+var import_path2 = __toESM(require("path"), 1);
 
 // node_modules/.pnpm/chalk@5.3.0/node_modules/chalk/source/vendor/ansi-styles/index.js
 var ANSI_BACKGROUND_OFFSET = 10;
@@ -57258,6 +57258,8 @@ var createSecretSchema = import_joi.default.object({
 // packages/sdk/cipher.js
 var import_crypto = __toESM(require("crypto"), 1);
 var import_fs = __toESM(require("fs"), 1);
+var import_path = __toESM(require("path"), 1);
+var import_zlib = __toESM(require("zlib"), 1);
 
 // packages/shared/config.js
 var import_dotenv = __toESM(require_main2(), 1);
@@ -57384,6 +57386,84 @@ var Cipher = class _Cipher {
     const decryptedData = _Cipher.decrypt(params);
     import_fs.default.writeFileSync(outputFilePath, decryptedData);
   }
+  static encryptFolder({ inputFolderPath, outputFilePath, encryptionKey, algorithm = config_default.encryptionALgo, encoding = "hex" }) {
+    const outputStream = import_fs.default.createWriteStream(outputFilePath);
+    const gzip = import_zlib.default.createGzip();
+    gzip.pipe(outputStream);
+    const baseFolder = import_path.default.basename(inputFolderPath);
+    function traverseFolder(folderPath) {
+      const items = import_fs.default.readdirSync(folderPath);
+      for (const item of items) {
+        const itemPath = import_path.default.join(baseFolder, import_path.default.relative(inputFolderPath, import_path.default.join(folderPath, item)));
+        if (import_fs.default.statSync(itemPath).isDirectory()) {
+          traverseFolder(itemPath);
+        } else {
+          const fileContent = import_fs.default.readFileSync(itemPath);
+          const params = {
+            value: fileContent,
+            encryptionKey,
+            algorithm,
+            encoding
+          };
+          const encryptedData = _Cipher.encrypt(params);
+          const encrypted = encryptedData.encrypted;
+          delete encryptedData.encrypted;
+          const encryptionMeta = Buffer.from(JSON.stringify(encryptedData)).toString("base64");
+          gzip.write(`${itemPath}
+---
+${encrypted}
+---
+${encryptionMeta}
+:::
+`);
+        }
+      }
+    }
+    traverseFolder(inputFolderPath);
+    gzip.end();
+    return new Promise((resolve, reject) => {
+      outputStream.on("finish", resolve);
+      outputStream.on("error", reject);
+    });
+  }
+  static decryptFolder({ inputFilePath, outputFolderPath, encryptionKey }) {
+    const inputStream = import_fs.default.createReadStream(inputFilePath);
+    const gunzip = import_zlib.default.createGunzip();
+    inputStream.pipe(gunzip);
+    let buff = "";
+    const compileFile = (data) => {
+      buff += data;
+      if (buff.includes(":::")) {
+        const [file, next] = buff.split("\n:::\n");
+        let [filePath, encrypted, encryptionMeta] = file.split("\n---\n");
+        filePath = import_path.default.join(outputFolderPath, filePath);
+        try {
+          import_fs.default.mkdirSync(import_path.default.dirname(filePath), { recursive: true });
+        } catch (error) {
+        }
+        const decoded = Buffer.from(
+          encryptionMeta,
+          "base64"
+        ).toString("utf-8");
+        const metaData = JSON.parse(decoded);
+        const params = {
+          ...metaData,
+          value: encrypted,
+          encryptionKey
+        };
+        const decryptedData = _Cipher.decrypt(params);
+        import_fs.default.writeFileSync(filePath, decryptedData);
+        buff = next;
+      }
+    };
+    gunzip.on("data", (data) => {
+      compileFile(data.toString("utf8"));
+    });
+    return new Promise((resolve, reject) => {
+      gunzip.on("end", resolve);
+      gunzip.on("error", reject);
+    });
+  }
 };
 
 // packages/sdk/secrets.js
@@ -58033,14 +58113,14 @@ var Temp = {
     }
   },
   truncate: (filePath) => {
-    const basename = import_node_path2.default.basename(filePath);
-    if (basename.length <= LIMIT_BASENAME_LENGTH)
+    const basename2 = import_node_path2.default.basename(filePath);
+    if (basename2.length <= LIMIT_BASENAME_LENGTH)
       return filePath;
-    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename);
+    const truncable = /^(\.?)(.*?)((?:\.[^.]+)?(?:\.tmp-\d{10}[a-f0-9]{6})?)$/.exec(basename2);
     if (!truncable)
       return filePath;
-    const truncationLength = basename.length - LIMIT_BASENAME_LENGTH;
-    return `${filePath.slice(0, -basename.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
+    const truncationLength = basename2.length - LIMIT_BASENAME_LENGTH;
+    return `${filePath.slice(0, -basename2.length)}${truncable[1]}${truncable[2].slice(0, -truncationLength)}${truncable[3]}`;
   }
 };
 node_default(Temp.purgeSyncAll);
@@ -59523,10 +59603,22 @@ var Logger = import_baloga.Logger;
 var logger2 = new Logger();
 var program2 = new Command();
 var getAuthoAbsolutePath = (path5) => {
-  if (import_path.default.isAbsolute(path5)) {
-    return import_path.default.join(path5, ".autho");
+  if (import_path2.default.isAbsolute(path5)) {
+    return import_path2.default.join(path5, ".autho");
+  }
+  return import_path2.default.join(process.cwd(), path5, ".autho");
+};
+var toAbsolutePath = (inputPath) => {
+  if (import_path2.default.isAbsolute(inputPath)) {
+    return inputPath;
+  } else {
+    return import_path2.default.join(process.cwd(), inputPath);
   }
-  return import_path.default.join(process.cwd(), path5, ".autho");
+};
+var basename = (filePath) => {
+  const normalizedPath = import_path2.default.normalize(filePath);
+  const folderName = import_path2.default.basename(normalizedPath);
+  return folderName;
 };
 program2.name("autho").description("Secrets manager").version("0.0.1").option("-p, --password <password>", "Master password").option("-ph, --passwordHash <passwordHash>", "Master password hash").option("-n, --name <name>", "Collection name", "default").option(
   "-data, --dataFolder <folderPath>",
@@ -59604,7 +59696,10 @@ program2.name("autho").description("Secrets manager").version("0.0.1").option("-
   }
 });
 program2.command("file").description("Encrypt/Decrypt file").option("-f, --filePath <filePath>", "File path").option("-en, --encrypt", "Encrypt file", false).option("-de, --decrypt", "Decrypt file", false).option("--override", "Override original file", false).action(async (args) => {
-  const { encrypt, decrypt, filePath, override } = args;
+  logger2.debug(`file:`, args);
+  const { encrypt, decrypt, override } = args;
+  let { filePath } = args;
+  filePath = toAbsolutePath(filePath);
   const encryptionKey = await App.masterKey();
   if (!encrypt && !decrypt) {
     console.log("Please provide either --encrypt or --decrypt");
@@ -59624,6 +59719,42 @@ program2.command("file").description("Encrypt/Decrypt file").option("-f, --fileP
   }
   process.exit(0);
 });
+program2.command("files").description("Encrypt/Decrypt file").option("--input <inputPath>", "Folder path").option("--output <outputPath>", "Folder path", process.cwd()).option("-en, --encrypt", "Encrypt folder", false).option("-de, --decrypt", "Decrypt folder", false).action(async (args) => {
+  try {
+    logger2.debug(`files:`, args);
+    const { encrypt, decrypt } = args;
+    let { input, output } = args;
+    input = toAbsolutePath(input);
+    output = toAbsolutePath(output);
+    const folderName = basename(input);
+    const encryptionKey = await App.masterKey();
+    if (!encrypt && !decrypt) {
+      console.log("Please provide either --encrypt or --decrypt");
+      process.exit(1);
+    } else if (encrypt) {
+      console.log("Encrypting files:", input);
+      const outputFilePath = import_path2.default.join(output, folderName + ".gzip.autho");
+      await Cipher.encryptFolder({
+        inputFolderPath: input,
+        outputFilePath,
+        encryptionKey
+      });
+      console.log("Created:", outputFilePath);
+    } else if (decrypt) {
+      console.log("Decrypting files:", input);
+      await Cipher.decryptFolder({
+        inputFilePath: input,
+        outputFolderPath: output,
+        encryptionKey
+      });
+    }
+  } catch (error) {
+    logger2.error("Something went wrong, Error: ", error.message);
+    console.log(error.stack);
+    process.exit(1);
+  }
+  process.exit(0);
+});
 program2.parse();
 /*! Bundled license information:
 

package/package.json

@@ -1,24 +1,11 @@
 {
   "name": "autho",
-  "version": "0.0.8",
+  "version": "0.0.10",
   "main": "build/bin.js",
   "type": "commonjs",
   "bin": {
     "autho": "build/bin.js"
   },
-  "scripts": {
-    "format": "prettier --check .",
-    "format:write": "prettier --write .",
-    "lint": "eslint .",
-    "lint:fix": "eslint --fix .",
-    "build": "esbuild packages/cli/bin.js --bundle --platform=node --target=node18 --outdir=build",
-    "pkg": "npm run pkg:linux && npm run pkg:macos && npm run pkg:win",
-    "pkg:macos-arm64": "pkg build/bin.js --output dist/autho --target node18-macos-arm64",
-    "pkg:macos": "pkg build/bin.js --output dist/autho-macos --target node18-macos-x64",
-    "pkg:linux": "pkg build/bin.js --output dist/autho-linux --target node18-linux-x64",
-    "pkg:win": "pkg build/bin.js --output dist/autho-win --target node18-win-x64",
-    "release": "gh release create v0.0.8 ./dist"
-  },
   "keywords": [
     "secrets",
     "otp"
@@ -49,5 +36,18 @@
       "node18-macos-x64"
     ],
     "outputPath": "dist"
+  },
+  "scripts": {
+    "format": "prettier --check .",
+    "format:write": "prettier --write .",
+    "lint": "eslint .",
+    "lint:fix": "eslint --fix .",
+    "build": "esbuild packages/cli/bin.js --bundle --platform=node --target=node18 --outdir=build",
+    "pkg": "npm run pkg:linux && npm run pkg:macos && npm run pkg:win",
+    "pkg:macos-arm64": "pkg build/bin.js --output dist/autho --target node18-macos-arm64",
+    "pkg:macos": "pkg build/bin.js --output dist/autho-macos --target node18-macos-x64",
+    "pkg:linux": "pkg build/bin.js --output dist/autho-linux --target node18-linux-x64",
+    "pkg:win": "pkg build/bin.js --output dist/autho-win --target node18-win-x64",
+    "release": "gh release create v0.0.8 ./dist/* --title 'v0.0.8' --generate-notes --prerelease"
   }
 }