secrez 1.1.1 → 1.1.2

package/src/commands/Quit.js

@@ -1,47 +1,45 @@
-const utils = require('@secrez/utils')
-
-class Quit extends require('../Command') {
+const utils = require("@secrez/utils");
 
+class Quit extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.quit = utils.sortKeys({
       // dontSaveHistory: TRUE // not supported, yet
-    })
-    this.cliConfig.completion.help.quit = true
+    });
+    this.cliConfig.completion.help.quit = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
-      }]
+        name: "help",
+        alias: "h",
+        type: Boolean,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Quits Secrez.'],
-      examples: [
-        'quit'
-      ]
-    }
+      description: ["Quits Secrez."],
+      examples: ["quit"],
+    };
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     /* istanbul ignore if  */
     // eslint-disable-next-line no-constant-condition
-    if (process.env.NODE_ENV !== 'test') {
-      await this.prompt.saveHistory()
-      this.Logger.bold('Clear or close the terminal. If not, your history will be visible scrolling up.')
-      this.Logger.reset('Bye bye :o)')
+    if (process.env.NODE_ENV !== "test") {
+      await this.prompt.saveHistory();
+      this.Logger.bold(
+        "Clear or close the terminal. If not, your history will be visible scrolling up."
+      );
+      this.Logger.reset("Bye bye :o)");
       /*eslint-disable-next-line*/
-      process.exit(0)
+      process.exit(0);
     } else {
-      this.Logger.reset('Bye bye :o)')
+      this.Logger.reset("Bye bye :o)");
     }
   }
 }
 
-module.exports = Quit
-
-
+module.exports = Quit;

package/src/commands/Rm.js

@@ -1,133 +1,141 @@
-const chalk = require('chalk')
-const fs = require('fs-extra')
-const path = require('path')
-const {Node} = require('@secrez/fs')
-
-class Rm extends require('../Command') {
+const chalk = require("chalk");
+const fs = require("fs-extra");
+const path = require("path");
+const { Node } = require("@secrez/fs");
 
+class Rm extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.rm = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.rm = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.rm = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
+        name: "help",
+        alias: "h",
+        type: Boolean,
       },
       {
-        name: 'path',
-        completionType: 'file',
-        alias: 'p',
+        name: "path",
+        completionType: "file",
+        alias: "p",
         defaultOption: true,
-        type: String
+        type: String,
       },
       {
-        name: 'versions',
-        alias: 'v',
+        name: "versions",
+        alias: "v",
         multiple: true,
-        type: String
-      }
-    ]
+        type: String,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Removes one or more files and folders.',
+      description: [
+        "Removes one or more files and folders.",
         'Technically files are moved to the trash dataset (access it with "use trash").',
-        'If you remove a file from the trash dataset, the data will be deleted from disk;',
-        'this action is not undoable.'
+        "If you remove a file from the trash dataset, the data will be deleted from disk;",
+        "this action is not undoable.",
       ],
       examples: [
-        'rm secret1',
-        ['rm secret2 -v au7t RF6z', 'deleted the versions "au7t" and "RF6z" of the file']
-      ]
-    }
+        "rm secret1",
+        [
+          "rm secret2 -v au7t RF6z",
+          'deleted the versions "au7t" and "RF6z" of the file',
+        ],
+      ],
+    };
   }
 
   async rm(options = {}) {
-    options.asIs = true
-    options.newPath = 'trash:/'
-    options.removing = true
+    options.asIs = true;
+    options.newPath = "trash:/";
+    options.removing = true;
 
-    let nodes = await this.internalFs.fileList(options, null, true)
-    let deleted = nodes.map(n => n.getPath())
+    let nodes = await this.internalFs.fileList(options, null, true);
+    let deleted = nodes.map((n) => n.getPath());
     if (deleted.length) {
-
       if (options.versions) {
         if (deleted.length > 1) {
-          throw new Error('You can delete versions of a single file at time')
+          throw new Error("You can delete versions of a single file at time");
         }
         /* istanbul ignore if */
-        if (!process.env.NODE_ENV === 'test') {
-          this.Logger.reset('The deletion of a version is not reversible.')
-          let message = 'Are you sure you want to proceed?'
+        if (!process.env.NODE_ENV === "test") {
+          this.Logger.reset("The deletion of a version is not reversible.");
+          let message = "Are you sure you want to proceed?";
           let yes = await this.useConfirm({
             message,
-            default: false
-          })
+            default: false,
+          });
           if (!yes) {
-            return 'Operation canceled'
+            return "Operation canceled";
           }
         }
-        let {datasetIndex} = Node.getRoot(nodes[0])
-        let res = []
+        let { datasetIndex } = Node.getRoot(nodes[0]);
+        let res = [];
         for (let ts in nodes[0].versions) {
-          let v = Node.hashVersion(ts)
+          let v = Node.hashVersion(ts);
           if (options.versions.indexOf(v) !== -1) {
-            let file = nodes[0].versions[ts].file
-            await fs.remove(path.join(this.secrez.config.dataPath + (datasetIndex ? `.${datasetIndex}` : ''), file))
-            res.push(this.formatResult({
-              name: path.basename(deleted[0]),
-              version: v
-            }))
-            delete nodes[0].versions[ts]
-            this.internalFs.trees[datasetIndex].save()
+            let file = nodes[0].versions[ts].file;
+            await fs.remove(
+              path.join(
+                this.secrez.config.dataPath +
+                  (datasetIndex ? `.${datasetIndex}` : ""),
+                file
+              )
+            );
+            res.push(
+              this.formatResult({
+                name: path.basename(deleted[0]),
+                version: v,
+              })
+            );
+            delete nodes[0].versions[ts];
+            this.internalFs.trees[datasetIndex].save();
           }
         }
-        return res
+        return res;
       }
-      await this.prompt.commands.mv.mv(options, nodes)
+      await this.prompt.commands.mv.mv(options, nodes);
     }
-    return deleted
+    return deleted;
   }
 
   formatResult(item) {
-    return [chalk.yellow(item.version), item.name].join(' ')
+    return [chalk.yellow(item.version), item.name].join(" ");
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     if (!options.path) {
-      this.Logger.red('File path not specified.')
+      this.Logger.red("File path not specified.");
     } else {
       try {
-        this.validate(options)
-        let deleted = await this.rm(options)
+        this.validate(options);
+        let deleted = await this.rm(options);
         if (deleted.length === 0) {
-          this.Logger.grey('No files have been deleted.')
+          this.Logger.grey("No files have been deleted.");
         } else {
-          this.Logger.grey('Deleted entries:')
-          if (typeof deleted === 'string') {
-            this.Logger.reset(deleted)
+          this.Logger.grey("Deleted entries:");
+          if (typeof deleted === "string") {
+            this.Logger.reset(deleted);
           } else {
             for (let d of deleted) {
-              this.Logger.reset(d)
+              this.Logger.reset(d);
             }
           }
         }
       } catch (e) {
-        this.Logger.red(e.message)
+        this.Logger.red(e.message);
       }
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Rm
-
-
+module.exports = Rm;

package/src/commands/Shell.js

@@ -1,62 +1,61 @@
-const {execSync} = require('child_process')
-
-class Shell extends require('../Command') {
+const { execSync } = require("child_process");
 
+class Shell extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.shell = {
-      _self: this
-    }
-    this.cliConfig.completion.help.shell = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.shell = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
+        name: "help",
+        alias: "h",
+        type: Boolean,
       },
       {
-        name: 'command',
-        alias: 'c',
+        name: "command",
+        alias: "c",
         type: String,
-        defaultOption: true
-      }
-    ]
+        defaultOption: true,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Execute a shell command in the current disk folder.'],
+      description: ["Execute a shell command in the current disk folder."],
       examples: [
         'shell "ls"',
-        ['shell "mv wallet1 wallet2"', 'renames an external file'],
-        ['shell', 'asks to type the command to execute']
-      ]
-    }
+        ['shell "mv wallet1 wallet2"', "renames an external file"],
+        ["shell", "asks to type the command to execute"],
+      ],
+    };
   }
 
   async shell(options) {
-    let pwd = await this.prompt.commands.lpwd.lpwd()
+    let pwd = await this.prompt.commands.lpwd.lpwd();
     if (!options.command) {
-      options.command = await this.useInput(Object.assign(options, {
-        message: 'Type the command'
-      }))
+      options.command = await this.useInput(
+        Object.assign(options, {
+          message: "Type the command",
+        })
+      );
     }
-    return execSync(`cd ${pwd} && ${options.command}`).toString()
+    return execSync(`cd ${pwd} && ${options.command}`).toString();
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      this.validate(options)
-      this.Logger.reset(await this.shell(options))
+      this.validate(options);
+      this.Logger.reset(await this.shell(options));
     } catch (e) {
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Shell
-
-
+module.exports = Shell;

package/src/commands/Ssh.js

@@ -1,110 +1,124 @@
-const path = require('path')
-const fs = require('fs-extra')
-const {execSync} = require('child_process')
-const {execAsync} = require('@secrez/utils')
-
-class Ssh extends require('../Command') {
+const path = require("path");
+const fs = require("fs-extra");
+const { execSync } = require("child_process");
+const { execAsync } = require("@secrez/utils");
 
+class Ssh extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.ssh = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.ssh = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.ssh = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
+        name: "help",
+        alias: "h",
+        type: Boolean,
       },
       {
-        name: 'remote-host',
-        alias: 'r',
+        name: "remote-host",
+        alias: "r",
         defaultOption: true,
-        type: String
+        type: String,
       },
       {
-        name: 'identity',
-        completionType: 'file',
-        alias: 'i',
-        type: String
+        name: "identity",
+        completionType: "file",
+        alias: "i",
+        type: String,
       },
       {
-        name: 'user',
-        alias: 'u',
-        type: String
+        name: "user",
+        alias: "u",
+        type: String,
       },
       {
-        name: 'delete-after',
-        alias: 'd',
-        type: Number
+        name: "delete-after",
+        alias: "d",
+        type: Number,
       },
       {
-        name: 'ignore-host-key-check',
-        type: Boolean
-      }
-    ]
+        name: "ignore-host-key-check",
+        type: Boolean,
+      },
+    ];
   }
 
   help() {
     return {
       description: [
-        'Opens a new tab and run ssh to connect to a remote server via SSH',
-        'Notice that the SSH key is temporarily copied to ~/.ssh and removed after few seconds seconds.'
+        "Opens a new tab and run ssh to connect to a remote server via SSH",
+        "Notice that the SSH key is temporarily copied to ~/.ssh and removed after few seconds seconds.",
       ],
       examples: [
-        ['ssh example.com -i id_ed25519 -u joe', 'connects using the private key "main:/.ssh/id_ed25519"'],
-        ['ssh example.com -i keys:/id_rsa', 'connects as root using the private key "id_rsa" in the root of the "keys" dataset'],
-        ['ssh example.com -i keys:/id_rsa_no -d 2', 'deletes the private key from the temporary folder after 2 seconds. The standard is 10 seconds to give you the time to type the password, but if the private key is passwordless you should reduce the time.']
-      ]
-    }
+        [
+          "ssh example.com -i id_ed25519 -u joe",
+          'connects using the private key "main:/.ssh/id_ed25519"',
+        ],
+        [
+          "ssh example.com -i keys:/id_rsa",
+          'connects as root using the private key "id_rsa" in the root of the "keys" dataset',
+        ],
+        [
+          "ssh example.com -i keys:/id_rsa_no -d 2",
+          "deletes the private key from the temporary folder after 2 seconds. The standard is 10 seconds to give you the time to type the password, but if the private key is passwordless you should reduce the time.",
+        ],
+      ],
+    };
   }
 
   async ssh(options = {}) {
-    let result = await execAsync('which', __dirname, ['ttab'])
+    let result = await execAsync("which", __dirname, ["ttab"]);
     if (!result.message || result.code === 1) {
-      throw new Error('On MacOS ttab is required. Run "npm i -g ttab" in another terminal to install it')
+      throw new Error(
+        'On MacOS ttab is required. Run "npm i -g ttab" in another terminal to install it'
+      );
     }
     if (!options.remoteHost) {
-      throw new Error('A remote host is required')
+      throw new Error("A remote host is required");
     }
     if (!options.identity) {
-      throw new Error('A path to the identity key is required')
+      throw new Error("A path to the identity key is required");
     }
-    let key = (await this.prompt.commands.cat.cat({
-      path: options.identity,
-      unformatted: true
-    }))[0].content
-    let sshPath = path.join(this.secrez.config.tmpPath, '.ssh')
+    let key = (
+      await this.prompt.commands.cat.cat({
+        path: options.identity,
+        unformatted: true,
+      })
+    )[0].content;
+    let sshPath = path.join(this.secrez.config.tmpPath, ".ssh");
     if (!(await fs.pathExists(sshPath))) {
-      await fs.ensureDir(sshPath)
-      await execAsync('chmod', this.secrez.config.tmpPath, ['700', '.ssh'])
+      await fs.ensureDir(sshPath);
+      await execAsync("chmod", this.secrez.config.tmpPath, ["700", ".ssh"]);
     }
-    let keyName = `id_${Math.random().toString().substring(2)}`
-    let keyPath = path.join(sshPath, keyName)
-    await fs.writeFile(keyPath, key)
-    await execAsync('chmod', sshPath, ['600', keyName])
-    execSync(`ttab ssh ${options.ignoreHostKeyCheck ? '-oStrictHostKeyChecking=no' : ''} -i ${keyPath} ${options.user || 'root'}@${options.remoteHost}`)
+    let keyName = `id_${Math.random().toString().substring(2)}`;
+    let keyPath = path.join(sshPath, keyName);
+    await fs.writeFile(keyPath, key);
+    await execAsync("chmod", sshPath, ["600", keyName]);
+    execSync(
+      `ttab ssh ${
+        options.ignoreHostKeyCheck ? "-oStrictHostKeyChecking=no" : ""
+      } -i ${keyPath} ${options.user || "root"}@${options.remoteHost}`
+    );
     setTimeout(() => {
-      fs.unlink(keyPath)
-    }, 10000)
+      fs.unlink(keyPath);
+    }, 10000);
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      this.validate(options)
-      let result = await this.ssh(options)
-      this.Logger.reset(result)
+      this.validate(options);
+      let result = await this.ssh(options);
+      this.Logger.reset(result);
     } catch (e) {
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Ssh
-
-
+module.exports = Ssh;