meross-cli 0.1.0

package/cli/commands/status/hub-status.js

@@ -0,0 +1,72 @@
+'use strict';
+
+const chalk = require('chalk');
+const { displaySubdeviceStatus } = require('./subdevices');
+
+async function displayHubStatus(device, filterSubdeviceId = null) {
+    const subdevices = filterSubdeviceId
+        ? [device.getSubdevice(filterSubdeviceId)].filter(Boolean)
+        : device.getSubdevices();
+
+    if (subdevices.length === 0) {
+        if (filterSubdeviceId) {
+            console.log(`  Subdevice with ID "${filterSubdeviceId}" not found.\n`);
+        } else {
+            console.log('  No subdevices found\n');
+        }
+        return false;
+    }
+
+    // Refresh hub state to get latest subdevice data
+    try {
+        await device.refreshState();
+
+        // Also fetch battery data for sensors
+        try {
+            if (typeof device.getHubBattery === 'function') {
+                const batteryResponse = await device.getHubBattery();
+                if (batteryResponse && batteryResponse.battery && Array.isArray(batteryResponse.battery)) {
+                    for (const batteryData of batteryResponse.battery) {
+                        const subdeviceId = batteryData.id;
+                        const subdevice = device.getSubdevice(subdeviceId);
+                        if (subdevice && batteryData.value !== undefined && batteryData.value !== null &&
+                            batteryData.value !== 0xFFFFFFFF && batteryData.value !== -1) {
+                            subdevice._battery = batteryData.value;
+                        }
+                    }
+                }
+            }
+        } catch {
+            // Battery fetch failed, but continue anyway
+        }
+    } catch (error) {
+        // Silently fail - continue with cached data
+    }
+
+    if (!filterSubdeviceId) {
+        const subdeviceCount = device.getSubdevices().length;
+        console.log(`\n  ${chalk.white.bold(`Hub with ${chalk.cyan(subdeviceCount)} subdevice(s)`)}`);
+    }
+
+    let hasReadings = false;
+
+    for (const subdevice of subdevices) {
+        if (!subdevice) {continue;}
+
+        const subName = subdevice.name || subdevice.subdeviceId;
+        const subType = subdevice.type || 'unknown';
+        const subId = subdevice.subdeviceId;
+        console.log(`\n  ${chalk.bold('Subdevice')} ${chalk.bold(subName)} ${chalk.gray(`(${subType})`)}`);
+        console.log(`    ${chalk.bold('ID:')} ${chalk.cyan(chalk.italic(subId))}`);
+
+        const subdeviceHasReadings = displaySubdeviceStatus(subdevice);
+        if (subdeviceHasReadings) {
+            hasReadings = true;
+        }
+    }
+
+    return hasReadings;
+}
+
+module.exports = { displayHubStatus };
+

package/cli/commands/status/index.js

@@ -0,0 +1,50 @@
+'use strict';
+
+const chalk = require('chalk');
+const { MerossHubDevice, MerossSubDevice } = require('meross-iot');
+const { displayHubStatus } = require('./hub-status');
+const { displayDeviceStatus } = require('./device-status');
+
+async function getDeviceStatus(manager, filterUuid = null, filterSubdeviceId = null) {
+    const allDevices = filterUuid ? [manager.getDevice(filterUuid)].filter(Boolean) : manager.getAllDevices();
+    const devices = allDevices.filter(device => !(device instanceof MerossSubDevice));
+
+    if (devices.length === 0) {
+        console.log('No devices found.');
+        return;
+    }
+
+    for (const device of devices) {
+        if (!device) {continue;}
+
+        const deviceName = device.name || device.uuid || 'Unknown';
+        const deviceUuid = device.uuid || 'unknown';
+
+        console.log(`\n  ${chalk.bold(deviceName)} ${chalk.gray(`(${device.deviceType || 'unknown'})`)}`);
+        console.log(`    ${chalk.bold('UUID:')} ${chalk.cyan(chalk.italic(deviceUuid))}`);
+
+        if (!device.deviceConnected) {
+            console.log(`\n  ${chalk.yellow('Not connected - cannot read device status')}\n`);
+            continue;
+        }
+
+        let hasReadings = false;
+
+        // Check if it's a hub device with subdevices
+        if (device instanceof MerossHubDevice) {
+            hasReadings = await displayHubStatus(device, filterSubdeviceId);
+        } else {
+            // Regular device - display status based on abilities
+            hasReadings = await displayDeviceStatus(device);
+        }
+
+        if (!hasReadings) {
+            console.log(`\n  ${chalk.white.bold('No device status available')}`);
+        }
+
+        console.log('');
+    }
+}
+
+module.exports = { getDeviceStatus };
+

package/cli/commands/status/subdevices/hub-smoke-detector.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const chalk = require('chalk');
+const { SmokeAlarmStatus } = require('meross-iot');
+
+function displaySmokeDetectorStatus(subdevice) {
+    const status = subdevice.getSmokeAlarmStatus();
+    const interConn = subdevice.getInterConnStatus();
+    const battery = subdevice.getCachedBattery();
+
+    console.log(`\n    ${chalk.bold.underline('Sensors')}`);
+
+    if (battery !== null && battery !== undefined) {
+        console.log(`      ${chalk.white.bold('Battery')}: ${chalk.italic(`${battery}%`)}`);
+    }
+
+    let alarmStatus;
+    if (status === SmokeAlarmStatus.NORMAL ||
+        status === SmokeAlarmStatus.INTERCONNECTION_STATUS) {
+        alarmStatus = 'Safe';
+    } else if (status === SmokeAlarmStatus.MUTE_SMOKE_ALARM) {
+        alarmStatus = 'Smoke Alarm Muted';
+    } else if (status === SmokeAlarmStatus.MUTE_TEMPERATURE_ALARM) {
+        alarmStatus = 'Temperature Alarm Muted';
+    } else {
+        alarmStatus = `Status: ${status}`;
+    }
+    console.log(`      ${chalk.white.bold('Alarm')}: ${chalk.italic(alarmStatus)}`);
+
+    console.log(`\n    ${chalk.bold.underline('Configuration')}`);
+
+    console.log(`      ${chalk.white.bold('Error')}: ${chalk.italic('OK')}`);
+
+    if (interConn !== null && interConn !== undefined) {
+        console.log(`      ${chalk.white.bold('Interconn')}: ${chalk.italic(interConn)}`);
+    }
+
+    let mutedStatus = 'Off';
+    if (status === SmokeAlarmStatus.MUTE_SMOKE_ALARM) {
+        mutedStatus = 'Smoke Alarm';
+    } else if (status === SmokeAlarmStatus.MUTE_TEMPERATURE_ALARM) {
+        mutedStatus = 'Temperature Alarm';
+    }
+    console.log(`      ${chalk.white.bold('Muted')}: ${chalk.italic(mutedStatus)}`);
+
+    let overallStatus;
+    if (status === SmokeAlarmStatus.NORMAL ||
+        status === SmokeAlarmStatus.INTERCONNECTION_STATUS) {
+        overallStatus = 'No issues';
+    } else if (status === SmokeAlarmStatus.MUTE_SMOKE_ALARM) {
+        overallStatus = 'Smoke alarm muted';
+    } else if (status === SmokeAlarmStatus.MUTE_TEMPERATURE_ALARM) {
+        overallStatus = 'Temperature alarm muted';
+    } else {
+        overallStatus = `Status code: ${status}`;
+    }
+    console.log(`      ${chalk.white.bold('Status')}: ${chalk.italic(overallStatus)}`);
+
+    const lastUpdate = subdevice.getLastStatusUpdate();
+    if (lastUpdate !== null && lastUpdate !== undefined) {
+        const updateDate = new Date(lastUpdate * 1000);
+        console.log(`      ${chalk.white.bold('Last Update')}: ${chalk.italic(updateDate.toLocaleString())}`);
+    }
+
+    const testEvents = subdevice.getTestEvents();
+    if (testEvents && testEvents.length > 0) {
+        console.log(`      ${chalk.white.bold('Test Events')}: ${chalk.italic(testEvents.length)}`);
+        testEvents.slice(-3).forEach((event, idx) => {
+            const eventType = event.type === 1 ? 'Manual' : event.type === 2 ? 'Automatic' : `Type ${event.type}`;
+            const eventDate = event.timestamp ? new Date(event.timestamp * 1000).toLocaleString() : 'Unknown';
+            console.log(`        ${idx + 1}. ${eventType} - ${eventDate}`);
+        });
+        if (testEvents.length > 3) {
+            console.log(`        ... and ${testEvents.length - 3} more`);
+        }
+    }
+
+    return true;
+}
+
+module.exports = { displaySmokeDetectorStatus };
+

package/cli/commands/status/subdevices/hub-temp-hum-sensor.js

@@ -0,0 +1,43 @@
+'use strict';
+
+const chalk = require('chalk');
+
+function displayTempHumSensorStatus(subdevice) {
+    const temp = subdevice.getLastSampledTemperature();
+    const humidity = subdevice.getLastSampledHumidity();
+    const battery = subdevice.getCachedBattery();
+    const lux = subdevice.getLux && subdevice.getLux();
+    const sampleTime = subdevice.getLastSampledTime();
+
+    let hasReadings = false;
+
+    console.log(`\n    ${chalk.bold.underline('Sensors')}`);
+
+    if (temp !== null) {
+        console.log(`      ${chalk.white.bold('Temperature')}: ${chalk.italic(`${temp.toFixed(1)}°C`)}`);
+        hasReadings = true;
+    }
+    if (humidity !== null) {
+        console.log(`      ${chalk.white.bold('Humidity')}: ${chalk.italic(`${humidity.toFixed(1)}%`)}`);
+        hasReadings = true;
+    }
+    if (lux !== null && lux !== undefined) {
+        console.log(`      ${chalk.white.bold('Light')}: ${chalk.italic(`${lux} lx`)}`);
+        hasReadings = true;
+    }
+    if (battery !== null && battery !== undefined) {
+        console.log(`      ${chalk.white.bold('Battery')}: ${chalk.italic(`${battery}%`)}`);
+        hasReadings = true;
+    }
+
+    console.log(`\n    ${chalk.bold.underline('Configuration')}`);
+
+    if (sampleTime) {
+        console.log(`      ${chalk.white.bold('Last Sample')}: ${chalk.italic(sampleTime.toISOString())}`);
+    }
+
+    return hasReadings;
+}
+
+module.exports = { displayTempHumSensorStatus };
+

package/cli/commands/status/subdevices/hub-thermostat-valve.js

@@ -0,0 +1,83 @@
+'use strict';
+
+const chalk = require('chalk');
+const { ThermostatMode } = require('meross-iot');
+
+function displayThermostatValveStatus(subdevice) {
+    const temp = subdevice.getLastSampledTemperature();
+    const targetTemp = subdevice.getTargetTemperature();
+    const isHeating = subdevice.isHeating();
+    const battery = subdevice.getCachedBattery();
+    const mode = subdevice.getMode();
+    const isWindowOpen = subdevice.isWindowOpen();
+    const calibration = subdevice.getAdjust();
+    const comfortTemp = subdevice.getPresetTemperature('comfort');
+    const economyTemp = subdevice.getPresetTemperature('economy');
+    const awayTemp = subdevice.getPresetTemperature('away');
+    const customTemp = subdevice.getPresetTemperature('custom');
+
+    let hasReadings = false;
+
+    console.log(`\n    ${chalk.bold.underline('Sensors')}`);
+
+    if (temp !== null) {
+        console.log(`      ${chalk.white.bold('Temperature')}: ${chalk.italic(`${temp.toFixed(1)}°C`)}`);
+        hasReadings = true;
+    }
+
+    if (isWindowOpen !== null && isWindowOpen !== undefined) {
+        console.log(`      ${chalk.white.bold('Windowopened')}: ${chalk.italic(isWindowOpen ? 'Open' : 'Closed')}`);
+        hasReadings = true;
+    }
+
+    if (battery !== null && battery !== undefined) {
+        console.log(`      ${chalk.white.bold('Battery')}: ${chalk.italic(`${battery}%`)}`);
+        hasReadings = true;
+    }
+
+    console.log(`\n    ${chalk.bold.underline('Configuration')}`);
+
+    if (mode !== undefined && mode !== null) {
+        const modeNames = {
+            [ThermostatMode.HEAT]: 'Heat',
+            [ThermostatMode.COOL]: 'Cool',
+            [ThermostatMode.ECONOMY]: 'Economy',
+            [ThermostatMode.AUTO]: 'Auto',
+            [ThermostatMode.MANUAL]: 'Manual'
+        };
+        const modeName = modeNames[mode] || `Mode ${mode}`;
+        const onoffStatus = subdevice.isOn() ? 'On' : 'Off';
+        console.log(`      ${chalk.white.bold('Mode')}: ${chalk.italic(`${onoffStatus} - ${modeName}${targetTemp !== null ? ` ${targetTemp.toFixed(1)}°C` : ''}`)}`);
+        hasReadings = true;
+    } else if (targetTemp !== null) {
+        console.log(`      ${chalk.white.bold('Target Temperature')}: ${chalk.italic(`${targetTemp.toFixed(1)}°C`)}`);
+        hasReadings = true;
+    }
+
+    if (comfortTemp !== null) {
+        console.log(`      ${chalk.white.bold('Comfort Temperature')}: ${chalk.italic(`${comfortTemp.toFixed(1)}°C`)}`);
+    }
+    if (economyTemp !== null) {
+        console.log(`      ${chalk.white.bold('Economy Temperature')}: ${chalk.italic(`${economyTemp.toFixed(1)}°C`)}`);
+    }
+    if (awayTemp !== null) {
+        console.log(`      ${chalk.white.bold('Away Temperature')}: ${chalk.italic(`${awayTemp.toFixed(1)}°C`)}`);
+    }
+    if (customTemp !== null) {
+        console.log(`      ${chalk.white.bold('Custom Temperature')}: ${chalk.italic(`${customTemp.toFixed(1)}°C`)}`);
+    }
+
+    if (calibration !== null) {
+        console.log(`      ${chalk.white.bold('Calibration')}: ${chalk.italic(`${calibration.toFixed(1)}°C`)}`);
+    }
+
+    if (isHeating !== null && isHeating !== undefined) {
+        console.log(`      ${chalk.white.bold('Status')}: ${chalk.italic(isHeating ? 'Heating' : 'Not heating')}`);
+        hasReadings = true;
+    }
+
+    return hasReadings;
+}
+
+module.exports = { displayThermostatValveStatus };
+

package/cli/commands/status/subdevices/hub-water-leak-sensor.js

@@ -0,0 +1,27 @@
+'use strict';
+
+const chalk = require('chalk');
+
+function displayWaterLeakSensorStatus(subdevice) {
+    const isLeaking = subdevice.isLeaking();
+    const leakTime = subdevice.getLatestDetectedWaterLeakTs();
+    const battery = subdevice.getCachedBattery();
+
+    console.log(`\n    ${chalk.bold.underline('Sensors')}`);
+
+    console.log(`      ${chalk.white.bold('Water Leak')}: ${chalk.italic(isLeaking ? 'WARNING: LEAK DETECTED' : 'OK: No leak')}`);
+    if (battery !== null && battery !== undefined) {
+        console.log(`      ${chalk.white.bold('Battery')}: ${chalk.italic(`${battery}%`)}`);
+    }
+
+    console.log(`\n    ${chalk.bold.underline('Configuration')}`);
+
+    if (leakTime) {
+        console.log(`      ${chalk.white.bold('Last Detection')}: ${chalk.italic(new Date(leakTime * 1000).toISOString())}`);
+    }
+
+    return true;
+}
+
+module.exports = { displayWaterLeakSensorStatus };
+

package/cli/commands/status/subdevices/index.js

@@ -0,0 +1,23 @@
+'use strict';
+
+const { HubTempHumSensor, HubWaterLeakSensor, HubSmokeDetector, HubThermostatValve } = require('meross-iot');
+const { displayTempHumSensorStatus } = require('./hub-temp-hum-sensor');
+const { displayWaterLeakSensorStatus } = require('./hub-water-leak-sensor');
+const { displaySmokeDetectorStatus } = require('./hub-smoke-detector');
+const { displayThermostatValveStatus } = require('./hub-thermostat-valve');
+
+function displaySubdeviceStatus(subdevice) {
+    if (subdevice instanceof HubTempHumSensor) {
+        return displayTempHumSensorStatus(subdevice);
+    } else if (subdevice instanceof HubWaterLeakSensor) {
+        return displayWaterLeakSensorStatus(subdevice);
+    } else if (subdevice instanceof HubSmokeDetector) {
+        return displaySmokeDetectorStatus(subdevice);
+    } else if (subdevice instanceof HubThermostatValve) {
+        return displayThermostatValveStatus(subdevice);
+    }
+    return false;
+}
+
+module.exports = { displaySubdeviceStatus };
+

package/cli/commands/test/index.js

@@ -0,0 +1,185 @@
+'use strict';
+
+const chalk = require('chalk');
+const inquirer = require('inquirer');
+const ora = require('ora');
+const testRunner = require('../../tests/test-runner');
+
+async function selectDeviceForTest(manager, testType) {
+    const findSpinner = ora(`Finding devices for test type: ${chalk.cyan(testType)}`).start();
+    const devices = await testRunner.findDevicesForTestType(testType, manager);
+    findSpinner.stop();
+
+    if (devices.length === 0) {
+        console.log(chalk.yellow(`\n⚠ No devices found for test type: ${chalk.cyan(testType)}`));
+        return { selectedDevices: null, testAll: false };
+    }
+
+    if (devices.length === 1) {
+        const device = devices[0];
+        console.log(chalk.green(`\n✓ Found 1 device: ${chalk.bold(device.name || device.uuid)}`));
+        return { selectedDevices: [device], testAll: false };
+    }
+
+    // Multiple devices - let user choose with arrow-based selection
+    const choices = [
+        ...devices.map((device, index) => {
+            const name = device.name || 'Unknown';
+            const uuid = device.uuid || 'unknown';
+            const type = device.deviceType || 'unknown';
+            return {
+                name: `${name} (${type}) - ${uuid}`,
+                value: `device_${index}`
+            };
+        }),
+        new inquirer.Separator(),
+        {
+            name: 'Test all devices',
+            value: 'all'
+        }
+    ];
+
+    const { deviceChoice } = await inquirer.prompt([{
+        type: 'list',
+        name: 'deviceChoice',
+        message: 'Select device to test:',
+        choices
+    }]);
+
+    if (deviceChoice === 'all') {
+        return { selectedDevices: devices, testAll: true };
+    } else if (deviceChoice.startsWith('device_')) {
+        const index = parseInt(deviceChoice.replace('device_', ''), 10);
+        const selectedDevice = devices[index];
+        console.log(`\nSelected device: ${chalk.bold(selectedDevice.name || selectedDevice.uuid || 'Unknown')}`);
+        return { selectedDevices: [selectedDevice], testAll: false };
+    }
+
+    // Fallback (shouldn't happen)
+    return { selectedDevices: null, testAll: false };
+}
+
+async function runTestCommand(manager, testType, allowDeviceSelection = false) {
+    let selectedDevices = null;
+
+    // If device selection is allowed, let user select device
+    if (allowDeviceSelection) {
+        const selection = await selectDeviceForTest(manager, testType);
+        if (!selection || !selection.selectedDevices || selection.selectedDevices.length === 0) {
+            // User cancelled or no devices found
+            return;
+        }
+        selectedDevices = selection.selectedDevices;
+    } else {
+        // Auto-discover devices
+        const findSpinner = ora(`Finding devices for test type: ${chalk.cyan(testType)}`).start();
+        selectedDevices = await testRunner.findDevicesForTestType(testType, manager);
+        findSpinner.stop();
+
+        if (selectedDevices.length === 0) {
+            console.log(chalk.yellow(`\n⚠ No devices found for test type: ${chalk.cyan(testType)}`));
+            return;
+        }
+
+        const deviceNames = selectedDevices.map(d => {
+            return d.name || d.uuid || 'Unknown';
+        });
+        console.log(chalk.green(`\n✓ Found ${selectedDevices.length} device${selectedDevices.length > 1 ? 's' : ''}: ${chalk.bold(deviceNames.join(', '))}`));
+    }
+
+    // Prepare context object for test runner
+    const context = {
+        manager,
+        devices: selectedDevices,
+        options: {
+            timeout: 30000,
+            verbose: true
+        }
+    };
+
+    // Start spinner for test execution
+    const testSpinner = ora({
+        text: `Running tests for device type: ${chalk.cyan(testType)}`,
+        spinner: 'dots'
+    }).start();
+
+    try {
+        const results = await testRunner.runTest(testType, context);
+        testSpinner.stop();
+
+        // Print detailed results with improved formatting
+        if (results.tests && results.tests.length > 0) {
+            console.log(chalk.bold('\nTest Results:\n'));
+
+            results.tests.forEach((test) => {
+                let icon, statusColor, statusText;
+                if (test.skipped) {
+                    icon = chalk.yellow('⏭');
+                    statusColor = chalk.yellow;
+                    statusText = 'SKIPPED';
+                } else if (test.passed) {
+                    icon = chalk.green('✓');
+                    statusColor = chalk.green;
+                    statusText = 'PASSED';
+                } else {
+                    icon = chalk.red('✗');
+                    statusColor = chalk.red;
+                    statusText = 'FAILED';
+                }
+
+                const deviceInfo = test.device ? chalk.gray(` [${test.device}]`) : '';
+                const testName = chalk.white(test.name);
+
+                console.log(`${icon} ${testName}${deviceInfo} ${statusColor(`- ${statusText}`)}`);
+
+                if (!test.passed && !test.skipped && test.error) {
+                    console.log(`   ${chalk.red('Error:')} ${chalk.gray(test.error)}`);
+                }
+            });
+
+            // Summary with colors
+            const passedColor = results.passed > 0 ? chalk.green : chalk.gray;
+            const failedColor = results.failed > 0 ? chalk.red : chalk.gray;
+            const skippedColor = results.skipped > 0 ? chalk.yellow : chalk.gray;
+
+            console.log(`${chalk.bold('\nSummary:')} ${passedColor(`${results.passed} passed`)}` +
+                ` ${failedColor(`${results.failed} failed`)}` +
+                ` ${skippedColor(`${results.skipped} skipped`)}${chalk.gray(` (${(results.duration / 1000).toFixed(2)}s)`)}`);
+        }
+
+        if (results.error) {
+            console.error(chalk.red(`\n✗ Test error: ${results.error}`));
+            if (results.stack) {
+                console.error(chalk.gray(results.stack));
+            }
+            if (!allowDeviceSelection) {
+                process.exit(1);
+            }
+            return;
+        }
+
+        if (results.success) {
+            console.log(chalk.green('\n✓ All tests completed successfully'));
+        } else {
+            console.log(chalk.red(`\n✗ Tests failed (${results.failed} failure(s))`));
+            if (!allowDeviceSelection) {
+                process.exit(1);
+            }
+        }
+    } catch (error) {
+        testSpinner.stop();
+        console.error(chalk.red(`\n✗ Error running tests: ${error.message}`));
+        if (error.stack) {
+            console.error(chalk.gray(error.stack));
+        }
+        if (!allowDeviceSelection) {
+            process.exit(1);
+        }
+    }
+}
+
+module.exports = {
+    runTestCommand,
+    selectDeviceForTest
+};
+

package/cli/config/users.js

@@ -0,0 +1,108 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+function getConfigPath() {
+    const configDir = path.join(os.homedir(), '.meross-cli');
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { mode: 0o700 });
+    }
+    return path.join(configDir, 'users.json');
+}
+
+function loadUsers() {
+    const configPath = getConfigPath();
+    if (!fs.existsSync(configPath)) {
+        return {};
+    }
+    try {
+        const data = fs.readFileSync(configPath, 'utf8');
+        return JSON.parse(data);
+    } catch (error) {
+        console.error(`Error reading user config: ${error.message}`);
+        return {};
+    }
+}
+
+function saveUsers(users) {
+    const configPath = getConfigPath();
+    try {
+        fs.writeFileSync(configPath, JSON.stringify(users, null, 2), { mode: 0o600 });
+        return true;
+    } catch (error) {
+        console.error(`Error saving user config: ${error.message}`);
+        return false;
+    }
+}
+
+function addUser(name, email, password, mfaCode = null) {
+    if (!name || typeof name !== 'string' || !name.trim()) {
+        return { success: false, error: 'User name cannot be empty' };
+    }
+
+    const trimmedName = name.trim();
+
+    if (!email || typeof email !== 'string' || !email.trim()) {
+        return { success: false, error: 'Email cannot be empty' };
+    }
+
+    if (!password || typeof password !== 'string' || !password) {
+        return { success: false, error: 'Password cannot be empty' };
+    }
+
+    const users = loadUsers();
+    if (users[trimmedName]) {
+        return { success: false, error: `User "${trimmedName}" already exists` };
+    }
+
+    users[trimmedName] = {
+        email: email.trim(),
+        password,
+        mfaCode: mfaCode || null,
+        createdAt: new Date().toISOString()
+    };
+
+    if (saveUsers(users)) {
+        return { success: true };
+    }
+    return { success: false, error: 'Failed to save user' };
+}
+
+function removeUser(name) {
+    const users = loadUsers();
+    if (!users[name]) {
+        return { success: false, error: `User "${name}" not found` };
+    }
+    delete users[name];
+    if (saveUsers(users)) {
+        return { success: true };
+    }
+    return { success: false, error: 'Failed to save user config' };
+}
+
+function getUser(name) {
+    const users = loadUsers();
+    return users[name] || null;
+}
+
+function listUsers() {
+    const users = loadUsers();
+    return Object.keys(users).map(name => ({
+        name,
+        email: users[name].email,
+        createdAt: users[name].createdAt
+    }));
+}
+
+module.exports = {
+    getConfigPath,
+    loadUsers,
+    saveUsers,
+    addUser,
+    removeUser,
+    getUser,
+    listUsers
+};
+