favacli 0.0.2 → 0.0.4

package/build/BaseCommand.d.mts

@@ -0,0 +1,16 @@
+import { Command } from 'clipanion';
+import type { Jsonifiable } from 'type-fest';
+import type { LockedRepresentationString, TwoFaLib } from 'favalib';
+import { Settings } from './utils/init.mjs';
+declare abstract class BaseCommand extends Command {
+    abstract exec(): Promise<Jsonifiable>;
+    abstract requireTwoFaLib: boolean;
+    json: boolean | undefined;
+    verbose: boolean | undefined;
+    lockedRepresentationString: LockedRepresentationString;
+    settings: Settings;
+    twoFaLib: TwoFaLib;
+    output(string: string): void;
+    execute(): Promise<number>;
+}
+export default BaseCommand;

package/build/BaseCommand.mjs

@@ -0,0 +1,40 @@
+import { Command, Option } from 'clipanion';
+import loadVault from './utils/loadVault.mjs';
+import init from './utils/init.mjs';
+class BaseCommand extends Command {
+    constructor() {
+        super(...arguments);
+        this.json = Option.Boolean('--json', {
+            description: 'output as json',
+        });
+        this.verbose = Option.Boolean('--verbose', {
+            description: 'verbose output',
+        });
+    }
+    output(string) {
+        if (!this.json) {
+            this.context.stdout.write(string);
+        }
+    }
+    async execute() {
+        const { lockedRepresentationString, settings } = await init();
+        this.settings = settings;
+        if (lockedRepresentationString) {
+            this.twoFaLib = await loadVault(lockedRepresentationString, this.verbose);
+        }
+        else {
+            if (this.requireTwoFaLib) {
+                throw new Error('TwoFaLib is required');
+            }
+        }
+        const json = await this.exec();
+        if (this.json) {
+            this.context.stdout.write(JSON.stringify(json, null, 2) + '\n');
+        }
+        if (this.twoFaLib?.sync) {
+            this.twoFaLib.sync.closeServerConnection();
+        }
+        return 0;
+    }
+}
+export default BaseCommand;

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

@@ -0,0 +1,15 @@
+import BaseCommand from '../../BaseCommand.mjs';
+declare class EntriesAddCommand extends BaseCommand {
+    static paths: string[][];
+    requireTwoFaLib: boolean;
+    name: string;
+    issuer: string;
+    secret: string;
+    period: string;
+    digits: string;
+    algorithm: string;
+    exec(): Promise<{
+        success: boolean;
+    }>;
+}
+export default EntriesAddCommand;

package/build/commands/entries/add.mjs

@@ -0,0 +1,31 @@
+import { Option } from 'clipanion';
+import BaseCommand from '../../BaseCommand.mjs';
+class EntriesAddCommand extends BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.requireTwoFaLib = true;
+        this.name = Option.String('--name', { required: true });
+        this.issuer = Option.String('--issuer', { required: true });
+        this.secret = Option.String('--secret', { required: true });
+        this.period = Option.String('--period', '30');
+        this.digits = Option.String('--digits', '6');
+        this.algorithm = Option.String('--algorithm', 'SHA-1');
+    }
+    static { this.paths = [['entries', 'add']]; }
+    async exec() {
+        await this.twoFaLib.vault.addEntry({
+            name: this.name,
+            issuer: this.issuer,
+            type: 'TOTP',
+            payload: {
+                secret: this.secret,
+                period: Number.parseInt(this.period, 10),
+                digits: Number.parseInt(this.digits, 10),
+                algorithm: this.algorithm,
+            },
+        });
+        this.output('Entry added!');
+        return { success: true };
+    }
+}
+export default EntriesAddCommand;

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

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

package/build/commands/entries/list.mjs

@@ -0,0 +1,29 @@
+import { Option } from 'clipanion';
+import BaseCommand from '../../BaseCommand.mjs';
+import generateEntriesTable from '../../utils/generateEntriesTable.mjs';
+class EntriesListCommand extends BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.requireTwoFaLib = true;
+        this.withTokens = Option.Boolean('--withTokens', {
+            description: 'Include current TOTP tokens in the output',
+        });
+    }
+    static { this.paths = [['entries', 'list']]; }
+    async exec() {
+        let entries;
+        if (this.withTokens) {
+            entries = this.twoFaLib.vault.listEntriesMetas(true);
+        }
+        else {
+            entries = this.twoFaLib.vault.listEntriesMetas(false);
+        }
+        if (entries.length === 0) {
+            this.context.stdout.write('No entries\n');
+            return 0;
+        }
+        this.output(generateEntriesTable(entries));
+        return Promise.resolve(entries);
+    }
+}
+export default EntriesListCommand;

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

@@ -0,0 +1,10 @@
+import type { JsonArray } from 'type-fest';
+import BaseCommand from '../../BaseCommand.mjs';
+declare class EntriesSearchCommand extends BaseCommand {
+    static paths: string[][];
+    requireTwoFaLib: boolean;
+    withTokens: boolean | undefined;
+    query: string;
+    exec(): Promise<JsonArray>;
+}
+export default EntriesSearchCommand;

package/build/commands/entries/search.mjs

@@ -0,0 +1,31 @@
+import { Option } from 'clipanion';
+import BaseCommand from '../../BaseCommand.mjs';
+import generateEntriesTable from '../../utils/generateEntriesTable.mjs';
+class EntriesSearchCommand extends BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.requireTwoFaLib = true;
+        this.withTokens = Option.Boolean('--withTokens', {
+            description: 'Include current TOTP tokens in the output',
+        });
+        this.query = Option.String({ required: true });
+    }
+    static { this.paths = [['entries', 'search']]; }
+    async exec() {
+        let filteredEntries;
+        if (this.withTokens) {
+            filteredEntries = this.twoFaLib.vault.searchEntriesMetas(this.query, true);
+        }
+        else {
+            filteredEntries = this.twoFaLib.vault.searchEntriesMetas(this.query, false);
+        }
+        if (filteredEntries.length === 0) {
+            this.output('No matching entries found.\n');
+            return [];
+        }
+        const out = generateEntriesTable(filteredEntries);
+        this.output(out);
+        return Promise.resolve(filteredEntries);
+    }
+}
+export default EntriesSearchCommand;

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

@@ -0,0 +1,9 @@
+import BaseCommand from '../../BaseCommand.mjs';
+declare class ConnectCommand extends BaseCommand {
+    static paths: string[][];
+    requireTwoFaLib: boolean;
+    exec(): Promise<{
+        success: boolean;
+    }>;
+}
+export default ConnectCommand;

package/build/commands/sync/connect.mjs

@@ -0,0 +1,27 @@
+import { input } from '@inquirer/prompts';
+import BaseCommand from '../../BaseCommand.mjs';
+import { TwoFaLibEvent } from 'favalib';
+class ConnectCommand extends BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.requireTwoFaLib = true;
+    }
+    static { this.paths = [['sync', 'connect']]; }
+    async exec() {
+        if (!this.twoFaLib.sync) {
+            throw new Error('No server url set');
+        }
+        const connectionString = await input({
+            message: 'Enter connection string:',
+        });
+        const connectFinished = new Promise((resolve) => {
+            this.twoFaLib.addEventListener(TwoFaLibEvent.ConnectToExistingVaultFinished, () => {
+                resolve();
+            });
+        });
+        await this.twoFaLib.sync.respondToAddDeviceFlow(connectionString, 'text');
+        await connectFinished;
+        return { success: true };
+    }
+}
+export default ConnectCommand;

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

@@ -0,0 +1,10 @@
+import BaseCommand from '../../BaseCommand.mjs';
+declare class SetServerUrlCommand extends BaseCommand {
+    static paths: string[][];
+    requireTwoFaLib: boolean;
+    serverUrl: string;
+    exec(): Promise<{
+        success: boolean;
+    }>;
+}
+export default SetServerUrlCommand;

package/build/commands/sync/setServerUrl.mjs

@@ -0,0 +1,15 @@
+import { Option } from 'clipanion';
+import BaseCommand from '../../BaseCommand.mjs';
+class SetServerUrlCommand extends BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.requireTwoFaLib = true;
+        this.serverUrl = Option.String({ required: true });
+    }
+    static { this.paths = [['sync', 'setServerUrl']]; }
+    async exec() {
+        await this.twoFaLib.setSyncServerUrl(this.serverUrl);
+        return { success: true };
+    }
+}
+export default SetServerUrlCommand;

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

@@ -0,0 +1,9 @@
+import BaseCommand from '../../BaseCommand.mjs';
+declare class VaultCreateCommand extends BaseCommand {
+    static paths: string[][];
+    requireTwoFaLib: boolean;
+    exec(): Promise<{
+        success: boolean;
+    }>;
+}
+export default VaultCreateCommand;

package/build/commands/vault/create.mjs

@@ -0,0 +1,31 @@
+import fs from 'node:fs/promises';
+import keytar from 'keytar';
+import BaseCommand from '../../BaseCommand.mjs';
+import { getTwoFaLibVaultCreationUtils, TwoFaLibEvent, } from 'favalib';
+import NodeCryptoProvider from 'favalib/cryptoProviders/node';
+import { password } from '@inquirer/prompts';
+const cryptoLib = new NodeCryptoProvider();
+const twoFaLibVaultCreationUtils = getTwoFaLibVaultCreationUtils(cryptoLib, 'cli', ['cli']);
+class VaultCreateCommand extends BaseCommand {
+    constructor() {
+        super(...arguments);
+        this.requireTwoFaLib = false;
+    }
+    static { this.paths = [['vault', 'create']]; }
+    async exec() {
+        const passphrase = (await password({
+            message: 'Enter your vault passphrase:',
+            mask: '*',
+        }));
+        const { twoFaLib } = await twoFaLibVaultCreationUtils.createNewTwoFaLibVault(passphrase);
+        twoFaLib.addEventListener(TwoFaLibEvent.Changed, (ev) => {
+            return fs.writeFile('vault.json', ev.detail.newLockedRepresentationString);
+        });
+        await Promise.all([
+            twoFaLib.forceSave(),
+            keytar.setPassword('2falib', 'vault-passphrase', passphrase),
+        ]);
+        return { success: true };
+    }
+}
+export default VaultCreateCommand;

package/build/main.d.mts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/build/main.mjs

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { Cli } from 'clipanion';
+import VaultCreateCommand from './commands/vault/create.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;
+const cli = new Cli({
+    binaryLabel: `My Application`,
+    binaryName: `${node} ${app}`,
+    binaryVersion: `1.0.0`,
+});
+cli.register(VaultCreateCommand);
+cli.register(EntriesAddCommand);
+cli.register(EntriesListCommand);
+cli.register(EntriesSearchCommand);
+cli.register(SyncSetServerUrlCommand);
+cli.register(SyncConnect);
+void cli.runExit(args);

package/build/utils/generateEntriesTable.d.mts

@@ -0,0 +1,3 @@
+import type { EntryMeta, EntryMetaWithToken } from 'favalib';
+declare const generateEntriesTable: (entries: EntryMeta[] | EntryMetaWithToken[]) => string;
+export default generateEntriesTable;

package/build/utils/generateEntriesTable.mjs

@@ -0,0 +1,35 @@
+import Table from 'tty-table';
+const generateEntriesTable = (entries) => {
+    const headers = [
+        { value: 'Id', align: 'left', width: 30 },
+        { value: 'Name', align: 'left', width: 30 },
+        { value: 'Issuer', align: 'left', width: 20 },
+        { value: 'Added at', align: 'left', width: 36 },
+        { value: 'Updated at', align: 'left', width: 36 },
+    ];
+    const withTokens = entries[0].token;
+    if (withTokens) {
+        headers.push({ value: 'Token', align: 'left', width: 10 });
+    }
+    const rows = entries.map((entry) => {
+        const row = [
+            entry.id,
+            entry.name || '-',
+            entry.issuer || '-',
+            new Date(entry.addedAt).toLocaleString(),
+            entry.updatedAt ? new Date(entry.updatedAt).toLocaleString() : '-',
+        ];
+        if (withTokens) {
+            row.push(entry.token.otp);
+        }
+        return row;
+    });
+    const tableOptions = {
+        borderStyle: 'solid',
+        paddingLeft: 1,
+        paddingRight: 1,
+        headerAlign: 'left',
+    };
+    return Table(headers, rows, [], tableOptions).render() + '\n';
+};
+export default generateEntriesTable;

package/build/utils/init.d.mts

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

package/build/utils/init.mjs

@@ -0,0 +1,30 @@
+import fs from 'node:fs/promises';
+const defaultSettings = {};
+const readFile = async (path) => {
+    try {
+        return (await fs.readFile(path)).toString();
+    }
+    catch (err) {
+        if (err.code === 'ENOENT') {
+            return null;
+        }
+        throw err;
+    }
+};
+const readJSONFile = async (path) => {
+    const contents = await readFile(path);
+    if (!contents) {
+        return null;
+    }
+    return JSON.parse(contents);
+};
+const init = async () => {
+    let settings = await readJSONFile('settings.json');
+    if (!settings) {
+        settings = defaultSettings;
+        await fs.writeFile('settings.json', JSON.stringify(settings, null, 2));
+    }
+    const lockedRepresentationString = (await readFile('vault.json'));
+    return { settings, lockedRepresentationString };
+};
+export default init;

package/build/utils/loadVault.d.mts

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

package/build/utils/loadVault.mjs

@@ -0,0 +1,21 @@
+import fs from 'node:fs/promises';
+import keytar from 'keytar';
+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 twoFaLib = await twoFaLibVaultCreationUtils.loadTwoFaLibFromLockedRepesentation(vaultData, passphrase);
+    twoFaLib.addEventListener(TwoFaLibEvent.Changed, (ev) => {
+        return fs.writeFile('vault.json', ev.detail.newLockedRepresentationString);
+    });
+    twoFaLib.addEventListener(TwoFaLibEvent.Log, (ev) => {
+        if (ev.detail.severity !== 'info' || verbose) {
+            console.log(ev.detail);
+        }
+    });
+    await twoFaLib.ready;
+    return twoFaLib;
+};
+export default loadVault;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "favacli",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "",
   "type": "module",
   "author": "",
@@ -15,17 +15,16 @@
     "ts-loader": "^9.5.1",
     "tty-table": "^4.2.3",
     "typanion": "^3.14.0",
-    "utf-8-validate": "^6.0.5",
-    "webpack": "^5.96.1"
+    "utf-8-validate": "^6.0.5"
   },
   "devDependencies": {
     "type-fest": "^4.26.1",
     "webpack-cli": "^5.1.4"
   },
   "bin": {
-    "favacli": "bundle.js"
+    "favacli": "main.mjs"
   },
   "files": [
-    "dist/**"
+    "build/**"
   ]
 }