favacli 0.0.17 → 0.0.19

package/build/BaseCommand.d.mts

@@ -2,9 +2,15 @@ import { Command } from 'clipanion';
 import type { Jsonifiable } from 'type-fest';
 import type { LockedRepresentationString, TwoFaLib } from 'favalib';
 import { Settings } from './utils/init.mjs';
+export interface ErrorInCommand {
+    timestamp: number;
+    message: string;
+}
 declare abstract class BaseCommand extends Command {
     abstract exec(): Promise<Jsonifiable>;
     abstract requireTwoFaLib: boolean;
+    errors: ErrorInCommand[];
+    preFormattedOutput: boolean;
     json: boolean | undefined;
     verbose: boolean | undefined;
     lockedRepresentationString: LockedRepresentationString;
@@ -12,5 +18,6 @@ declare abstract class BaseCommand extends Command {
     twoFaLib: TwoFaLib;
     output(string: string): void;
     execute(): Promise<number>;
+    private addError;
 }
 export default BaseCommand;

package/build/BaseCommand.mjs

@@ -4,6 +4,8 @@ import init from './utils/init.mjs';
 class BaseCommand extends Command {
     constructor() {
         super(...arguments);
+        this.errors = [];
+        this.preFormattedOutput = false;
         this.json = Option.Boolean('--json', {
             description: 'output as json',
         });
@@ -20,21 +22,35 @@ class BaseCommand extends Command {
         const { lockedRepresentationString, settings } = await init();
         this.settings = settings;
         if (lockedRepresentationString && this.requireTwoFaLib) {
-            this.twoFaLib = await loadVault(lockedRepresentationString, settings, this.verbose);
+            this.twoFaLib = await loadVault(lockedRepresentationString, settings, this.addError.bind(this), this.verbose);
         }
         else {
             if (this.requireTwoFaLib) {
                 throw new Error('No vault loaded, was it created?');
             }
         }
-        const json = await this.exec();
-        if (this.json) {
-            this.context.stdout.write(JSON.stringify(json, null, 2) + '\n');
-        }
+        const result = await this.exec();
         if (this.twoFaLib?.sync) {
             this.twoFaLib.sync.closeServerConnection();
         }
+        if (this.json) {
+            // output is already formatted, don't add the result & errors bit
+            if (this.preFormattedOutput) {
+                this.context.stdout.write(JSON.stringify(result, null, 2) + '\n');
+            }
+            else {
+                this.context.stdout.write(JSON.stringify({ result, errors: this.errors }, null, 2) + '\n');
+            }
+        }
         return 0;
     }
+    addError(err) {
+        if (this.json && !this.verbose) {
+            this.errors.push({ timestamp: Date.now(), message: err.message });
+        }
+        else {
+            console.error(err);
+        }
+    }
 }
 export default BaseCommand;

package/build/BaseListOutputCommand.d.mts

@@ -1,8 +1,9 @@
 import type { EntryMeta, EntryMetaWithToken } from 'favalib';
 import BaseCommand from './BaseCommand.mjs';
+import type { ErrorInCommand } from './BaseCommand.mjs';
 import formatters from './formatters/index.mjs';
 import { Jsonifiable } from 'type-fest';
-export type Formatter = (entries: (EntryMeta | EntryMetaWithToken)[]) => Jsonifiable;
+export type Formatter = (entries: (EntryMeta | EntryMetaWithToken)[], errors: ErrorInCommand[]) => Jsonifiable;
 declare abstract class BaseListOutputCommand extends BaseCommand {
     abstract getList(): EntryMeta[] | EntryMetaWithToken[];
     format: (typeof formatters)[0]["name"] | undefined;

package/build/BaseListOutputCommand.mjs

@@ -13,6 +13,7 @@ class BaseListOutputCommand extends BaseCommand {
     }
     // eslint-disable-next-line @typescript-eslint/require-await
     async exec() {
+        this.preFormattedOutput = this.format !== undefined;
         let formatter = (json) => json;
         if (this.format) {
             const selectedFormatter = formattersMap.get(this.format);
@@ -24,10 +25,10 @@ class BaseListOutputCommand extends BaseCommand {
         const list = this.getList();
         if (list.length === 0) {
             this.context.stdout.write('No entries\n');
-            return formatter([]);
+            return formatter([], this.errors);
         }
         this.output(generateEntriesTable(list));
-        return formatter(list);
+        return formatter(list, this.errors);
     }
 }
 export default BaseListOutputCommand;

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

@@ -0,0 +1,12 @@
+import BaseCommand from '../../BaseCommand.mjs';
+declare class GetInfoCommand extends BaseCommand {
+    static paths: string[][];
+    requireTwoFaLib: boolean;
+    static usage: import("clipanion").Usage;
+    exec(): Promise<{
+        connected: boolean;
+        friendlyName: string;
+        serverUrl: string;
+    }>;
+}
+export default GetInfoCommand;

package/build/commands/sync/getInfo.mjs

@@ -0,0 +1,27 @@
+import BaseCommand from '../../BaseCommand.mjs';
+class GetInfoCommand extends BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.requireTwoFaLib = true;
+    }
+    static { this.paths = [['sync', 'get-info']]; }
+    static { this.usage = BaseCommand.Usage({
+        category: 'Sync',
+        description: 'Get sync info for the current device',
+        details: `This command returns the friendly name and sync server URL for the current device in your vault sync configuration.`,
+        examples: [['Get sync info', 'sync get-info']],
+    }); }
+    exec() {
+        if (!this.twoFaLib.sync) {
+            throw new Error('No server url set');
+        }
+        const connected = this.twoFaLib.sync.webSocketConnected || false;
+        const friendlyName = this.twoFaLib.meta.deviceFriendlyName || '(none)';
+        const serverUrl = this.twoFaLib.sync.serverUrl || '(none)';
+        this.output(`Connected: ${connected ? 'yes' : 'no'}\n`);
+        this.output(`Device friendly name: ${friendlyName}\n`);
+        this.output(`Sync server URL: ${serverUrl}\n`);
+        return Promise.resolve({ connected, friendlyName, serverUrl });
+    }
+}
+export default GetInfoCommand;

package/build/formatters/alfred.mjs

@@ -1,8 +1,15 @@
-const alfredFormatter = (entries) => ({
-    items: entries.map((entry) => ({
+const alfredFormatter = (entries, errors) => {
+    const items = entries.map((entry) => ({
         title: entry.issuer,
         subtitle: entry.name,
         arg: entry.token?.otp,
-    })),
-});
+    }));
+    if (errors) {
+        items.unshift({
+            title: `Favacli encountered ${errors.length} errors while processing your command`,
+            subtitle: errors.map((e, i) => `[${i}]: ${e.message}`).join(' '),
+        });
+    }
+    return { items: items };
+};
 export default { name: 'alfred', formatter: alfredFormatter };

package/build/main.mjs

@@ -11,6 +11,7 @@ import SyncResilver from './commands/sync/resilver.mjs';
 import SyncListDevices from './commands/sync/listDevices.mjs';
 import SyncSetFriendlyNameCommand from './commands/sync/setFriendlyName.mjs';
 import ExportTextCommand from './commands/export/text.mjs';
+import SyncGetInfoCommand from './commands/sync/getInfo.mjs';
 // check node version
 const nodeRuntimeMajorVersion = parseInt(process.version.split('.')[0]);
 if (nodeRuntimeMajorVersion < 20) {
@@ -20,7 +21,7 @@ const [, , ...args] = process.argv;
 const cli = new Cli({
     binaryLabel: 'FavaCli',
     binaryName: `favacli`,
-    binaryVersion: '0.0.17',
+    binaryVersion: '0.0.18',
 });
 cli.register(VaultCreateCommand);
 cli.register(VaultDeleteCommand);
@@ -33,5 +34,6 @@ cli.register(SyncResilver);
 cli.register(SyncListDevices);
 cli.register(ExportTextCommand);
 cli.register(SyncSetFriendlyNameCommand);
+cli.register(SyncGetInfoCommand);
 cli.register(Builtins.HelpCommand);
 void cli.runExit(args);

package/build/utils/loadVault.d.mts

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

package/build/utils/loadVault.mjs

@@ -3,7 +3,7 @@ import keytar from 'keytar';
 import { getTwoFaLibVaultCreationUtils, TwoFaLibEvent, } from 'favalib';
 import NodeCryptoProvider from 'favalib/cryptoProviders/node';
 const cryptoLib = new NodeCryptoProvider();
-const loadVault = async (vaultData, settings, verbose = false) => {
+const loadVault = async (vaultData, settings, addError, verbose = false) => {
     const saveFunction = async (newLockedRepresentationString) => {
         const tempFile = `${settings.vaultLocation}.tmp`;
         const backupFile = `${settings.vaultLocation}.backup`;
@@ -34,8 +34,12 @@ 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.Log, (ev) => {
+        if (ev.detail.severity === 'warning') {
+            addError(new Error(ev.detail.message));
+            return;
+        }
         if (ev.detail.severity !== 'info' || verbose) {
-            console.log(ev.detail);
+            console.log(ev.detail.message);
         }
     });
     await twoFaLib.ready;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "favacli",
-  "version": "0.0.17",
+  "version": "0.0.19",
   "description": "",
   "type": "module",
   "author": "",
@@ -10,7 +10,7 @@
     "bufferutil": "^4.0.9",
     "clipanion": "^4.0.0-rc.4",
     "env-paths": "^3.0.0",
-    "favalib": "^0.0.10",
+    "favalib": "^0.0.11",
     "keytar": "^7.9.0",
     "tty-table": "^4.2.3",
     "typanion": "^3.14.0"