favacli 0.0.23 → 0.0.26

package/build/BaseCommand.d.mts

@@ -11,11 +11,14 @@ declare abstract class BaseCommand extends Command {
     abstract requireFavaLib: boolean;
     errors: ErrorInCommand[];
     preFormattedOutput: boolean;
-    json: boolean | undefined;
+    rawOutput: boolean;
+    format: string | undefined;
     verbose: boolean | undefined;
     lockedRepresentationString: LockedRepresentationString;
     settings: Settings;
     favaLib: FavaLib;
+    get machineOutput(): boolean;
+    protected validFormats(): string[];
     output(string: string): void;
     execute(): Promise<number>;
     private addError;

package/build/BaseCommand.mjs

@@ -6,19 +6,35 @@ class BaseCommand extends Command {
         super(...arguments);
         this.errors = [];
         this.preFormattedOutput = false;
-        this.json = Option.Boolean('--json', {
-            description: 'output as json',
+        // when true, exec()'s result is a raw string to write to stdout verbatim
+        // (no JSON.stringify, no escaping/trimming) — e.g. rofi script-mode output
+        this.rawOutput = false;
+        this.format = Option.String('--format', {
+            description: 'output format (e.g. json)',
         });
         this.verbose = Option.Boolean('--verbose', {
             description: 'verbose output',
         });
     }
+    // machine-readable mode: any --format suppresses human output and triggers
+    // serialized output
+    get machineOutput() {
+        return this.format !== undefined;
+    }
+    // the set of --format values this command accepts; subclasses extend it
+    validFormats() {
+        return ['json'];
+    }
     output(string) {
-        if (!this.json) {
+        if (!this.machineOutput) {
             this.context.stdout.write(string);
         }
     }
     async execute() {
+        if (this.format !== undefined &&
+            !this.validFormats().includes(this.format)) {
+            throw new Error(`Unknown format: ${this.format}. Valid formats: ${this.validFormats().join(', ')}`);
+        }
         const { lockedRepresentationString, settings } = await init();
         this.settings = settings;
         this.lockedRepresentationString = lockedRepresentationString;
@@ -34,10 +50,16 @@ class BaseCommand extends Command {
         if (this.favaLib?.sync) {
             this.favaLib.sync.closeServerConnection();
         }
-        if (this.json) {
+        if (this.machineOutput) {
             // output is already formatted, don't add the result & errors bit
             if (this.preFormattedOutput) {
-                this.context.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                if (this.rawOutput) {
+                    // raw passthrough: write the formatter's string exactly as-is
+                    this.context.stdout.write(result);
+                }
+                else {
+                    this.context.stdout.write(JSON.stringify(result, null, 2) + '\n');
+                }
             }
             else {
                 this.context.stdout.write(JSON.stringify({ result, errors: this.errors }, null, 2) + '\n');
@@ -46,7 +68,7 @@ class BaseCommand extends Command {
         return 0;
     }
     addError(err) {
-        if (this.json && !this.verbose) {
+        if (this.machineOutput && !this.verbose) {
             this.errors.push({ timestamp: Date.now(), message: err.message });
         }
         else {

package/build/BaseListOutputCommand.d.mts

@@ -1,12 +1,11 @@
 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)[], errors: ErrorInCommand[]) => Jsonifiable;
 declare abstract class BaseListOutputCommand extends BaseCommand {
     abstract getList(): Promise<(EntryMeta | EntryMetaWithToken)[]>;
-    format: (typeof formatters)[0]["name"] | undefined;
+    protected validFormats(): string[];
     exec(): Promise<string | number | boolean | {
         [x: string]: Jsonifiable | undefined;
     } | {

package/build/BaseListOutputCommand.mjs

@@ -1,29 +1,30 @@
-import { Option } from 'clipanion';
 import BaseCommand from './BaseCommand.mjs';
 import generateEntriesTable from './utils/generateEntriesTable.mjs';
 import formatters from './formatters/index.mjs';
-const formattersMap = new Map(formatters.map((f) => [f.name, f.formatter]));
+const formattersMap = new Map(formatters.map((f) => [f.name, f]));
 class BaseListOutputCommand extends BaseCommand {
-    constructor() {
-        super(...arguments);
-        // eslint-disable-next-line @typescript-eslint/no-unnecessary-type-assertion
-        this.format = Option.String('--format', {
-            description: 'formatter',
-        });
+    validFormats() {
+        return ['json', ...formatters.map((f) => f.name)];
     }
     async exec() {
-        this.preFormattedOutput = this.format !== undefined;
         let formatter = (json) => json;
-        if (this.format) {
+        // 'json' (and no --format) uses the default identity formatter and is
+        // wrapped in { result, errors } by BaseCommand; named formatters produce
+        // pre-formatted output instead
+        if (this.format && this.format !== 'json') {
             const selectedFormatter = formattersMap.get(this.format);
             if (!selectedFormatter) {
                 throw new Error(`Formatter ${this.format} not found`);
             }
-            formatter = selectedFormatter;
+            formatter = selectedFormatter.formatter;
+            this.preFormattedOutput = true;
+            this.rawOutput = 'raw' in selectedFormatter && selectedFormatter.raw;
         }
         const list = await this.getList();
         if (list.length === 0) {
-            this.context.stdout.write('No entries\n');
+            // output() suppresses this when --format is set, so it can't corrupt the
+            // machine-readable formatter output
+            this.output('No entries\n');
             return formatter([], this.errors);
         }
         this.output(generateEntriesTable(list));

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

@@ -0,0 +1,9 @@
+import BaseCommand from '../../BaseCommand.mjs';
+declare class EntriesGetTokenByIdCommand extends BaseCommand {
+    static paths: string[][];
+    static usage: import("clipanion").Usage;
+    requireFavaLib: boolean;
+    id: string;
+    exec(): Promise<string | null>;
+}
+export default EntriesGetTokenByIdCommand;

package/build/commands/entries/getTokenById.mjs

@@ -0,0 +1,39 @@
+import { Option } from 'clipanion';
+import { EntryNotFoundError } from 'favalib';
+import BaseCommand from '../../BaseCommand.mjs';
+class EntriesGetTokenByIdCommand extends BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.requireFavaLib = true;
+        this.id = Option.String({ required: true });
+    }
+    static { this.paths = [['entries', 'get-token-by-id']]; }
+    static { this.usage = BaseCommand.Usage({
+        category: 'Entries',
+        description: 'Get the current TOTP token for an entry by its id',
+        details: `
+      This command generates and prints the current TOTP code for a single
+      entry, identified by its id.
+    `,
+        examples: [
+            ['Get the current token for an entry', 'entries get-token-by-id <id>'],
+        ],
+    }); }
+    async exec() {
+        const id = this.id;
+        try {
+            const token = await this.favaLib.vault.generateTokenForEntry(id);
+            this.output(`${token.otp}\n`);
+            return token.otp;
+        }
+        catch (err) {
+            if (err instanceof EntryNotFoundError) {
+                this.output(`No entry found with id ${this.id}\n`);
+                this.errors.push({ timestamp: Date.now(), message: err.message });
+                return null;
+            }
+            throw err;
+        }
+    }
+}
+export default EntriesGetTokenByIdCommand;

package/build/formatters/index.d.mts

@@ -1,5 +1,9 @@
-declare const formatters: {
+declare const formatters: ({
     name: "alfred";
     formatter: import("../BaseListOutputCommand.mjs").Formatter;
-}[];
+} | {
+    name: "rofi";
+    formatter: import("../BaseListOutputCommand.mjs").Formatter;
+    raw: boolean;
+})[];
 export default formatters;

package/build/formatters/index.mjs

@@ -1,3 +1,4 @@
 import alfredFormatter from './alfred.mjs';
-const formatters = [alfredFormatter];
+import rofiFormatter from './rofi.mjs';
+const formatters = [alfredFormatter, rofiFormatter];
 export default formatters;

package/build/formatters/rofi.d.mts

@@ -0,0 +1,7 @@
+import { Formatter } from '../BaseListOutputCommand.mjs';
+declare const _default: {
+    name: "rofi";
+    formatter: Formatter;
+    raw: boolean;
+};
+export default _default;

package/build/formatters/rofi.mjs

@@ -0,0 +1,17 @@
+const NUL = '\0'; // separates display text from the row's options
+const US = '\x1f'; // separates option key/value pairs
+const rofiFormatter = (entries, errors) => {
+    const lines = [`${NUL}prompt${US}2FA`];
+    if (errors.length > 0) {
+        const msg = errors.map((e, i) => `[${i}] ${e.message}`).join(' ');
+        lines.push(`${NUL}message${US}${msg}`);
+    }
+    for (const entry of entries) {
+        const display = `${entry.issuer}: ${entry.name}`;
+        lines.push(`${display}${NUL}info${US}${entry.id}${US}meta${US}${entry.issuer} ${entry.name}`);
+    }
+    return lines.join('\n');
+};
+// raw: rofi script mode consumes line-based text with embedded control bytes,
+// so this output must be written to stdout verbatim, not JSON-stringified.
+export default { name: 'rofi', formatter: rofiFormatter, raw: true };

package/build/main.mjs

@@ -6,6 +6,7 @@ import VaultRestorePasswordCommand from './commands/vault/restorePassword.mjs';
 import EntriesAddCommand from './commands/entries/add.mjs';
 import EntriesListCommand from './commands/entries/list.mjs';
 import EntriesSearchCommand from './commands/entries/search.mjs';
+import EntriesGetTokenByIdCommand from './commands/entries/getTokenById.mjs';
 import SyncSetServerUrlCommand from './commands/sync/setServerUrl.mjs';
 import SyncConnect from './commands/sync/connect.mjs';
 import SyncResilver from './commands/sync/resilver.mjs';
@@ -23,7 +24,7 @@ const [, , ...args] = process.argv;
 const cli = new Cli({
     binaryLabel: 'FavaCli',
     binaryName: `favacli`,
-    binaryVersion: '0.0.23',
+    binaryVersion: '0.0.26',
 });
 cli.register(VaultCreateCommand);
 cli.register(VaultDeleteCommand);
@@ -31,6 +32,7 @@ cli.register(VaultRestorePasswordCommand);
 cli.register(EntriesAddCommand);
 cli.register(EntriesListCommand);
 cli.register(EntriesSearchCommand);
+cli.register(EntriesGetTokenByIdCommand);
 cli.register(SyncSetServerUrlCommand);
 cli.register(SyncConnect);
 cli.register(SyncResilver);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "favacli",
-  "version": "0.0.23",
+  "version": "0.0.26",
   "description": "",
   "type": "module",
   "author": "",
@@ -13,7 +13,7 @@
     "keytar": "^7.9.0",
     "tty-table": "^5.0.0",
     "typanion": "^3.14.0",
-    "favalib": "0.0.17"
+    "favalib": "0.0.18"
   },
   "devDependencies": {
     "type-fest": "^5.6.0"