fnos-cli 0.2.0 → 0.3.0

package/src/commands/index.js

@@ -1,144 +1,23 @@
-/**
- * Command registration helper
- */
-
-const { COMMAND_MAPPING } = require('../constants');
-const { createClient, getSDKInstance } = require('../utils/client');
-const { formatOutput } = require('../utils/formatter');
-const { logger } = require('../utils/logger');
-const { resolveCredentials } = require('../utils/auth-helper');
-
-/**
- * Register all dynamic commands based on COMMAND_MAPPING
- * @param {Command} program - Commander program instance
- */
-function registerCommands(program) {
-  for (const [commandName, config] of Object.entries(COMMAND_MAPPING)) {
-    for (const [subCommandName, commandConfig] of Object.entries(config.commands)) {
-      // Create combined command name (e.g., "resmon.cpu")
-      const fullCommandName = `${commandName}.${subCommandName}`;
-
-      // Create command
-      const cmd = program.command(fullCommandName)
-        .description(commandConfig.description);
-
-      // Add authentication parameters
-      cmd.option('-e, --endpoint <endpoint>', 'Server endpoint (e.g., nas-9.timandes.net:5666)');
-      cmd.option('-u, --username <username>', 'Username');
-      cmd.option('-p, --password <password>', 'Password');
-
-      // Add parameters
-      if (commandConfig.params) {
-        commandConfig.params.forEach(param => {
-          const optionName = `--${param}`;
-          const description = `${param} parameter`;
-          if (param === 'disk' || param === 'path' || param === 'ifName' || param === 'files') {
-            cmd.requiredOption(optionName + ' <value>', `${description} (required)`);
-          } else {
-            cmd.option(optionName + ' <value>', description);
-          }
-        });
-      }
-
-      // Add action handler
-      cmd.action(async (options) => {
-        try {
-          // Get global options from root command
-          const globalOptions = program.opts();
-
-          // Validate required parameters
-          if (commandConfig.params) {
-            const requiredParams = ['disk', 'path', 'ifName', 'files'];
-            for (const param of requiredParams) {
-              if (commandConfig.params.includes(param) && !options[param]) {
-                console.error(`Error: --${param} is required for this command.`);
-                process.exit(4);
-              }
-            }
-          }
-
-          // Resolve credentials (command line or settings file)
-          let credentials;
-          try {
-            credentials = resolveCredentials(options, program);
-          } catch (error) {
-            if (error.message === 'PARTIAL_CREDENTIALS') {
-              // Display friendly error message
-              console.error('Error: When using -e/--endpoint, you must also provide -u/--username and -p/--password.');
-              console.error('Usage: fnos %s -e <endpoint> -u <username> -p <password>', fullCommandName);
-              process.exit(1);
-            }
-            throw error;
-          }
-
-          // Create client with resolved credentials
-          const client = await createClient({
-            credentials,
-            timeout: 60
-          });
-
-          // Get SDK instance
-          const sdkInstance = getSDKInstance(client, config.className);
-
-          // Prepare method arguments
-          const args = [];
-          const timeoutFirstClasses = ['ResourceMonitor', 'User', 'SystemInfo', 'SAC'];
-
-          if (commandConfig.params) {
-            commandConfig.params.forEach(param => {
-              if (options[param] !== undefined) {
-                let value = options[param];
-                // Handle comma-separated lists
-                if (param === 'files' || param === 'items') {
-                  if (typeof value === 'string') {
-                    value = value.split(',').map(s => s.trim());
-                  } else if (!Array.isArray(value)) {
-                    value = [value];
-                  }
-                }
-                // Handle boolean parameters
-                if (param === 'noHotSpare' || param === 'moveToTrashbin') {
-                  value = value === 'false' ? false : value;
-                }
-                // Handle numeric parameters
-                if (param === 'type') {
-                  value = parseInt(value, 10);
-                }
-                args.push(value);
-              }
-            });
-          }
-
-          // Add timeout based on class pattern
-          if (timeoutFirstClasses.includes(config.className)) {
-            // Timeout first pattern: (timeout, params...)
-            args.unshift(10000);
-          } else {
-            // Timeout last pattern: (params..., timeout)
-            args.push(10000);
-          }
-
-          // Execute method
-          logger.info(`Executing ${config.className}.${commandConfig.method}...`);
-          const result = await sdkInstance[commandConfig.method](...args);
-
-          // Format output
-          console.log(formatOutput(result, globalOptions.raw));
-
-          // Close connection
-          client.close();
-          process.exit(0);
-        } catch (error) {
-          logger.error(`Command failed: ${error.message}`);
-          const globalOptions = program.opts();
-          if (globalOptions.debug || globalOptions.silly) {
-            console.error(error);
-          }
-          process.exit(1);
-        }
+const { COMMAND_CATALOG } = require('./catalog');
+const { registerAuthenticationOptions, registerBusinessOptions } = require('./options');
+const { runCommand } = require('./runner');
+
+function registerCommands(program, dependencies = {}) {
+  for (const [domainName, domain] of Object.entries(COMMAND_CATALOG)) {
+    for (const [commandName, definition] of Object.entries(domain.commands)) {
+      const command = program.command(`${domainName}.${commandName}`).description(definition.description);
+      registerAuthenticationOptions(command);
+      registerBusinessOptions(command, definition.options);
+      command.action(async (options) => {
+        process.exitCode = await runCommand({
+          domain,
+          definition,
+          options,
+          globalOptions: program.opts()
+        }, dependencies);
       });
     }
   }
 }
 
-module.exports = { registerCommands };
+module.exports = { registerCommands };

package/src/commands/options.js

@@ -0,0 +1,128 @@
+const { Option } = require('commander');
+
+class CommandParameterError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = 'CommandParameterError';
+    this.exitCode = 4;
+  }
+}
+
+function cloneDefault(value) {
+  if (Array.isArray(value)) return value.map((item) => cloneDefault(item));
+  if (value && typeof value === 'object') return { ...value };
+  return value;
+}
+
+function parseBoolean(name, value) {
+  if (typeof value === 'boolean') return value;
+  if (typeof value === 'string' && value.toLowerCase() === 'true') return true;
+  if (typeof value === 'string' && value.toLowerCase() === 'false') return false;
+  throw new CommandParameterError(`--${name} must be true or false.`);
+}
+
+function parseInteger(definition, value) {
+  if (typeof value === 'string' && !/^-?\d+$/.test(value.trim())) {
+    throw new CommandParameterError(`--${definition.name} must be a decimal integer.`);
+  }
+  const parsed = typeof value === 'number' ? value : Number(value);
+  if (!Number.isInteger(parsed)) throw new CommandParameterError(`--${definition.name} must be an integer.`);
+  if (definition.min !== undefined && parsed < definition.min) {
+    throw new CommandParameterError(`--${definition.name} must be at least ${definition.min}.`);
+  }
+  if (definition.max !== undefined && parsed > definition.max) {
+    throw new CommandParameterError(`--${definition.name} must be at most ${definition.max}.`);
+  }
+  if (definition.allowedValues && !definition.allowedValues.includes(parsed)) {
+    throw new CommandParameterError(`--${definition.name} must be one of: ${definition.allowedValues.join(', ')}.`);
+  }
+  return parsed;
+}
+
+function parseJson(name, value) {
+  if (value && typeof value === 'object') return value;
+  try {
+    return JSON.parse(value);
+  } catch {
+    throw new CommandParameterError(`--${name} must be valid JSON.`);
+  }
+}
+
+function parseValue(definition, value) {
+  if (definition.type === 'boolean') return parseBoolean(definition.name, value);
+  if (definition.type === 'integer') return parseInteger(definition, value);
+  if (definition.type === 'csv') {
+    const values = Array.isArray(value) ? value : String(value).split(',').map((item) => item.trim()).filter(Boolean);
+    if (values.length === 0) throw new CommandParameterError(`--${definition.name} must contain at least one value.`);
+    return values;
+  }
+  if (definition.type === 'json') {
+    const parsed = parseJson(definition.name, value);
+    if (!parsed || Array.isArray(parsed) || typeof parsed !== 'object') {
+      throw new CommandParameterError(`--${definition.name} must be a JSON object.`);
+    }
+    return parsed;
+  }
+  if (definition.type === 'json-record-array') {
+    const parsed = parseJson(definition.name, value);
+    if (!Array.isArray(parsed) || parsed.length === 0 || parsed.some((item) => !item || Array.isArray(item) || typeof item !== 'object')) {
+      throw new CommandParameterError(`--${definition.name} must be a non-empty JSON object array.`);
+    }
+    return parsed;
+  }
+  const parsed = String(value);
+  if (!parsed.trim()) throw new CommandParameterError(`--${definition.name} must not be empty.`);
+  return parsed;
+}
+
+function optionReadNames(definition) {
+  if (definition.readNames) return definition.readNames;
+  return [new Option(definition.flag).attributeName()];
+}
+
+function readRawValue(definition, options) {
+  for (const name of optionReadNames(definition)) {
+    if (options[name] !== undefined) return options[name];
+  }
+  return undefined;
+}
+
+function buildMethodArguments(definition, options, timeout = 10000) {
+  const values = definition.options.map((option) => {
+    const raw = readRawValue(option, options);
+    if (raw === undefined) {
+      if (option.required) throw new CommandParameterError(`--${option.name} is required.`);
+      return cloneDefault(option.defaultValue);
+    }
+    return parseValue(option, raw);
+  });
+  return definition.timeoutPosition === 'first' ? [timeout, ...values] : [...values, timeout];
+}
+
+function registerBusinessOptions(command, definitions) {
+  for (const definition of definitions) {
+    command.addOption(new Option(definition.flag, definition.description));
+    for (const legacyFlag of definition.legacyFlags || []) {
+      command.addOption(new Option(legacyFlag, `${definition.description} (legacy spelling)`).hideHelp());
+    }
+  }
+  return command;
+}
+
+function registerAuthenticationOptions(command, requiredCredentials = false) {
+  const add = requiredCredentials ? 'requiredOption' : 'option';
+  command[add]('-e, --endpoint <endpoint>', 'Server endpoint, including optional ws:// or wss:// prefix');
+  command[add]('-u, --username <username>', 'Username');
+  command[add]('-p, --password <password>', 'Password');
+  command.option('--twofa-code <code>', 'Six-digit two-factor code');
+  command.option('--trust-device', 'Trust this device after two-factor login');
+  command.option('--verify-ssl', 'Verify the WSS server certificate');
+  return command;
+}
+
+module.exports = {
+  CommandParameterError,
+  buildMethodArguments,
+  registerAuthenticationOptions,
+  registerBusinessOptions
+};

package/src/commands/runner.js

@@ -0,0 +1,37 @@
+const { buildMethodArguments } = require('./options');
+const clientUtils = require('../utils/client');
+const { formatOutput } = require('../utils/formatter');
+const { resolveCredentials } = require('../utils/auth-helper');
+const { errorMessage } = require('../utils/errors');
+
+async function runCommand(context, dependencies = {}) {
+  const createClient = dependencies.createClient || clientUtils.createClient;
+  const getSDKInstance = dependencies.getSDKInstance || clientUtils.getSDKInstance;
+  const resolve = dependencies.resolveCredentials || resolveCredentials;
+  const stdout = dependencies.stdout || console.log;
+  const stderr = dependencies.stderr || console.error;
+  let client;
+
+  try {
+    const args = buildMethodArguments(context.definition, context.options, 10000);
+    const credentials = resolve(context.options);
+    client = await createClient({
+      credentials,
+      timeout: 60,
+      twofaCode: context.options.twofaCode,
+      trustDevice: context.options.trustDevice,
+      verifySsl: context.options.verifySsl
+    });
+    const instance = getSDKInstance(client, context.domain.className);
+    const result = await instance[context.definition.method](...args);
+    stdout(formatOutput(result, context.globalOptions.raw));
+    return 0;
+  } catch (error) {
+    stderr(`Error: ${errorMessage(error)}`);
+    return error.exitCode || 1;
+  } finally {
+    if (client) client.close();
+  }
+}
+
+module.exports = { errorMessage, runCommand };

package/src/index.js

@@ -1,57 +1,47 @@
 #!/usr/bin/env node
 
-/**
- * fnos-cli - CLI client for 飞牛 fnOS system
- */
-
 const { Command } = require('commander');
 const { registerLoginCommand, registerLogoutCommand } = require('./commands/auth');
 const { registerCommands } = require('./commands');
 const { setLogLevel } = require('./utils/logger');
-
-// Create program
-const program = new Command();
-
-// Configure program
-program
-  .name('fnos')
-  .description('CLI client for 飞牛 fnOS system')
-  .version('0.2.0');
-
-// Global options
-program
-  .option('--raw', 'Output raw JSON response')
-  .option('-v, --verbose', 'Verbose output (info level)')
-  .option('-vv, --debug', 'Debug output (debug level)')
-  .option('-vvv, --silly', 'Silly output (silly level)');
-
-// Register auth commands
-registerLoginCommand(program);
-registerLogoutCommand(program);
-
-// Register dynamic commands
-registerCommands(program);
-
-// Hook into parse to set log level before command execution
-program.hook('preAction', (thisCommand, actionCommand) => {
-  const options = thisCommand.opts();
-  let verboseLevel = 0;
-  if (options.verbose) verboseLevel = 1;
-  if (options.debug) verboseLevel = 2;
-  if (options.silly) verboseLevel = 3;
-  
-  // Set log level for both CLI and SDK logger
-  setLogLevel(verboseLevel);
-  
-  // Set environment variable to control SDK logger level
-  const sdkLogLevels = ['error', 'info', 'debug', 'silly'];
-  process.env.LOG_LEVEL = sdkLogLevels[verboseLevel];
-});
-
-// Parse
-program.parse(process.argv);
-
-// Show help if no command provided
-if (!process.argv.slice(2).length) {
-  program.outputHelp();
-}
+const { errorMessage } = require('./utils/errors');
+const { version } = require('../package.json');
+
+function createProgram(dependencies = {}) {
+  const program = new Command();
+  program.name('fnos').description('CLI client for 飞牛 fnOS system').version(version);
+  program
+    .option('--raw', 'Output raw JSON response')
+    .option('-v, --verbose', 'Verbose output (info level)')
+    .option('-vv, --debug', 'Debug output (debug level)')
+    .option('-vvv, --silly', 'Silly output (silly level)');
+  registerLoginCommand(program, dependencies);
+  registerLogoutCommand(program, dependencies);
+  registerCommands(program, dependencies);
+  program.hook('preAction', (thisCommand) => {
+    const options = thisCommand.opts();
+    const verboseLevel = options.silly ? 3 : options.debug ? 2 : options.verbose ? 1 : 0;
+    setLogLevel(verboseLevel);
+    process.env.LOG_LEVEL = ['error', 'info', 'debug', 'silly'][verboseLevel];
+  });
+  return program;
+}
+
+async function main(argv = process.argv, dependencies = {}) {
+  const program = createProgram(dependencies);
+  if (argv.slice(2).length === 0) {
+    program.outputHelp();
+    return 0;
+  }
+  await program.parseAsync(argv);
+  return process.exitCode || 0;
+}
+
+if (require.main === module) {
+  main().catch((error) => {
+    console.error(`Error: ${errorMessage(error)}`);
+    process.exitCode = error.exitCode || 1;
+  });
+}
+
+module.exports = { createProgram, main };

package/src/utils/auth-helper.js

@@ -15,6 +15,13 @@ function hasPartialCredentials(options) {
   return provided.length > 0 && provided.length < 3;
 }
 
+function credentialError(message) {
+  const error = new Error(message);
+  error.name = 'AuthenticationError';
+  error.exitCode = 3;
+  return error;
+}
+
 /**
  * Validate command line credentials completeness
  * @param {Object} options - Command line options
@@ -23,10 +30,10 @@ function hasPartialCredentials(options) {
  */
 function validateCommandLineCredentials(options) {
   if (hasPartialCredentials(options)) {
-    throw new Error('PARTIAL_CREDENTIALS');
+    throw credentialError('PARTIAL_CREDENTIALS');
   }
 
-  const hasCredentials = options.endpoint && options.username && options.password;
+  const hasCredentials = Boolean(options.endpoint && options.username && options.password);
   return { isValid: true, hasCredentials };
 }
 
@@ -36,7 +43,7 @@ function validateCommandLineCredentials(options) {
  * @returns {Object} - Credentials object
  * @throws {Error} - If no valid credentials are found or partial credentials are provided
  */
-function resolveCredentials(options) {
+function resolveCredentials(options, settingsStore = settings) {
   const validation = validateCommandLineCredentials(options);
 
   if (validation.hasCredentials) {
@@ -50,9 +57,9 @@ function resolveCredentials(options) {
   }
 
   // Read from settings file
-  const credentials = settings.getCredentials();
+  const credentials = settingsStore.getCredentials();
   if (!credentials || !credentials.endpoint || !credentials.username || !credentials.password) {
-    throw new Error('No valid credentials found. Please use "fnos login" or provide -e/-u/-p options.');
+    throw credentialError('No valid credentials found. Please use "fnos login" or provide -e/-u/-p options.');
   }
 
   return {
@@ -65,4 +72,4 @@ module.exports = {
   hasPartialCredentials,
   validateCommandLineCredentials,
   resolveCredentials
-};
+};