secrez 2.1.14 → 2.1.16

package/README.md

@@ -368,6 +368,15 @@ Secrez is not intended to compete with password managers, so do not expect it to
 
 ## History
 
+**2.1.16**
+
+- remove legacy second-factor handling from the CLI (`Welcome`, `Conf`)
+- refactor `git` command tests to use a local bare repository instead of a private GitHub remote (no SSH keys or external setup required)
+
+**2.1.15**
+
+- add `find -R` to look for recent entries only. With `-l` to set a limit (default 10)
+
 **2.1.14**
 
 - reverse changes done in version 2.1.12

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "secrez",
-  "version": "2.1.14",
+  "version": "2.1.16",
   "license": "MIT",
   "nyc": {
     "include": "src",
     "exclude": []
   },
   "dependencies": {
-    "@secrez/core": "~1.0.6",
-    "@secrez/crypto": "~1.0.5",
+    "@secrez/core": "~1.0.7",
+    "@secrez/crypto": "~1.0.6",
     "@secrez/eth": "~0.0.5",
     "@secrez/fs": "~1.0.8",
     "@secrez/utils": "~1.0.5",
@@ -29,7 +29,7 @@
     "tiny-cli-editor": "^0.1.1"
   },
   "devDependencies": {
-    "@secrez/test-helpers": "~2.0.1",
+    "@secrez/test-helpers": "~2.0.2",
     "chai": "^4.5.0",
     "chalk": "^3.0.0",
     "cross-env": "^7.0.3",

package/src/Welcome.js

@@ -96,9 +96,6 @@ Thanks.`);
           }
           return 0;
         } catch (e) {
-          if (e.message === "A second factor is required") {
-            return 1;
-          }
           Logger.red(`${e.message}.Try again or Ctrl - C to exit.`);
         }
       } catch (e) {

package/src/commands/Conf.js

@@ -43,16 +43,6 @@ class Conf extends require("../Command") {
     };
   }
 
-  async getAllFactors() {
-    let allFactors = {};
-    const conf = this.secrez.getConf();
-    let keys = conf.data.keys || {};
-    for (let authenticator in keys) {
-      allFactors[authenticator] = keys[authenticator].type;
-    }
-    return allFactors;
-  }
-
   async showConf(options) {
     const env = await ConfigUtils.getEnv(this.secrez.config);
     this.Logger.reset(chalk.grey("Container: ") + this.secrez.config.container);
@@ -86,10 +76,6 @@ class Conf extends require("../Command") {
         "Changing password and number of iterations in the same operation not allowed"
       );
     }
-    let haveSomeFactors = false;
-    if (Object.keys(await this.getAllFactors()).length) {
-      haveSomeFactors = true;
-    }
     let message =
       "Are you sure you want to upgrade your " +
       (pw ? "password" : "number of iterations") +
@@ -140,11 +126,6 @@ class Conf extends require("../Command") {
               this.Logger.reset(
                 'In case you have doubts about it, please, "cat" the file and take a look before exiting.'
               );
-              if (haveSomeFactors) {
-                this.Logger.yellow(
-                  "All the second factors have been unregistered."
-                );
-              }
               return;
             }
           }

package/src/commands/Find.js

@@ -1,5 +1,7 @@
 const chalk = require("chalk");
 const { Node } = require("@secrez/fs");
+const { config } = require("@secrez/core");
+const Crypto = require("@secrez/crypto");
 
 class Find extends require("../Command") {
   setHelpAndCompletion() {
@@ -56,6 +58,18 @@ class Find extends require("../Command") {
         type: Boolean,
         hint: "If global, search also in trash",
       },
+      {
+        name: "recent",
+        alias: "R",
+        type: Boolean,
+        hint: "Search for recent changes",
+      },
+      {
+        name: "limit",
+        alias: "l",
+        type: Number,
+        hint: "Limit the number of results (default: 10 when recent is enabled)",
+      },
     ];
   }
 
@@ -83,11 +97,69 @@ class Find extends require("../Command") {
           "Search scanning all the versions in all the datasets",
         ],
         ["find archive:allet", "Search allet in the archive dataset"],
+        ["find -R", "Show the 10 most recent changes"],
+        ["find -R -l 20", "Show the 20 most recent changes"],
       ],
     };
   }
 
   async find(options) {
+    // Handle recent mode
+    if (options.recent) {
+      // Set default limit if not specified by user
+      if (options.limit === undefined) {
+        options.limit = 10;
+      }
+      // In recent mode, ignore keywords completely - just show the N most recent entries
+      options.name = undefined;
+      options.keywords = undefined;
+
+      if (options.global) {
+        let datasetInfo = await this.internalFs.getDatasetsInfo();
+        let allResults = [];
+        for (let dataset of datasetInfo) {
+          if (options.global && !options.trashToo && dataset.index === 1) {
+            continue;
+          }
+          await this.internalFs.mountTree(dataset.index);
+          options.tree = this.internalFs.trees[dataset.index];
+          options.dataset = dataset.name;
+          // Collect raw results (with ts property) for sorting across datasets
+          let rawResults = await this._findRecentRaw(options);
+          allResults = allResults.concat(rawResults);
+        }
+        // Sort all results together by timestamp and limit
+        allResults.sort((a, b) => {
+          return Node.sortEntry(a.ts, b.ts);
+        });
+        if (allResults.length > options.limit) {
+          allResults = allResults.slice(0, options.limit);
+        }
+        // Format results
+        return allResults.map((e) => {
+          let result = [
+            Node.hashVersion(e.ts),
+            e.path + (e.isDir ? "/" : ""),
+            e.name,
+            undefined,
+          ];
+          // Store timestamp for date formatting in recent mode
+          result.ts = e.ts;
+          if (e.dataset) {
+            result[1] = e.dataset + ":" + result[1];
+          }
+          return result;
+        });
+      } else {
+        let data = await this.internalFs.getTreeIndexAndPath(".");
+        // Don't set dataset for non-global search (matches regular find behavior)
+        // Dataset prefix is only shown when searching globally
+        options.tree = data.tree;
+        return await this._findRecent(options);
+      }
+    }
+
+    // Regular find mode
     if (!options.name && options.keywords) {
       options.name = options.keywords;
     }
@@ -133,20 +205,155 @@ class Find extends require("../Command") {
     });
   }
 
+  async _findRecent(options) {
+    let rawResults = await this._findRecentRaw(options);
+
+    // Sort by timestamp (most recent first) and limit
+    rawResults.sort((a, b) => {
+      return Node.sortEntry(a.ts, b.ts);
+    });
+
+    // Limit results
+    if (rawResults.length > options.limit) {
+      rawResults = rawResults.slice(0, options.limit);
+    }
+
+    // Format results to match regular find output
+    return rawResults.map((e) => {
+      let result = [
+        Node.hashVersion(e.ts),
+        e.path + (e.isDir ? "/" : ""),
+        e.name,
+        undefined,
+      ];
+      // Store timestamp for date formatting in recent mode
+      result.ts = e.ts;
+      // Only add dataset prefix if dataset is set (which happens in global mode)
+      if (options.dataset) {
+        result[1] = options.dataset + ":" + result[1];
+      }
+      return result;
+    });
+  }
+
+  async _findRecentRaw(options) {
+    let start = options.tree[options.root ? "root" : "workingNode"];
+    let results = [];
+
+    // Recursively collect all entries with their timestamps (no keyword filtering in recent mode)
+    await this._collectRecentEntries(start, results, options, null);
+
+    // Add dataset info to results for global mode
+    if (options.dataset) {
+      results = results.map((e) => {
+        e.dataset = options.dataset;
+        return e;
+      });
+    }
+
+    return results;
+  }
+
+  async _collectRecentEntries(node, results, options, re) {
+    // Skip root node
+    if (Node.isRoot(node)) {
+      // Process children
+      if (node.children) {
+        for (let id in node.children) {
+          await this._collectRecentEntries(
+            node.children[id],
+            results,
+            options,
+            re
+          );
+        }
+      }
+      return;
+    }
+
+    // Process current node if it has versions
+    if (node.versions && node.lastTs) {
+      let name = node.getName();
+      let path = node.getPath();
+      let isDir = Node.isDir(node);
+
+      // Filter by keywords if provided
+      if (re) {
+        if (re.test(name)) {
+          results.push({
+            ts: node.lastTs,
+            name: name,
+            path: path,
+            isDir: isDir,
+          });
+        } else if (
+          options.content &&
+          Node.isFile(node) &&
+          node.type === config.types.TEXT &&
+          options.tree
+        ) {
+          // Check content if content option is enabled
+          try {
+            let { content } = await options.tree.getEntryDetails(
+              node,
+              node.lastTs
+            );
+            if (re.test(content || "")) {
+              results.push({
+                ts: node.lastTs,
+                name: name,
+                path: path,
+                isDir: isDir,
+              });
+            }
+          } catch (e) {
+            // Ignore errors when reading content
+          }
+        }
+      } else {
+        // No keyword filter, include all entries
+        results.push({
+          ts: node.lastTs,
+          name: name,
+          path: path,
+          isDir: isDir,
+        });
+      }
+    }
+
+    // Process children
+    if (node.children) {
+      for (let id in node.children) {
+        await this._collectRecentEntries(
+          node.children[id],
+          results,
+          options,
+          re
+        );
+      }
+    }
+  }
+
   formatResult(result, re) {
-    if (re.test(result)) {
+    if (re && re.test(result)) {
       return result.replace(re, (a) => chalk.bold(a));
     } else {
       return result;
     }
   }
 
+  formatDate(ts) {
+    let dateArray = Crypto.fromTsToDate(ts);
+    let date = dateArray[0].split("Z")[0].split("T")[0]; // Get YYYY-MM-DD format
+    return chalk.cyan(date);
+  }
+
   formatIndex(len, i) {
     return " ".repeat(len.toString().length - i.toString().length) + i;
   }
 
   formatList(list, options) {
-    let re = Node.getFindRe(options);
+    let re = options.name ? Node.getFindRe(options) : null;
     let i = 0;
     const setCache = (i, e) => {
       this.prompt.setCache("findResult", i, e);
@@ -159,7 +366,7 @@ class Find extends require("../Command") {
         let l = p.length;
         let c = p[l - 1] ? p[l - 1] : p[l - 2];
         if (e[2] && e[2] !== c) {
-          e[2] = this.formatResult(e[2], re, options.name);
+          e[2] = re ? this.formatResult(e[2], re, options.name) : e[2];
         } else {
           e[2] = undefined;
         }
@@ -169,13 +376,29 @@ class Find extends require("../Command") {
           "  ",
           chalk.yellow(e[0]),
           "  ",
-          this.formatResult(e[1], re, options.name),
+          re ? this.formatResult(e[1], re, options.name) : e[1],
           "  ",
           e[2],
         ].join("");
       } else {
         setCache(i, e);
-        return [k, "  ", this.formatResult(e[1], re, options.name)].join("");
+        // In recent mode, show date before the path
+        if (options.recent && e.ts) {
+          let dateStr = this.formatDate(e.ts);
+          return [
+            k,
+            "  ",
+            dateStr,
+            "  ",
+            re ? this.formatResult(e[1], re, options.name) : e[1],
+          ].join("");
+        } else {
+          return [
+            k,
+            "  ",
+            re ? this.formatResult(e[1], re, options.name) : e[1],
+          ].join("");
+        }
       }
     });
   }
@@ -186,8 +409,8 @@ class Find extends require("../Command") {
     }
     try {
       this.validate(options);
-      options.name = options.keywords;
-      if (options.name) {
+      // In recent mode, keywords are ignored - just show recent entries
+      if (options.recent) {
         try {
           this.lastResult = await this.find(options);
           let list = this.formatList(this.lastResult, options);
@@ -203,7 +426,26 @@ class Find extends require("../Command") {
           this.Logger.red(e.message);
         }
       } else {
-        this.Logger.grey("Missing parameters");
+        // Regular find mode requires keywords
+        options.name = options.keywords;
+        if (options.name) {
+          try {
+            this.lastResult = await this.find(options);
+            let list = this.formatList(this.lastResult, options);
+            if (list && list.length) {
+              this.Logger.grey(
+                `${list.length} result${list.length > 1 ? "s" : ""} found:`
+              );
+              for (let l of list) this.Logger.reset(l);
+            } else {
+              this.Logger.grey("No results.");
+            }
+          } catch (e) {
+            this.Logger.red(e.message);
+          }
+        } else {
+          this.Logger.grey("Missing parameters");
+        }
       }
     } catch (e) {
       this.Logger.red(e.message);