error-ux-cli 1.0.0

package/README.md

@@ -0,0 +1,7 @@
+# Project
+
+## 🚀 Changelog
+
+v1 - final test verdict
+v1 - final
+v1 - hi bye

package/index.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+const readline = require('readline');
+const commands = require('./lib/commands');
+const utils = require('./lib/utils');
+const storage = require('./lib/storage');
+const auth = require('./lib/auth');
+
+async function main() {
+    utils.loadEnv();
+    const args = process.argv.slice(2);
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: 'error-ux > '
+    });
+
+    try {
+        let config = await storage.loadConfig();
+
+        // 1. Onboarding
+        if (!config || !config.users || Object.keys(config.users).length === 0) {
+            config = await commands.initOnboarding(rl);
+        }
+
+        // 2. Multi-User Login
+        const usernames = Object.keys(config.users);
+        let targetUser = config.activeUser;
+
+        if (usernames.length > 1) {
+            console.log('\nProfiles: ' + usernames.join(', '));
+            const selected = await commands.askQuestion(rl, 'Username: ');
+            if (!config.users[selected]) {
+                console.error('error');
+                process.exit(1);
+            }
+            targetUser = selected;
+        }
+
+        let authenticated = false;
+        let attempts = 0;
+        const storedHash = config.users[targetUser].password_hash;
+        
+        while (!authenticated && attempts < 3) {
+            const pwd = await auth.askPassword(rl, `Password (${targetUser}): `);
+            if (auth.verifyPassword(pwd, storedHash)) {
+                authenticated = true;
+                config.activeUser = targetUser;
+                await commands.ensureUserNewsApiKey(rl, config, config.users[targetUser], {forcePrompt: true});
+                await storage.saveConfig(config);
+            } else {
+                attempts++;
+                if (attempts >= 3) {
+                    console.error('error');
+                    process.exit(1);
+                }
+                console.log('Incorrect password.');
+            }
+        }
+
+        // 3. Execution
+        if (args.length > 0) {
+            try {
+                await processInput(rl, args.join(' '), true);
+            } catch (err) {
+                console.error('error');
+            }
+            rl.close();
+        } else {
+            try {
+                await commands.handleDashboard(rl);
+            } catch (err) {
+                console.error('error');
+            }
+            rl.prompt();
+
+            rl.on('line', async (line) => {
+                try {
+                    await processInput(rl, line.trim(), false);
+                } catch (err) {
+                    console.error('error');
+                }
+                rl.prompt();
+            }).on('close', () => {
+                console.log('\nExiting error-ux...');
+                process.exit(0);
+            });
+        }
+    } catch (err) {
+        console.error('error');
+        process.exit(1);
+    }
+}
+
+async function processInput(rl, input, isDirect) {
+    const trimmedInput = input.trim();
+    if (trimmedInput === '' || trimmedInput === 'help') {
+        await commands.handleMenu();
+        return;
+    }
+
+    const firstWord = trimmedInput.split(' ')[0].toLowerCase();
+    const restOfInput = trimmedInput.slice(firstWord.length).trim();
+
+    switch (firstWord) {
+        case 'user':
+            await commands.handleUser(rl, restOfInput);
+            break;
+        case 'export':
+        case 'export-data':
+            await commands.handleExport(rl, restOfInput);
+            break;
+        case 'import':
+        case 'import-data':
+            await commands.handleImport(rl, restOfInput);
+            break;
+        case 'link':
+            await commands.handleLink(rl);
+            break;
+        case 'links':
+            await commands.handleLinks();
+            break;
+        case 'unlink':
+            await commands.handleUnlink(rl, restOfInput);
+            break;
+        case 'push':
+            await commands.handlePush(rl, restOfInput);
+            break;
+        case 'news':
+            await commands.handleNews(rl, restOfInput);
+            break;
+        case 'todo':
+            await commands.handleTodo(rl, restOfInput);
+            break;
+        case 'repo':
+            await commands.handleRepo(rl, restOfInput);
+            break;
+        case 'uninstall':
+            await commands.handleUninstall(rl);
+            break;
+        case 'exit':
+            rl.close();
+            break;
+        default:
+            const found = await commands.handleShortcut(firstWord);
+            if (!found && trimmedInput !== '') {
+                console.error('error');
+            }
+            break;
+    }
+}
+
+main();

package/lib/auth.js

@@ -0,0 +1,52 @@
+const crypto = require('crypto');
+
+/**
+ * Hashes a password using scryptSync.
+ * Returns salt:hash format.
+ */
+function hashPassword(password) {
+    const salt = crypto.randomBytes(16).toString('hex');
+    const hash = crypto.scryptSync(password, salt, 64).toString('hex');
+    return `${salt}:${hash}`;
+}
+
+/**
+ * Verifies a password against a salt:hash string.
+ */
+function verifyPassword(password, storedValue) {
+    if (!storedValue || !storedValue.includes(':')) return false;
+    const [salt, hash] = storedValue.split(':');
+    if (!salt || !hash) return false;
+    const derivedHash = crypto.scryptSync(password, salt, 64).toString('hex');
+    return derivedHash === hash;
+}
+
+/**
+ * Prompts for password with input masking.
+ */
+function askPassword(rl, query = 'Password: ') {
+    return new Promise((resolve) => {
+        // We override _writeToOutput on the internal readline output stream
+        const originalWrite = rl.output.write;
+        rl.output.write = (string) => {
+            // Only mask actual characters, not the prompt itself or newlines
+            if (string === query) return originalWrite.apply(rl.output, [string]);
+            if (string === '\n' || string === '\r\n') return originalWrite.apply(rl.output, [string]);
+            
+            // Masking character
+            return originalWrite.apply(rl.output, ['*']);
+        };
+
+        rl.question(query, (password) => {
+            rl.output.write = originalWrite; // Restore original write
+            console.log(''); // New line after entry
+            resolve(password);
+        });
+    });
+}
+
+module.exports = {
+    hashPassword,
+    verifyPassword,
+    askPassword
+};