cloudron 5.14.10 → 5.15.0

package/bin/cloudron

@@ -56,6 +56,7 @@ backupCommand.command('decrypt <infile> <outfile>')
 backupCommand.command('decrypt-dir <indir> <outdir>')
     .description('Decrypt an encrypted directory')
     .option('--password <password>', 'password')
+    .option('--no-decrypt-filenames', 'Decrypt filenames [false]')
     .action(backupTools.decryptDir);
 
 backupCommand.command('decrypt-filename <path>')
@@ -111,7 +112,7 @@ envCommand.command('list')
     .action(actions.envList);
 
 envCommand.command('set <KEY=value...>')
-    .description('Set environment variables')
+    .description('Set environment variables. e.g X=1 Y=2')
     .option('--app <id>', 'App id')
     .action(actions.envSet);
 
@@ -173,6 +174,7 @@ program.command('install')
     .option('--no-sso', 'Disable Cloudron SSO [false]')
     .option('--debug [cmd...]', 'Enable debug mode', false)
     .option('--readonly', 'Mount filesystem readonly. Default is read/write in debug mode.')
+    .option('--env <KEY=value...>', 'Set environment variables. e.g X=1 Y=2')
     .action(actions.install);
 
 program.command('list')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cloudron",
-  "version": "5.14.10",
+  "version": "5.15.0",
   "license": "MIT",
   "description": "Cloudron Commandline Tool",
   "main": "main.js",

package/src/actions.js

@@ -643,6 +643,16 @@ async function install(localOptions, cmd) {
 
         for (const port in ports) console.log(`Port ${port}: ${ports[port]}`);
 
+        // environment variables
+        const env = {};
+        if (options.env) {
+            options.env.forEach(envVar => {
+                const m = envVar.match(/(.*?)=(.*)/);
+                if (!m) return exit(`Expecting KEY=VALUE pattern. Got ${envVar}`);
+                env[m[1]] = m[2];
+            });
+        }
+
         const memoryLimit = options.memoryLimit ? parseMemoryLimit(options.memoryLimit) : 0;
 
         const data = {
@@ -655,7 +665,8 @@ async function install(localOptions, cmd) {
             aliasDomains,
             ports,
             accessRestriction: null,
-            memoryLimit
+            memoryLimit,
+            env
         };
 
         // the sso only applies for apps which allow optional sso

package/src/backup-tools.js

@@ -262,11 +262,13 @@ async function decryptDir(inDir, outDir, options) {
     }
 
     const encryption = aesKeysFromPassword(options.password);
+    const decryptFilenames = options.decryptFilenames;
 
     const inDirAbs = path.resolve(process.cwd(), inDir);
     const outDirAbs = path.resolve(process.cwd(), outDir);
 
     const tbd = [ '' ]; // only has paths relative to inDirAbs
+    let errorCount = 0;
     while (true) {
         const cur = tbd.pop();
         const entries = fs.readdirSync(path.join(inDirAbs, cur), { withFileTypes: true });
@@ -279,29 +281,41 @@ async function decryptDir(inDir, outDir, options) {
                 continue;
             }
 
-            const encryptedFilePath = path.join(cur, entry.name);
-
-            const { error, decryptedFilePath } = decryptFilePath(encryptedFilePath, encryption);
-            if (error) throw error;
+            const fullPath = path.join(cur, entry.name);
+
+            let destPath = fullPath;
+            if (decryptFilenames) {
+                const { error, decryptedFilePath } = decryptFilePath(fullPath, encryption);
+                if (error) {
+                    console.warn(`Could not decrypt filename: ${error.message}`);
+                    errorCount++;
+                    continue;
+                }
+                destPath = decryptedFilePath;
+            }
 
-            console.log(`Decrypting ${decryptedFilePath}`);
+            console.log(`Decrypting ${destPath}`);
 
             const infile = path.join(inDirAbs, cur, entry.name);
             const inStream = fs.createReadStream(infile);
-            fs.mkdirSync(path.dirname(path.join(outDirAbs, decryptedFilePath)), { recursive: true });
-            const outfile = path.join(outDirAbs, decryptedFilePath);
+            fs.mkdirSync(path.dirname(path.join(outDirAbs, destPath)), { recursive: true });
+            const outfile = path.join(outDirAbs, destPath);
             const outStream = fs.createWriteStream(outfile);
             const decryptStream = new DecryptStream(encryption);
 
             const [decryptError] = await safe(stream.pipeline(inStream, decryptStream, outStream));
             if (decryptError) {
                 safe.fs.rmSync(outfile);
-                throw new Error(`Could not decrypt ${infile}: ${decryptError.message}`);
+                console.warn(`Could not decrypt ${infile}: ${decryptError.message}`);
+                ++errorCount;
             }
         }
 
         if (tbd.length === 0) break;
     }
+
+
+    if (errorCount) exit(`Failed to decrypt ${errorCount} files`);
 }
 
 async function decryptFilename(filePath, options) {