secrez 1.1.1 → 1.1.2

package/src/commands/Courier.js

@@ -1,207 +1,225 @@
-const {sleep} = require('@secrez/utils')
-const {ConfigUtils} = require('@secrez/core')
-
-class Conf extends require('../Command') {
+const { sleep } = require("@secrez/utils");
+const { ConfigUtils } = require("@secrez/core");
 
+class Conf extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.courier = {
-      _self: this
-    }
-    this.cliConfig.completion.help.courier = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.courier = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
-      }
-    ]
+        name: "help",
+        alias: "h",
+        type: Boolean,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Configure the connection to a local courier'],
-      examples: [
-        'courier'
-      ]
-    }
+      description: ["Configure the connection to a local courier"],
+      examples: ["courier"],
+    };
   }
 
   async publishToHubIfNotYet(options) {
     try {
-      const {port, caCrt} = options.env.courier
-      let id = options.env.courier.tunnel ? options.env.courier.tunnel.clientId : 0
-      this.prompt.loadingMessage = 'Publishing the courier'
-      this.prompt.loading()
-      let res = await this.callCourier({
-            action: {
-              name: 'publish'
-            },
-            id
+      const { port, caCrt } = options.env.courier;
+      let id = options.env.courier.tunnel
+        ? options.env.courier.tunnel.clientId
+        : 0;
+      this.prompt.loadingMessage = "Publishing the courier";
+      this.prompt.loading();
+      let res = await this.callCourier(
+        {
+          action: {
+            name: "publish",
           },
-          port,
-          caCrt,
-          '/admin'
-      )
-      this.prompt.showLoading = false
-      await sleep(100)
+          id,
+        },
+        port,
+        caCrt,
+        "/admin"
+      );
+      this.prompt.showLoading = false;
+      await sleep(100);
       try {
-        process.stdout.clearLine()
-      } catch(e) {
+        process.stdout.clearLine();
+      } catch (e) {
         // most likely we are running workspace testing
       }
       if (res.info.error) {
-        throw new Error(`The connection to the hub ${res.info.hub} is refused. Verify that your Secrez Courier is connecting to an active hub, please, and try again.`)
+        throw new Error(
+          `The connection to the hub ${res.info.hub} is refused. Verify that your Secrez Courier is connecting to an active hub, please, and try again.`
+        );
       } else {
-        return res.info
+        return res.info;
       }
     } catch (e) {
       // console.error(e)
-      throw new Error(e.message)
+      throw new Error(e.message);
     }
   }
 
   async isCourierReady(options) {
     if (!options.env) {
-      options.env = await ConfigUtils.getEnv(this.secrez.config)
+      options.env = await ConfigUtils.getEnv(this.secrez.config);
     }
     if (options.env.courier) {
-      const {port, caCrt} = options.env.courier
-      return await this.callCourier({action: {name: 'ready'}}, port, caCrt, '/admin')
+      const { port, caCrt } = options.env.courier;
+      return await this.callCourier(
+        { action: { name: "ready" } },
+        port,
+        caCrt,
+        "/admin"
+      );
     } else {
-      throw new Error('No courier set up yet.')
+      throw new Error("No courier set up yet.");
     }
   }
 
   async getRecentMessages(options = {}) {
-    const env = await ConfigUtils.getEnv(this.secrez.config)
+    const env = await ConfigUtils.getEnv(this.secrez.config);
     if (!env.messages) {
-      env.messages = {}
+      env.messages = {};
     }
-    this.lastRead = env.messages.lastRead || 0
+    this.lastRead = env.messages.lastRead || 0;
     if (env.courier) {
-      const {port, caCrt} = env.courier
-      const payload = Object.assign({
-        minTimestamp: this.lastRead
-      }, options)
-      let messages = await this.callCourier(payload, port, caCrt, '/messages')
+      const { port, caCrt } = env.courier;
+      const payload = Object.assign(
+        {
+          minTimestamp: this.lastRead,
+        },
+        options
+      );
+      let messages = await this.callCourier(payload, port, caCrt, "/messages");
       for (let message of messages.result) {
-        this.lastRead = Math.max(this.lastRead, message.timestamp + 1)
+        this.lastRead = Math.max(this.lastRead, message.timestamp + 1);
       }
-      env.messages.lastRead = this.lastRead
-      await ConfigUtils.putEnv(this.secrez.config, env)
-      return messages.result.map(e => this.decryptMessage(e))
+      env.messages.lastRead = this.lastRead;
+      await ConfigUtils.putEnv(this.secrez.config, env);
+      return messages.result.map((e) => this.decryptMessage(e));
     } else {
-      throw new Error('No courier set up yet.')
+      throw new Error("No courier set up yet.");
     }
   }
 
   async getSomeMessages(options = {}) {
-    const env = await ConfigUtils.getEnv(this.secrez.config)
+    const env = await ConfigUtils.getEnv(this.secrez.config);
     if (env.courier) {
-      const {port, caCrt} = env.courier
-      const payload = options.payload
-      let messages = await this.callCourier(payload, port, caCrt, '/messages')
-      return messages.result.map(e => this.decryptMessage(e))
+      const { port, caCrt } = env.courier;
+      const payload = options.payload;
+      let messages = await this.callCourier(payload, port, caCrt, "/messages");
+      return messages.result.map((e) => this.decryptMessage(e));
     } else {
-      throw new Error('No courier set up yet.')
+      throw new Error("No courier set up yet.");
     }
   }
 
   decryptMessage(message) {
-    message.decrypted = this.secrez.decryptSharedData(JSON.parse(message.payload).message, message.publickey)
-    return message
+    message.decrypted = this.secrez.decryptSharedData(
+      JSON.parse(message.payload).message,
+      message.publickey
+    );
+    return message;
   }
 
   async preInit(options) {
-    const env = options.env
-    let ready
+    const env = options.env;
+    let ready;
     if (env.courier && env.courier.port) {
-      let body = await this.isCourierReady(options)
-      ready = body.success
+      let body = await this.isCourierReady(options);
+      ready = body.success;
       if (ready) {
-        env.courier.caCrt = body.caCrt
+        env.courier.caCrt = body.caCrt;
         if (!body.tunnel.url) {
-          body.tunnel = await this.publishToHubIfNotYet(options)
+          body.tunnel = await this.publishToHubIfNotYet(options);
         }
-        env.courier.tunnel = body.tunnel
-        await ConfigUtils.putEnv(this.secrez.config, env)
-        options.ready = true
+        env.courier.tunnel = body.tunnel;
+        await ConfigUtils.putEnv(this.secrez.config, env);
+        options.ready = true;
       }
     }
   }
 
   async initCourier(options) {
-    const env = options.env = await ConfigUtils.getEnv(this.secrez.config)
-    await this.preInit(options)
-    if (process.env.NODE_ENV === 'test') {
-      return await this.setUpCorier(options)
+    const env = (options.env = await ConfigUtils.getEnv(this.secrez.config));
+    await this.preInit(options);
+    if (process.env.NODE_ENV === "test") {
+      return await this.setUpCorier(options);
     }
     if (options.ready) {
-      this.Logger.reset(`A courier is already set and is listening on port ${env.courier.port}`)
+      this.Logger.reset(
+        `A courier is already set and is listening on port ${env.courier.port}`
+      );
     } else {
       let yes = await this.useConfirm({
-        message: 'No Secrez Courier configured yet.\nDid you launch one?',
-        default: true
-      })
+        message: "No Secrez Courier configured yet.\nDid you launch one?",
+        default: true,
+      });
       if (yes) {
         options.port = await this.useInput({
-          message: 'Which port the courier is listening to?'
-        })
+          message: "Which port the courier is listening to?",
+        });
         if (options.port) {
-          await this.setUpCorier(options)
+          await this.setUpCorier(options);
         } else {
-          this.Logger.grey('Operation canceled')
+          this.Logger.grey("Operation canceled");
         }
       } else {
-        this.Logger.grey('Operation canceled')
+        this.Logger.grey("Operation canceled");
       }
     }
   }
 
   async setUpCorier(options) {
-    const port = options.port
+    const port = options.port;
     try {
-      const body = await this.callCourier({action: {name: 'ready'}}, port, undefined, '/admin')
+      const body = await this.callCourier(
+        { action: { name: "ready" } },
+        port,
+        undefined,
+        "/admin"
+      );
       if (body.success) {
-        let previousTunnel
+        let previousTunnel;
         if (options.env.courier && options.env.courier.port === port) {
-          previousTunnel = options.env.courier.tunnel
+          previousTunnel = options.env.courier.tunnel;
         }
         options.env.courier = {
           port,
           caCrt: body.caCrt,
-          tunnel: previousTunnel
-        }
-        body.tunnel = await this.publishToHubIfNotYet(options)
-        options.env.courier.tunnel = body.tunnel
-        await ConfigUtils.putEnv(this.secrez.config, options.env)
-        this.Logger.reset('Connected')
+          tunnel: previousTunnel,
+        };
+        body.tunnel = await this.publishToHubIfNotYet(options);
+        options.env.courier.tunnel = body.tunnel;
+        await ConfigUtils.putEnv(this.secrez.config, options.env);
+        this.Logger.reset("Connected");
       } else {
-        throw new Error('Courier not found')
+        throw new Error("Courier not found");
       }
-    } catch(e) {
-      throw new Error('Courier not available')
+    } catch (e) {
+      throw new Error("Courier not available");
     }
   }
 
   async courier(options) {
-    return this.initCourier(options)
+    return this.initCourier(options);
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
-      await this.courier(options)
+      await this.courier(options);
     } catch (e) {
       // console.error(e)
-      this.Logger.red(e.message)
+      this.Logger.red(e.message);
     }
-    await this.prompt.run()
+    await this.prompt.run();
   }
 }
 
-module.exports = Conf
-
-
+module.exports = Conf;

package/src/commands/Ds.js

@@ -1,152 +1,164 @@
-class Ds extends require('../Command') {
-
+class Ds extends require("../Command") {
   setHelpAndCompletion() {
     this.cliConfig.completion.ds = {
       _func: this.selfCompletion(this),
-      _self: this
-    }
-    this.cliConfig.completion.help.ds = true
+      _self: this,
+    };
+    this.cliConfig.completion.help.ds = true;
     this.optionDefinitions = [
       {
-        name: 'help',
-        alias: 'h',
-        type: Boolean
+        name: "help",
+        alias: "h",
+        type: Boolean,
       },
       {
-        name: 'list',
-        alias: 'l',
-        type: Boolean
+        name: "list",
+        alias: "l",
+        type: Boolean,
       },
       {
-        name: 'create',
-        alias: 'c',
-        type: String
+        name: "create",
+        alias: "c",
+        type: String,
       },
       {
-        name: 'rename',
-        alias: 'r',
+        name: "rename",
+        alias: "r",
         multiple: true,
-        type: String
+        type: String,
       },
       {
-        name: 'delete',
-        alias: 'd',
-        type: String
-      }
-    ]
+        name: "delete",
+        alias: "d",
+        type: String,
+      },
+    ];
   }
 
   help() {
     return {
-      description: ['Manages datasets'],
+      description: ["Manages datasets"],
       examples: [
-        ['ds -l', 'lists all datasets'],
-        ['ds -c archive', 'create the dataset named "archive";', 'if the dataset does not exists it creates it'],
-        ['ds -r archive unused', 'if the "archive" dataset exists, renames it "unused"'],
-        ['ds -d cryptos', 'deletes the dataset "cryptos" if it exists']
-
-      ]
-    }
+        ["ds -l", "lists all datasets"],
+        [
+          "ds -c archive",
+          'create the dataset named "archive";',
+          "if the dataset does not exists it creates it",
+        ],
+        [
+          "ds -r archive unused",
+          'if the "archive" dataset exists, renames it "unused"',
+        ],
+        ["ds -d cryptos", 'deletes the dataset "cryptos" if it exists'],
+      ],
+    };
   }
 
   async exists(set) {
-    let datasetsInfo = await this.internalFs.getDatasetsInfo()
+    let datasetsInfo = await this.internalFs.getDatasetsInfo();
     for (let dataset of datasetsInfo) {
       if (dataset.name.toLowerCase() === set.toLowerCase()) {
-        return dataset.index
+        return dataset.index;
       }
     }
-    return -1
+    return -1;
   }
 
   async ds(options) {
-    let datasetsInfo = await this.internalFs.getDatasetsInfo()
+    let datasetsInfo = await this.internalFs.getDatasetsInfo();
     if (options.rename) {
-      let name = options.rename[0]
-      let newName = options.rename[1]
-      this.internalFs.tree.validateDatasetName(newName)
-      let index = await this.exists(name)
+      let name = options.rename[0];
+      let newName = options.rename[1];
+      this.internalFs.tree.validateDatasetName(newName);
+      let index = await this.exists(name);
       if (index >= 0) {
-        if (['main', 'trash'].includes(name)) {
-          throw new Error('main and trash cannot be renamed')
+        if (["main", "trash"].includes(name)) {
+          throw new Error("main and trash cannot be renamed");
         }
         if ((await this.exists(newName)) >= 0) {
-          throw new Error(`A dataset named ${newName} already exists`)
+          throw new Error(`A dataset named ${newName} already exists`);
         }
-        await this.internalFs.trees[index].nameDataset(newName)
-        this.internalFs.updateTreeCache(index, newName)
-        return `The dataset ${name} has been renamed ${newName}`
+        await this.internalFs.trees[index].nameDataset(newName);
+        this.internalFs.updateTreeCache(index, newName);
+        return `The dataset ${name} has been renamed ${newName}`;
       }
     } else if (options.create) {
-      let newName = options.create
+      let newName = options.create;
       if ((await this.exists(newName)) >= 0) {
-        throw new Error(`A dataset named ${newName} already exists`)
+        throw new Error(`A dataset named ${newName} already exists`);
       }
-      this.internalFs.tree.validateDatasetName(newName)
-      let index = datasetsInfo[datasetsInfo.length - 1].index + 1
-      await this.internalFs.mountTree(index, true)
-      await this.internalFs.tree.nameDataset(newName)
-      return `The dataset ${newName} has been created`
+      this.internalFs.tree.validateDatasetName(newName);
+      let index = datasetsInfo[datasetsInfo.length - 1].index + 1;
+      await this.internalFs.mountTree(index, true);
+      await this.internalFs.tree.nameDataset(newName);
+      return `The dataset ${newName} has been created`;
     } else if (options.delete) {
-      let name = options.delete
-      let index = await this.exists(name)
+      let name = options.delete;
+      let index = await this.exists(name);
       if (index < 0) {
-        throw new Error(`A dataset named ${name} does not exist`)
+        throw new Error(`A dataset named ${name} does not exist`);
       }
       if (index === this.internalFs.treeIndex) {
-        return 'You can not delete the active dataset'
+        return "You can not delete the active dataset";
       }
       let list = await this.prompt.commands.ls.ls({
-        path: `${name}:/`
-      })
-      if (list.length > 0 && process.env.NODE_ENV !== 'test') {
+        path: `${name}:/`,
+      });
+      if (list.length > 0 && process.env.NODE_ENV !== "test") {
         let yes = await this.useConfirm({
           message: `The dataset ${name} contains files. Are you sure you want to delete it?`,
-          default: false
-        })
+          default: false,
+        });
         if (!yes) {
-          return 'Operation canceled'
+          return "Operation canceled";
         }
       }
       for (let file of list) {
         await this.prompt.commands.mv.mv({
           path: `${name}:/${file}`,
-          newPath: 'trash:/'
-        })
+          newPath: "trash:/",
+        });
       }
       if (this.internalFs.deleteDataset(index)) {
-        return `The dataset ${name} has been canceled. Its content has been moved to the "trash" dataset`
+        return `The dataset ${name} has been canceled. Its content has been moved to the "trash" dataset`;
       } else {
-        throw new Error('Unknown error')
+        throw new Error("Unknown error");
       }
     } else if (options.list) {
-      return (await this.internalFs.getDatasetsInfo()).map(e => e.name)
+      return (await this.internalFs.getDatasetsInfo()).map((e) => e.name);
     }
-    throw new Error('Wrong parameters')
+    throw new Error("Wrong parameters");
   }
 
   async exec(options = {}) {
     if (options.help) {
-      return this.showHelp()
+      return this.showHelp();
     }
     try {
       if (!Object.keys(options).length) {
-        options.list = true
+        options.list = true;
       }
-      this.validate(options)
-      let result = await this.ds(options)
+      this.validate(options);
+      let result = await this.ds(options);
       if (result) {
         if (options.list) {
-          this.Logger.reset(this.prompt.commandPrompt.formatList(result, 26, true, this.threeRedDots()))
+          this.Logger.reset(
+            this.prompt.commandPrompt.formatList(
+              result,
+              26,
+              true,
+              this.threeRedDots()
+            )
+          );
         } else {
-          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 = Ds
+module.exports = Ds;