secrez 1.1.0 → 1.1.2

package/src/commands/Touch.js

@@ -1,98 +1,211 @@
-const {config, Entry} = require('@secrez/core')
-
-class Touch extends require('../Command') {
+const { config, Entry } = require("@secrez/core");
+const { yamlStringify } = require("@secrez/utils");
+const { newWallet, getWalletFromMnemonic } = require("@secrez/eth");
 
+class Touch extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.touch = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.touch = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.touch = 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: 'content',
-        alias: 'c',
-        type: String
+        name: "content",
+        alias: "c",
+        type: String,
       },
       {
-        name: 'not-visible-content',
-        alias: 'n',
-        type: Boolean
+        name: "prefix",
+        alias: "x",
+        type: String,
       },
       {
-        name: 'version-if-exists',
-        alias: 'v',
-        type: Boolean
-      }
-    ]
+        name: "wait-for-content",
+        alias: "w",
+        type: Boolean,
+      },
+      {
+        name: "not-visible-content",
+        alias: "n",
+        type: Boolean,
+      },
+      {
+        name: "generate-wallet",
+        alias: "g",
+        type: Boolean,
+      },
+      {
+        name: "amount",
+        alias: "a",
+        type: Number,
+      },
+      {
+        name: "include-mnemonic",
+        alias: "m",
+        type: Boolean,
+      },
+      {
+        name: "version-if-exists",
+        alias: "v",
+        type: Boolean,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Creates a file.',
+      description: [
+        "Creates a file.",
         'Compared with Unix "touch" command, it can create a file with content',
-        'Check also "help create" for more options.'
+        'Check also "help create" for more options.',
       ],
       examples: [
-        'touch somefile',
+        [
+          "touch somefile",
+          "If the the file exists, it create 'somefile.2', 'somefile.3', etc.",
+        ],
         'touch -p afile --content "Password: 1432874565"',
         'touch ether -c "Private Key: eweiu34y23h4y23ih4uy23hiu4y234i23y4iuh3"',
-        ['touch ether -v', 'Save the file as ether.2 if ether already exists']
-      ]
-    }
+        [
+          "touch sample.txt -e",
+          "Prompt the user to type the content of the file. The text cannot contain newlines. It will cut at the first one, if so. If '-e' and '-c' are both present, '-c' will be ignored.",
+        ],
+        [
+          "touch walletPassword -n",
+          "Prompt the user to type the password without showing it. Notice that '-n' has priority on '-e' and '-c'",
+        ],
+        [
+          "touch gilbert -f name -c 'Albert Goose'",
+          "If the file does not exists, it creates 'gilbert.yaml' with the field 'name'. If a yaml file exists, it adds the field 'name' to it if the the field does not exist.",
+        ],
+        [
+          "touch new-wallet -w",
+          "Creates a new wallet file containing 'private_key' and `address`. Wallet has priority on other creation options.",
+        ],
+        [
+          "touch new-wallets.yaml -w -n 3",
+          "Creates 'new-wallets.yaml', containing 3 wallet, calling them 'private_key', `private_key2` and `private_key3`, and relative addresses.",
+        ],
+        [
+          "touch new-wallet --wallet -x trust0",
+          "In combination con '-x', it creates a new wallet file calling the fields 'trust0_private_key' and 'trust0_address'.",
+        ],
+        [
+          "touch new-wallets.yaml -wi",
+          "Includes the mnemonic. In this case, it will also add the fields 'mnemonic' (mnemonic phrase) and 'derived_path' (path used to generate the keys). ",
+        ],
+      ],
+    };
   }
 
   async touch(options = {}) {
-    this.checkPath(options)
-    let data = await this.internalFs.getTreeIndexAndPath(options.path)
-    let sanitizedPath = Entry.sanitizePath(data.path)
-    if (sanitizedPath !== data.path) {
-      throw new Error('A filename cannot contain \\/><|:&?*^$ chars.')
+    this.checkPath(options);
+    let data = await this.internalFs.getTreeIndexAndPath(options.path);
+    let fileExists = false;
+    let node;
+    if (options.generateWallet) {
+      let content = {};
+      let amount = options.amount || 1;
+      let wallet = newWallet();
+      for (let i = 1; i <= amount; i++) {
+        let wallet0;
+        if (i === 1) {
+          wallet0 = wallet;
+        } else {
+          wallet0 = await getWalletFromMnemonic(
+            wallet.mnemonic.phrase,
+            wallet.path,
+            i - 1
+          );
+        }
+        let field = `${options.prefix ? options.prefix + "_" : ""}private_key${
+          i > 1 ? i : ""
+        }`;
+        content[field] = wallet0.privateKey.replace(/^0x/, "");
+        content[field.replace(/private_key/, "address")] = wallet0.address;
+        if (i === 1 && options.includeMnemonic) {
+          content[field.replace(/private_key/, "mnemonic")] =
+            wallet.mnemonic.phrase;
+          let derivedPath = wallet.path;
+          if (derivedPath.split("/").length === 6) {
+            derivedPath = derivedPath.replace(/\/0$/, "");
+          }
+          content[field.replace(/private_key/, "derived_path")] = derivedPath;
+        }
+      }
+      options.content = yamlStringify(content);
+    }
+    if (fileExists) {
+      await this.internalFs.tree.update(node, options.content);
+    } else {
+      let sanitizedPath = Entry.sanitizePath(data.path);
+      if (sanitizedPath !== data.path) {
+        throw new Error("A filename cannot contain \\/><|:&?*^$ chars.");
+      }
+      options.type = config.types.TEXT;
+      return await this.internalFs.make(options);
     }
-    options.type = config.types.TEXT
-    return await this.internalFs.make(options)
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      this.validate(options)
-      this.checkPath(options)
+      this.validate(options);
+      this.checkPath(options);
       /* istanbul ignore if  */
-      if (options.notVisibleContent) {
-        let content = await this.useInput(Object.assign(options, {
-          type: 'password',
-          message: 'Type the secret'
-        }))
-        if (content) {
-          options.content = content
-        } else {
-          throw new Error('Command canceled')
+      if (!options.generateWallet) {
+        if (options.notVisibleContent) {
+          let content = await this.useInput(
+            Object.assign(options, {
+              type: "password",
+              message: "Type the secret",
+            })
+          );
+          if (content) {
+            options.content = content;
+          } else {
+            throw new Error("Command canceled");
+          }
+        } else if (options.waitForContent) {
+          let content = await this.useInput(
+            Object.assign(options, {
+              type: "input",
+              message: "Type/paste the content",
+            })
+          );
+          if (content) {
+            options.content = content;
+          } else {
+            throw new Error("Command canceled");
+          }
         }
       }
-      let newFile = await this.touch(options)
-      this.Logger.grey(`New file "${newFile.getPath()}" created.`)
+      let newFile = await this.touch(options);
+      if (newFile) {
+        this.Logger.grey(`New file "${newFile.getPath()}" created.`);
+      } else {
+        this.Logger.grey(`File "${options.path}" updated.`);
+      }
     } catch (e) {
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Touch
-
-
+module.exports = Touch;

package/src/commands/Use.js

@@ -1,86 +1,89 @@
-class Use extends require('../Command') {
-
+class Use extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.use = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.use = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.use = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
+        name: "help",
+        alias: "h",
+        type: Boolean,
       },
       {
-        name: 'dataset',
-        completionType: 'dataset',
-        alias: 'd',
+        name: "dataset",
+        completionType: "dataset",
+        alias: "d",
         defaultOption: true,
-        type: String
+        type: String,
       },
       {
-        name: 'create',
-        alias: 'c',
-        type: Boolean
-      }
-    ]
+        name: "create",
+        alias: "c",
+        type: Boolean,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Uses a specific dataset.'],
+      description: ["Uses a specific dataset."],
       examples: [
-        ['use archive', 'use "archive" dataset if it exists'],
-        ['use -c archive', 'use the dataset named "archive";', 'if the dataset does not exists it creates it']
-      ]
-    }
+        ["use archive", 'use "archive" dataset if it exists'],
+        [
+          "use -c archive",
+          'use the dataset named "archive";',
+          "if the dataset does not exists it creates it",
+        ],
+      ],
+    };
   }
 
   async use(options) {
-    let datasetsInfo = await this.internalFs.getDatasetsInfo()
+    let datasetsInfo = await this.internalFs.getDatasetsInfo();
     if (options.dataset) {
-      let newSet
+      let newSet;
       for (let dataset of datasetsInfo) {
         if (dataset.name.toLowerCase() === options.dataset.toLowerCase()) {
-          newSet = dataset
-          break
+          newSet = dataset;
+          break;
         }
       }
       if (!newSet && !options.create) {
-        throw new Error('The dataset does not exist; add "-c" to create it')
+        throw new Error('The dataset does not exist; add "-c" to create it');
       }
       if (newSet && newSet.index === this.internalFs.treeIndex) {
-        return `You are already using ${options.dataset}`
+        return `You are already using ${options.dataset}`;
       } else if (newSet) {
-        await this.internalFs.mountTree(newSet.index, true)
+        await this.internalFs.mountTree(newSet.index, true);
       } else {
         // create
-        this.internalFs.tree.validateDatasetName(options.dataset)
-        let index = datasetsInfo[datasetsInfo.length - 1].index + 1
-        await this.internalFs.mountTree(index, true)
-        await this.internalFs.tree.nameDataset(options.dataset)
+        this.internalFs.tree.validateDatasetName(options.dataset);
+        let index = datasetsInfo[datasetsInfo.length - 1].index + 1;
+        await this.internalFs.mountTree(index, true);
+        await this.internalFs.tree.nameDataset(options.dataset);
       }
     } else {
-      throw new Error('Wrong parameters')
+      throw new Error("Wrong parameters");
     }
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      this.validate(options)
-      let result = await this.use(options)
+      this.validate(options);
+      let result = await this.use(options);
       if (result) {
-        this.Logger.reset(result)
+        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 = Use
+module.exports = Use;

package/src/commands/Ver.js

@@ -1,34 +1,32 @@
-const pkg = require('../../package')
-
-class Ver extends require('../Command') {
+const pkg = require("../../package");
 
+class Ver extends require("../Command") {
   setHelpAndCompletion() {
-    this.cliConfig.completion.ver = {}
-    this.cliConfig.completion.help.ver = true
+    this.cliConfig.completion.ver = {};
+    this.cliConfig.completion.help.ver = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
-      }]
+        name: "help",
+        alias: "h",
+        type: Boolean,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Shows the version of Secrez.'],
-      examples: [
-        'ver'
-      ]
-    }
+      description: ["Shows the version of Secrez."],
+      examples: ["ver"],
+    };
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
-    this.Logger.reset(`v${pkg.version}`)
-    await this.prompt.run()
+    this.Logger.reset(`v${pkg.version}`);
+    await this.prompt.run();
   }
 }
 
-module.exports = Ver
+module.exports = Ver;

package/src/commands/Whoami.js

@@ -1,73 +1,70 @@
-const chalk = require('chalk')
-const {ConfigUtils} = require('@secrez/core')
-const clipboardy = require('clipboardy')
-
-class Whoami extends require('../Command') {
+const chalk = require("chalk");
+const { ConfigUtils } = require("@secrez/core");
+const clipboardy = require("clipboardy");
 
+class Whoami extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.whoami = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.whoami = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.whoami = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
-      }
-    ]
+        name: "help",
+        alias: "h",
+        type: Boolean,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Show data that other users need to chat with you'],
-      examples: [
-        'whoami'
-      ]
-    }
+      description: ["Show data that other users need to chat with you"],
+      examples: ["whoami"],
+    };
   }
 
   async customCompletion(options, originalLine, defaultOption) {
-    return []
+    return [];
   }
 
   async whoami(options) {
     let result = {
-      publicKey: this.secrez.getPublicKey()
-    }
-    const env = options.env = await ConfigUtils.getEnv(this.secrez.config)
+      publicKey: this.secrez.getPublicKey(),
+    };
+    const env = (options.env = await ConfigUtils.getEnv(this.secrez.config));
     if (env.courier) {
-      await this.prompt.commands.courier.preInit(options)
+      await this.prompt.commands.courier.preInit(options);
       if (options.ready) {
-        result.url = env.courier.tunnel.url
+        result.url = env.courier.tunnel.url;
       }
     }
     if (options.asIs) {
-      return result
+      return result;
     }
-    this.Logger.reset(chalk.grey('Public key: ') + result.publicKey)
+    this.Logger.reset(chalk.grey("Public key: ") + result.publicKey);
     if (result.url) {
-      this.Logger.reset(chalk.grey('Hub url: ') + result.url)
-      await clipboardy.write(result.url)
-      this.Logger.grey('For your convenience, the url has been copied to the clipboard.')
+      this.Logger.reset(chalk.grey("Hub url: ") + result.url);
+      await clipboardy.write(result.url);
+      this.Logger.grey(
+        "For your convenience, the url has been copied to the clipboard."
+      );
     }
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      this.validate(options)
-      await this.whoami(options)
+      this.validate(options);
+      await this.whoami(options);
     } catch (e) {
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Whoami
-
-
+module.exports = Whoami;