favacli 0.0.6 → 0.0.9

package/build/BaseCommand.mjs

@@ -19,12 +19,12 @@ class BaseCommand extends Command {
     async execute() {
         const { lockedRepresentationString, settings } = await init();
         this.settings = settings;
-        if (lockedRepresentationString) {
-            this.twoFaLib = await loadVault(lockedRepresentationString, this.verbose);
+        if (lockedRepresentationString && this.requireTwoFaLib) {
+            this.twoFaLib = await loadVault(lockedRepresentationString, settings, this.verbose);
         }
         else {
             if (this.requireTwoFaLib) {
-                throw new Error('TwoFaLib is required');
+                throw new Error('No vault loaded, was it created?');
             }
         }
         const json = await this.exec();

package/build/commands/entries/add.d.mts

@@ -1,6 +1,7 @@
 import BaseCommand from '../../BaseCommand.mjs';
 declare class EntriesAddCommand extends BaseCommand {
     static paths: string[][];
+    static usage: import("clipanion").Usage;
     requireTwoFaLib: boolean;
     name: string;
     issuer: string;

package/build/commands/entries/add.mjs

@@ -12,6 +12,25 @@ class EntriesAddCommand extends BaseCommand {
         this.algorithm = Option.String('--algorithm', 'SHA-1');
     }
     static { this.paths = [['entries', 'add']]; }
+    static { this.usage = BaseCommand.Usage({
+        category: 'Entries',
+        description: 'Add a new TOTP entry to the vault',
+        details: `
+      This command adds a new time-based one-time password (TOTP) entry to your vault.
+
+      The secret must be provided in base32 format.
+    `,
+        examples: [
+            [
+                'Add a basic TOTP entry',
+                'entries add --name "My Account" --issuer "Example.com" --secret JBSWY3DPEHPK3PXP',
+            ],
+            [
+                'Add a TOTP entry with custom period and digits',
+                'entries add --name "Custom Account" --issuer "Example.com" --secret AAAAAAAA --period 60 --digits 8',
+            ],
+        ],
+    }); }
     async exec() {
         await this.twoFaLib.vault.addEntry({
             name: this.name,

package/build/commands/entries/list.d.mts

@@ -1,6 +1,7 @@
 import BaseCommand from '../../BaseCommand.mjs';
 declare class EntriesListCommand extends BaseCommand {
     static paths: string[][];
+    static usage: import("clipanion").Usage;
     requireTwoFaLib: boolean;
     withTokens: boolean | undefined;
     exec(): Promise<0 | readonly import("type-fest").JsonValue[]>;

package/build/commands/entries/list.mjs

@@ -10,6 +10,19 @@ class EntriesListCommand extends BaseCommand {
         });
     }
     static { this.paths = [['entries', 'list']]; }
+    static { this.usage = BaseCommand.Usage({
+        category: 'Entries',
+        description: 'List all stored 2FA entries',
+        details: `
+      This command displays a table of all stored two-factor authentication entries.
+      
+      When used with --withTokens, it will also show the current TOTP codes for each entry.
+    `,
+        examples: [
+            ['List all entries', 'entries list'],
+            ['List entries with current TOTP tokens', 'entries list --withTokens'],
+        ],
+    }); }
     async exec() {
         let entries;
         if (this.withTokens) {

package/build/commands/entries/search.d.mts

@@ -2,6 +2,7 @@ import type { JsonArray } from 'type-fest';
 import BaseCommand from '../../BaseCommand.mjs';
 declare class EntriesSearchCommand extends BaseCommand {
     static paths: string[][];
+    static usage: import("clipanion").Usage;
     requireTwoFaLib: boolean;
     withTokens: boolean | undefined;
     query: string;

package/build/commands/entries/search.mjs

@@ -11,6 +11,23 @@ class EntriesSearchCommand extends BaseCommand {
         this.query = Option.String({ required: true });
     }
     static { this.paths = [['entries', 'search']]; }
+    static { this.usage = BaseCommand.Usage({
+        category: 'Entries',
+        description: 'Search for stored 2FA entries',
+        details: `
+      This command searches through all stored two-factor authentication entries.
+      
+      The search query will match against entry names and issuers.
+      When used with --withTokens, it will also show the current TOTP codes for matching entries.
+    `,
+        examples: [
+            ['Search for entries containing "google"', 'entries search google'],
+            [
+                'Search and show current TOTP tokens',
+                'entries search google --withTokens',
+            ],
+        ],
+    }); }
     async exec() {
         let filteredEntries;
         if (this.withTokens) {

package/build/commands/sync/connect.d.mts

@@ -2,6 +2,7 @@ import BaseCommand from '../../BaseCommand.mjs';
 declare class ConnectCommand extends BaseCommand {
     static paths: string[][];
     requireTwoFaLib: boolean;
+    static usage: import("clipanion").Usage;
     exec(): Promise<{
         success: boolean;
     }>;

package/build/commands/sync/connect.mjs

@@ -7,6 +7,16 @@ class ConnectCommand extends BaseCommand {
         this.requireTwoFaLib = true;
     }
     static { this.paths = [['sync', 'connect']]; }
+    static { this.usage = BaseCommand.Usage({
+        category: 'Sync',
+        description: 'Connect to an existing vault using a connection string',
+        details: `
+      This command allows you to connect to an existing vault by providing a connection string.
+      
+      The connection string should be obtained from the device that hosts the vault you want to connect to.
+    `,
+        examples: [['Connect to an existing vault', 'sync connect']],
+    }); }
     async exec() {
         if (!this.twoFaLib.sync) {
             throw new Error('No server url set');

package/build/commands/sync/setServerUrl.d.mts

@@ -1,6 +1,7 @@
 import BaseCommand from '../../BaseCommand.mjs';
 declare class SetServerUrlCommand extends BaseCommand {
     static paths: string[][];
+    static usage: import("clipanion").Usage;
     requireTwoFaLib: boolean;
     serverUrl: string;
     exec(): Promise<{

package/build/commands/sync/setServerUrl.mjs

@@ -7,6 +7,18 @@ class SetServerUrlCommand extends BaseCommand {
         this.serverUrl = Option.String({ required: true });
     }
     static { this.paths = [['sync', 'setServerUrl']]; }
+    static { this.usage = BaseCommand.Usage({
+        category: 'Sync',
+        description: 'Set the server URL for syncing',
+        details: `
+      This command sets the URL of the server that will be used for syncing.
+      
+      The server URL must be provided as an argument.
+    `,
+        examples: [
+            ['Set sync server URL', 'sync setServerUrl https://example.com'],
+        ],
+    }); }
     async exec() {
         await this.twoFaLib.setSyncServerUrl(this.serverUrl);
         return { success: true };

package/build/commands/vault/create.d.mts

@@ -2,6 +2,7 @@ import BaseCommand from '../../BaseCommand.mjs';
 declare class VaultCreateCommand extends BaseCommand {
     static paths: string[][];
     requireTwoFaLib: boolean;
+    static usage: import("clipanion").Usage;
     exec(): Promise<{
         success: boolean;
     }>;

package/build/commands/vault/create.mjs

@@ -12,6 +12,17 @@ class VaultCreateCommand extends BaseCommand {
         this.requireTwoFaLib = false;
     }
     static { this.paths = [['vault', 'create']]; }
+    static { this.usage = BaseCommand.Usage({
+        category: 'Vault',
+        description: 'Create a new encrypted vault',
+        details: `
+      This command creates a new encrypted vault file to store your 2FA entries.
+
+      You will be prompted to enter a passphrase that will be used to encrypt the vault.
+      The passphrase will be securely stored in your system's keychain.
+    `,
+        examples: [['Create a new vault', 'vault create']],
+    }); }
     async exec() {
         const passphrase = (await password({
             message: 'Enter your vault passphrase:',
@@ -19,11 +30,11 @@ class VaultCreateCommand extends BaseCommand {
         }));
         const { twoFaLib } = await twoFaLibVaultCreationUtils.createNewTwoFaLibVault(passphrase);
         twoFaLib.addEventListener(TwoFaLibEvent.Changed, (ev) => {
-            return fs.writeFile('vault.json', ev.detail.newLockedRepresentationString);
+            return fs.writeFile(this.settings.vaultLocation, ev.detail.newLockedRepresentationString);
         });
         await Promise.all([
             twoFaLib.forceSave(),
-            keytar.setPassword('2falib', 'vault-passphrase', passphrase),
+            keytar.setPassword('favacli', 'vault-passphrase', passphrase),
         ]);
         return { success: true };
     }

package/build/commands/vault/delete.d.mts

@@ -0,0 +1,14 @@
+import BaseCommand from '../../BaseCommand.mjs';
+declare class VaultDeleteCommand extends BaseCommand {
+    static paths: string[][];
+    requireTwoFaLib: boolean;
+    static usage: import("clipanion").Usage;
+    exec(): Promise<{
+        success: boolean;
+        cancelled: boolean;
+    } | {
+        success: boolean;
+        cancelled?: undefined;
+    }>;
+}
+export default VaultDeleteCommand;

package/build/commands/vault/delete.mjs

@@ -0,0 +1,33 @@
+import fs from 'node:fs/promises';
+import { confirm } from '@inquirer/prompts';
+import BaseCommand from '../../BaseCommand.mjs';
+class VaultDeleteCommand extends BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.requireTwoFaLib = false;
+    }
+    static { this.paths = [['vault', 'delete']]; }
+    static { this.usage = BaseCommand.Usage({
+        category: 'Vault',
+        description: 'Delete the current vault',
+        details: `
+      This command deletes the current vault file.
+      You will be asked to confirm before deletion.
+    `,
+        examples: [['Delete the current vault', 'vault delete']],
+    }); }
+    async exec() {
+        const shouldDelete = await confirm({
+            message: 'Are you sure you want to delete the vault? This action cannot be undone.',
+            default: false,
+        });
+        if (!shouldDelete) {
+            this.output('Vault deletion cancelled.\n');
+            return { success: false, cancelled: true };
+        }
+        await fs.rm(this.settings.vaultLocation);
+        this.output('Vault deleted successfully.\n');
+        return { success: true };
+    }
+}
+export default VaultDeleteCommand;

package/build/main.mjs

@@ -1,21 +1,29 @@
 #!/usr/bin/env node
-import { Cli } from 'clipanion';
+import { Cli, Builtins } from 'clipanion';
 import VaultCreateCommand from './commands/vault/create.mjs';
+import VaultDeleteCommand from './commands/vault/delete.mjs';
 import EntriesAddCommand from './commands/entries/add.mjs';
 import EntriesListCommand from './commands/entries/list.mjs';
 import EntriesSearchCommand from './commands/entries/search.mjs';
 import SyncSetServerUrlCommand from './commands/sync/setServerUrl.mjs';
 import SyncConnect from './commands/sync/connect.mjs';
-const [node, app, ...args] = process.argv;
+// check node version
+const nodeRuntimeMajorVersion = parseInt(process.version.split('.')[0]);
+if (nodeRuntimeMajorVersion < 20) {
+    throw new Error('Node.js version must be 20 or higher');
+}
+const [, , ...args] = process.argv;
 const cli = new Cli({
-    binaryLabel: `My Application`,
-    binaryName: `${node} ${app}`,
-    binaryVersion: `1.0.0`,
+    binaryLabel: 'FavaCli',
+    binaryName: `favacli`,
+    binaryVersion: '0.0.8',
 });
 cli.register(VaultCreateCommand);
+cli.register(VaultDeleteCommand);
 cli.register(EntriesAddCommand);
 cli.register(EntriesListCommand);
 cli.register(EntriesSearchCommand);
 cli.register(SyncSetServerUrlCommand);
 cli.register(SyncConnect);
+cli.register(Builtins.HelpCommand);
 void cli.runExit(args);

package/build/utils/init.d.mts

@@ -1,8 +1,9 @@
 import type { LockedRepresentationString } from 'favalib';
-import type { EmptyObject } from 'type-fest';
-export type Settings = EmptyObject;
+export interface Settings {
+    vaultLocation: string;
+}
 declare const init: () => Promise<{
-    settings: EmptyObject;
+    settings: Settings;
     lockedRepresentationString: LockedRepresentationString;
 }>;
 export default init;

package/build/utils/init.mjs

@@ -1,5 +1,9 @@
 import fs from 'node:fs/promises';
-const defaultSettings = {};
+import path from 'node:path';
+import envPaths from 'env-paths';
+const getDefaultSettings = () => ({
+    vaultLocation: path.join(envPaths('favacli').data, 'vault.json'),
+});
 const readFile = async (path) => {
     try {
         return (await fs.readFile(path)).toString();
@@ -18,13 +22,21 @@ const readJSONFile = async (path) => {
     }
     return JSON.parse(contents);
 };
+const ensureDirectoriesExists = async (...paths) => {
+    for (const p of paths) {
+        const directory = path.dirname(p);
+        await fs.mkdir(directory, { recursive: true });
+    }
+};
 const init = async () => {
-    let settings = await readJSONFile('settings.json');
+    const settingsLocation = path.join(envPaths('favacli').config, 'settings.json');
+    let settings = await readJSONFile(settingsLocation);
     if (!settings) {
-        settings = defaultSettings;
-        await fs.writeFile('settings.json', JSON.stringify(settings, null, 2));
+        settings = getDefaultSettings();
+        await ensureDirectoriesExists(settingsLocation, settings.vaultLocation);
+        await fs.writeFile(settingsLocation, JSON.stringify(settings, null, 2));
     }
-    const lockedRepresentationString = (await readFile('vault.json'));
+    const lockedRepresentationString = (await readFile(settings.vaultLocation));
     return { settings, lockedRepresentationString };
 };
 export default init;

package/build/utils/loadVault.d.mts

@@ -1,3 +1,4 @@
 import { type LockedRepresentationString } from 'favalib';
-declare const loadVault: (vaultData: LockedRepresentationString, verbose?: boolean) => Promise<import("favalib").TwoFaLib>;
+import { Settings } from './init.mjs';
+declare const loadVault: (vaultData: LockedRepresentationString, settings: Settings, verbose?: boolean) => Promise<import("favalib").TwoFaLib>;
 export default loadVault;

package/build/utils/loadVault.mjs

@@ -4,11 +4,11 @@ import { getTwoFaLibVaultCreationUtils, TwoFaLibEvent, } from 'favalib';
 import NodeCryptoProvider from 'favalib/cryptoProviders/node';
 const cryptoLib = new NodeCryptoProvider();
 const twoFaLibVaultCreationUtils = getTwoFaLibVaultCreationUtils(cryptoLib, 'cli', ['cli']);
-const loadVault = async (vaultData, verbose = false) => {
-    const passphrase = (await keytar.getPassword('2falib', 'vault-passphrase'));
+const loadVault = async (vaultData, settings, verbose = false) => {
+    const passphrase = (await keytar.getPassword('favacli', 'vault-passphrase'));
     const twoFaLib = await twoFaLibVaultCreationUtils.loadTwoFaLibFromLockedRepesentation(vaultData, passphrase);
     twoFaLib.addEventListener(TwoFaLibEvent.Changed, (ev) => {
-        return fs.writeFile('vault.json', ev.detail.newLockedRepresentationString);
+        return fs.writeFile(settings.vaultLocation, ev.detail.newLockedRepresentationString);
     });
     twoFaLib.addEventListener(TwoFaLibEvent.Log, (ev) => {
         if (ev.detail.severity !== 'info' || verbose) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "favacli",
-  "version": "0.0.6",
+  "version": "0.0.9",
   "description": "",
   "type": "module",
   "author": "",
@@ -9,7 +9,8 @@
     "@inquirer/prompts": "^7.0.1",
     "bufferutil": "^4.0.8",
     "clipanion": "^4.0.0-rc.4",
-    "favalib": "^0.0.1",
+    "env-paths": "^3.0.0",
+    "favalib": "^0.0.2",
     "keytar": "^7.9.0",
     "node-loader": "^2.0.0",
     "ts-loader": "^9.5.1",
@@ -25,5 +26,8 @@
   },
   "files": [
     "/build"
-  ]
+  ],
+  "engines": {
+    "node": ">=20"
+  }
 }