secrez 1.1.1 → 1.1.3

package/src/commands/Cat.js

@@ -1,214 +1,224 @@
-const _ = require('lodash')
-const {chalk} = require('../utils/Logger')
-const path = require('path')
-const {config} = require('@secrez/core')
-const Crypto = require('@secrez/crypto')
-const {Node} = require('@secrez/fs')
-const {isYaml, yamlParse} = require('@secrez/utils')
-
-class Cat extends require('../Command') {
+const _ = require("lodash");
+const { chalk } = require("../utils/Logger");
+const path = require("path");
+const { config } = require("@secrez/core");
+const Crypto = require("@secrez/crypto");
+const { Node } = require("@secrez/fs");
+const { isYaml, yamlParse } = require("@secrez/utils");
 
+class Cat extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.cat = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.cat = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.cat = 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: 'metadata',
-        alias: 'm',
-        type: Boolean
+        name: "metadata",
+        alias: "m",
+        type: Boolean,
       },
       {
-        name: 'version',
-        alias: 'v',
+        name: "version",
+        alias: "v",
         multiple: true,
-        type: String
+        type: String,
       },
       {
-        name: 'all',
-        alias: 'a',
-        type: Boolean
+        name: "all",
+        alias: "a",
+        type: Boolean,
       },
       {
-        name: 'field',
-        alias: 'f',
+        name: "field",
+        alias: "f",
         type: String,
-        hint: 'Shows only the specified field if a Yaml file'
+        hint: "Shows only the specified field if a Yaml file",
       },
       {
-        name: 'unformatted',
-        alias: 'u',
+        name: "unformatted",
+        alias: "u",
         type: Boolean,
-        hint: 'If a Yaml file, it does not format the output'
-      }
-    ]
+        hint: "If a Yaml file, it does not format the output",
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Shows the content of a file.'],
+      description: ["Shows the content of a file."],
       examples: [
-        'cat ../passwords/Facebook',
-        ['cat wallet -m', 'shows metadata: version and creation date'],
-        ['cat etherWallet -v 2UYw', 'shows the version 2UYw of the secret, if exists'],
-        ['cat etherWallet -a', 'lists all the versions'],
-        ['cat etherWallet -v 17TR hUUv', 'shows two versions (-m is forced)'],
-        ['cat wallet.yml -f private_key', 'shows only the field private_key of a yaml file'],
-        ['cat some.yml -u', 'shows a Yaml file as is']
-      ]
-    }
+        "cat ../passwords/Facebook",
+        ["cat wallet -m", "shows metadata: version and creation date"],
+        [
+          "cat etherWallet -v 2UYw",
+          "shows the version 2UYw of the secret, if exists",
+        ],
+        ["cat etherWallet -a", "lists all the versions"],
+        ["cat etherWallet -v 17TR hUUv", "shows two versions (-m is forced)"],
+        [
+          "cat wallet.yml -f private_key",
+          "shows only the field private_key of a yaml file",
+        ],
+        ["cat some.yml -u", "shows a Yaml file as is"],
+      ],
+    };
   }
 
   formatTs(ts, name) {
-    let tsHash = Node.hashVersion(ts)
-    ts = Crypto.fromTsToDate(ts)
-    let date = ts[0].split('Z')[0].split('T')
-    let ret = `-- ${chalk.bold(tsHash)} -- ${date[0]} ${date[1].substring(0, 12)}${ts[1]}`
+    let tsHash = Node.hashVersion(ts);
+    ts = Crypto.fromTsToDate(ts);
+    let date = ts[0].split("Z")[0].split("T");
+    let ret = `-- ${chalk.bold(tsHash)} -- ${date[0]} ${date[1].substring(
+      0,
+      12
+    )}${ts[1]}`;
     if (name) {
-      ret += ' (' + name + ')'
+      ret += " (" + name + ")";
     }
 
-    return ret
+    return ret;
   }
 
   async cat(options, justContent) {
-    if (typeof options === 'string') {
+    if (typeof options === "string") {
       options = {
-        path: options
-      }
+        path: options,
+      };
     }
-    let data = await this.internalFs.getTreeIndexAndPath(options.path)
-    options.path = data.path
-    let tree = data.tree
-    let p = tree.getNormalizedPath(options.path)
-    let node = tree.root.getChildFromPath(p)
+    let data = await this.internalFs.getTreeIndexAndPath(options.path);
+    options.path = data.path;
+    let tree = data.tree;
+    let p = tree.getNormalizedPath(options.path);
+    let node = tree.root.getChildFromPath(p);
     if (node && Node.isFile(node)) {
-      let result = []
+      let result = [];
       if (!isYaml(p)) {
-        delete options.field
+        delete options.field;
       }
 
       const pushDetails = async (node, ts, field) => {
-        let details = await tree.getEntryDetails(node, ts)
+        let details = await tree.getEntryDetails(node, ts);
         if (!justContent && !options.unformatted && isYaml(p)) {
-          let fields
+          let fields;
           try {
-            fields = yamlParse(details.content || '{}')
+            fields = yamlParse(details.content || "{}");
           } catch (e) {
             // wrong format
           }
 
-          const format = field => {
-            let val = fields[field]
+          const format = (field) => {
+            let val = fields[field];
             if (/\n/.test(val)) {
-              val = '\n' + val
+              val = "\n" + val;
             }
-            return [chalk.grey(field + ':'), val].join(' ')
-          }
-          if (typeof fields === 'object') {
+            return [chalk.grey(field + ":"), val].join(" ");
+          };
+          if (typeof fields === "object") {
             if (field) {
               if (fields[field]) {
-                details.content = format(field)
+                details.content = format(field);
               } else {
-                details.content = chalk.yellow('-- empty field')
+                details.content = chalk.yellow("-- empty field");
               }
             } else {
-              let content = []
+              let content = [];
               for (let f in fields) {
-                content.push(format(f))
+                content.push(format(f));
               }
-              details.content = content.join('\n')
+              details.content = content.join("\n");
             }
           }
         }
-        result.push(details)
-      }
+        result.push(details);
+      };
 
       if (options.all || options.version) {
-        let versions = node.getVersions()
+        let versions = node.getVersions();
         if (options.version && options.version.length > 1) {
-          options.metadata = true
+          options.metadata = true;
         }
-        let found = []
+        let found = [];
         for (let ts of versions) {
-          let v = Node.hashVersion(ts)
+          let v = Node.hashVersion(ts);
           if (options.version) {
             if (!options.version.includes(v)) {
-              continue
+              continue;
             }
           }
-          await pushDetails(node, ts, options.field)
-          found.push(v)
+          await pushDetails(node, ts, options.field);
+          found.push(v);
         }
         if (options.version && options.version.length > found.length) {
-          options.notFound = []
+          options.notFound = [];
           for (let v of options.version) {
             if (!found.includes(v)) {
-              options.notFound.push(v)
+              options.notFound.push(v);
             }
           }
         }
       } else {
-        await pushDetails(node, options.ts, options.field)
+        await pushDetails(node, options.ts, options.field);
       }
-      return result
+      return result;
     } else {
-      throw new Error('Cat requires a valid file')
+      throw new Error("Cat requires a valid file");
     }
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
       this.validate(options, {
-        path: true
-      })
-      let fn = path.basename(options.path)
-      let data = await this.cat(options)
-      let extra = options.all || options.metadata || options.versions
+        path: true,
+      });
+      let fn = path.basename(options.path);
+      let data = await this.cat(options);
+      let extra = options.all || options.metadata || options.versions;
       if (data) {
         for (let d of data) {
-          let {content, ts, type, name} = d
+          let { content, ts, type, name } = d;
           if (extra) {
-            this.Logger.yellow(`${this.formatTs(ts, fn === name ? undefined : name)}`)
+            this.Logger.yellow(
+              `${this.formatTs(ts, fn === name ? undefined : name)}`
+            );
           }
           if (type === config.types.TEXT) {
             if (_.trim(content)) {
-              this.Logger.reset(_.trim(content))
+              this.Logger.reset(_.trim(content));
             } else {
-              this.Logger.yellow('-- this version is empty')
+              this.Logger.yellow("-- this version is empty");
             }
           } else {
-            this.Logger.yellow('-- this is a binary file')
+            this.Logger.yellow("-- this is a binary file");
           }
         }
         if (options.notFound && options.notFound.length) {
-          this.Logger.yellow('Versions not found: ' + options.notFound.join(' '))
+          this.Logger.yellow(
+            "Versions not found: " + options.notFound.join(" ")
+          );
         }
       }
     } catch (e) {
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Cat
-
-
+module.exports = Cat;

package/src/commands/Cd.js

@@ -1,80 +1,77 @@
-const {Node} = require('@secrez/fs')
-
-class Cd extends require('../Command') {
+const { Node } = require("@secrez/fs");
 
+class Cd extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.cd = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.cd = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.cd = 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,
-        defaultValue: '/'
-      }
-    ]
+        defaultValue: "/",
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Changes the working directory.'],
+      description: ["Changes the working directory."],
       examples: [
-        'cd coin',
-        'cd ../passwords',
-        ['cd', 'moves to the root, like "cd /"'],
-        ['cd ~', '~ is equivalent to /'],
-      ]
-    }
+        "cd coin",
+        "cd ../passwords",
+        ["cd", 'moves to the root, like "cd /"'],
+        ["cd ~", "~ is equivalent to /"],
+      ],
+    };
   }
 
   async cd(options) {
-    let currentIndex = this.internalFs.treeIndex
-    let startingPath = options.path
-    let data = await this.internalFs.getTreeIndexAndPath(options.path)
+    let currentIndex = this.internalFs.treeIndex;
+    let startingPath = options.path;
+    let data = await this.internalFs.getTreeIndexAndPath(options.path);
     if (currentIndex !== data.index) {
-      await this.internalFs.mountTree(data.index, true)
+      await this.internalFs.mountTree(data.index, true);
     }
-    options.path = startingPath ? data.path : '/'
-    let tree = data.tree
-    let p = tree.getNormalizedPath(options.path)
+    options.path = startingPath ? data.path : "/";
+    let tree = data.tree;
+    let p = tree.getNormalizedPath(options.path);
     if (!p || /^(\/|~|~\/)$/.test(p)) {
-      tree.workingNode = tree.root
-    } else if (p === '.') {
+      tree.workingNode = tree.root;
+    } else if (p === ".") {
       // nothing
     } else {
-      let node = tree.root.getChildFromPath(p)
+      let node = tree.root.getChildFromPath(p);
       if (Node.isDir(node)) {
-        tree.workingNode = node
+        tree.workingNode = node;
       } else {
-        throw new Error('You cannot cd to a file')
+        throw new Error("You cannot cd to a file");
       }
     }
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      this.validate(options)
-      await this.cd(options)
+      this.validate(options);
+      await this.cd(options);
     } catch (e) {
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Cd
-
-
+module.exports = Cd;

package/src/commands/Chat.js

@@ -1,106 +1,120 @@
-const path = require('path')
-const chalk = require('chalk')
-const {ConfigUtils} = require('@secrez/core')
-const ChatPrompt = require('../prompts/ChatPrompt')
-
-class Chat extends require('../Command') {
+const path = require("path");
+const chalk = require("chalk");
+const { ConfigUtils } = require("@secrez/core");
+const ChatPrompt = require("../prompts/ChatPrompt");
 
+class Chat extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.chat = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.chat = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.chat = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
-      }
-    ]
+        name: "help",
+        alias: "h",
+        type: Boolean,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Enters the Secrez chat'],
-      examples: [
-        'chat'
-      ]
-    }
+      description: ["Enters the Secrez chat"],
+      examples: ["chat"],
+    };
   }
 
   async uploadUsersPublicKeysToCourier(options) {
-    const {port, caCrt} = options.env.courier
-    let contacts = await this.prompt.commands.contacts.contacts({list: true, asIs: true})
-    this.contactsByPublicKey = {}
+    const { port, caCrt } = options.env.courier;
+    let contacts = await this.prompt.commands.contacts.contacts({
+      list: true,
+      asIs: true,
+    });
+    this.contactsByPublicKey = {};
     for (let contact of contacts) {
-      this.contactsByPublicKey[contact[1].publicKey] = contact[0]
-      await this.callCourier({
-        action: {
-          name: 'add',
-          publicKey: contact[1].publicKey,
-          url: contact[1].url
-        }
-      }, port, caCrt, '/admin')
+      this.contactsByPublicKey[contact[1].publicKey] = contact[0];
+      await this.callCourier(
+        {
+          action: {
+            name: "add",
+            publicKey: contact[1].publicKey,
+            url: contact[1].url,
+          },
+        },
+        port,
+        caCrt,
+        "/admin"
+      );
     }
   }
 
   async readHistoryMessages(options = {}) {
     /* istanbul ignore if  */
     if (!options.asIs) {
-      this.chatPrompt.skip = true
+      this.chatPrompt.skip = true;
     }
-    const {minTimestamp, maxTimestamp, from, to} = options
+    const { minTimestamp, maxTimestamp, from, to } = options;
     /* istanbul ignore if  */
     if (!options.asIs) {
-      this.Logger.bold(from || to ? `Messages${from ? ` from ${from}` : ''}${to ? ` to ${to}` : ''}:` : 'All message history:')
+      this.Logger.bold(
+        from || to
+          ? `Messages${from ? ` from ${from}` : ""}${to ? ` to ${to}` : ""}:`
+          : "All message history:"
+      );
     }
     let newMessages = await this.prompt.commands.courier.getSomeMessages({
       payload: {
         minTimestamp,
         maxTimestamp,
         from: this.room[0].publicKey,
-        limit: 1000
-      }
-    })
+        limit: 1000,
+      },
+    });
     /* istanbul ignore if  */
     if (!options.asIs) {
-      let len = newMessages.length
+      let len = newMessages.length;
       if (len) {
         this.chatPrompt.onMessages(newMessages, {
           fromHistory: true,
           verbose: options.verbose,
-          lastLine: options.asIs ? undefined : chalk.grey(`${len} message${len > 1 ? 's' : ''} found.`)
-        })
+          lastLine: options.asIs
+            ? undefined
+            : chalk.grey(`${len} message${len > 1 ? "s" : ""} found.`),
+        });
       } else {
-        this.Logger.yellow('None found')
+        this.Logger.yellow("None found");
       }
-      this.chatPrompt.skip = false
+      this.chatPrompt.skip = false;
     } else {
-      return newMessages
+      return newMessages;
     }
   }
 
   async chat(options) {
-    const env = options.env = await ConfigUtils.getEnv(this.secrez.config)
+    const env = (options.env = await ConfigUtils.getEnv(this.secrez.config));
     if (env.courier) {
-      this.courier = await this.prompt.commands.courier
-      await this.courier.preInit(options)
+      this.courier = await this.prompt.commands.courier;
+      await this.courier.preInit(options);
       if (options.ready) {
-        await this.uploadUsersPublicKeysToCourier(options)
-        if (process.env.NODE_ENV === 'test') {
-          this.chatPrompt = options.chatPrompt
+        await this.uploadUsersPublicKeysToCourier(options);
+        if (process.env.NODE_ENV === "test") {
+          this.chatPrompt = options.chatPrompt;
         } else {
-          this.chatPrompt = new ChatPrompt
+          this.chatPrompt = new ChatPrompt();
         }
         await this.chatPrompt.init({
-          historyPath: path.join(this.secrez.config.localDataPath, 'chatHistory'),
+          historyPath: path.join(
+            this.secrez.config.localDataPath,
+            "chatHistory"
+          ),
           environment: this,
-          secrez: this.secrez
-        })
-        await this.chatPrompt.run(options)
+          secrez: this.secrez,
+        });
+        await this.chatPrompt.run(options);
       } else {
-        throw new Error('The configured courier is not responding.')
+        throw new Error("The configured courier is not responding.");
       }
     } else {
       this.Logger.grey(`Chat requires a courier listening locally.
@@ -112,25 +126,23 @@ and launch it as
 
   secrez-courier
   
-It will show the port where it is listening to. Copy it and come back to Secrez. Then run "courier" to configure the connection w/ the courier.`)
-      throw new Error('Courier not found.')
+It will show the port where it is listening to. Copy it and come back to Secrez. Then run "courier" to configure the connection w/ the courier.`);
+      throw new Error("Courier not found.");
     }
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      await this.chat(options)
+      await this.chat(options);
     } catch (e) {
       // console.log(e)
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Chat
-
-
+module.exports = Chat;