@icyouo/evt-cli 0.1.3 → 0.1.4

package/README.md

@@ -275,6 +275,42 @@ intermediate endpoint should include at least:
 
 This JSON is used only for scanning, coverage, and sync. Runtime execution still reads YAML.
 
+## Flow Inputs
+
+Flow inputs can prompt users interactively. Inputs with `type: "password"` are
+masked with `*` while typing.
+
+Use `inputGroups.anyOf` when one value from a set is required. For example,
+login flows can accept either an email verification code or a Google OTP:
+
+```yaml
+inputs:
+  email:
+    prompt: Email
+    type: string
+    required: true
+  password:
+    prompt: Password
+    type: password
+    required: true
+  code:
+    prompt: Email code
+    type: string
+    default: ""
+  googleCode:
+    prompt: Google OTP
+    type: string
+    default: ""
+
+inputGroups:
+  anyOf:
+    - fields:
+        - code
+        - googleCode
+      prompt: Enter either an email code or Google OTP.
+      message: email code or Google OTP
+```
+
 ## Common Commands
 
 ```bash

package/README.zh-CN.md

@@ -264,6 +264,41 @@ npm run sync:api -- --config-root /path/to/project/cli
 
 这个 JSON 只参与扫描/覆盖率/sync，最终运行仍然读取 YAML。
 
+## Flow 输入
+
+flow inputs 支持交互式输入。`type: "password"` 的输入会在键入时显示为 `*`。
+
+当一组输入里必须至少提供一个值时，可以使用 `inputGroups.anyOf`。例如登录 flow
+可以支持邮箱验证码和 Google OTP 二选一：
+
+```yaml
+inputs:
+  email:
+    prompt: Email
+    type: string
+    required: true
+  password:
+    prompt: Password
+    type: password
+    required: true
+  code:
+    prompt: Email code
+    type: string
+    default: ""
+  googleCode:
+    prompt: Google OTP
+    type: string
+    default: ""
+
+inputGroups:
+  anyOf:
+    - fields:
+        - code
+        - googleCode
+      prompt: Enter either an email code or Google OTP.
+      message: email code or Google OTP
+```
+
 ## 常用命令
 
 ```bash

package/data/flows/login.example.yaml

@@ -10,6 +10,24 @@ inputs:
     prompt: Password
     type: password
     required: true
+  code:
+    prompt: Email code
+    type: string
+    required: false
+    default: ""
+  googleCode:
+    prompt: Google OTP
+    type: string
+    required: false
+    default: ""
+
+inputGroups:
+  anyOf:
+    - fields:
+        - code
+        - googleCode
+      prompt: Enter either an email code or Google OTP.
+      message: email code or Google OTP
 
 steps:
   - id: login
@@ -17,6 +35,8 @@ steps:
     body:
       email: "{{inputs.email}}"
       password: "{{inputs.password}}"
+      code: "{{inputs.code}}"
+      googleCode: "{{inputs.googleCode}}"
 
 save:
   cache:

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@icyouo/evt-cli",
-  "version": "0.1.3",
+  "version": "0.1.4",
   "description": "Run YAML-defined HTTP APIs and interactive workflows from your terminal.",
   "license": "MIT",
   "repository": {
@@ -27,7 +27,7 @@
   "scripts": {
     "ci:local": "node scripts/local-ci.js",
     "test": "node --test",
-    "check": "node --check bin/evt.js && node --check src/index.js && node --check src/util/settings.js && node --check src/api/liveTester.js && node --check scripts/sync-api-coverage.js && node --check scripts/check-api-coverage.js && node --check scripts/check-api-audit.js && node --check scripts/local-ci.js && node --check scripts/build-package.js && node --check skills/evt-api-scanner/scripts/discover.js && node --check skills/evt-api-scanner/scripts/scan.js",
+    "check": "node --check bin/evt.js && node --check src/index.js && node --check src/util/settings.js && node --check src/flow/inputResolver.js && node --check src/api/liveTester.js && node --check scripts/sync-api-coverage.js && node --check scripts/check-api-coverage.js && node --check scripts/check-api-audit.js && node --check scripts/local-ci.js && node --check scripts/build-package.js && node --check skills/evt-api-scanner/scripts/discover.js && node --check skills/evt-api-scanner/scripts/scan.js",
     "package:local": "node scripts/build-package.js",
     "sync:api": "node scripts/sync-api-coverage.js",
     "coverage:api": "node scripts/check-api-coverage.js",

package/src/config/validate.js

@@ -143,6 +143,25 @@ function validateFlow(flow, file) {
       }
     }
   }
+  if (flow.inputGroups !== undefined) {
+    if (!isObject(flow.inputGroups)) {
+      push(errors, file, "flow.inputGroups must be an object");
+    } else if (flow.inputGroups.anyOf !== undefined) {
+      if (!Array.isArray(flow.inputGroups.anyOf)) {
+        push(errors, file, "flow.inputGroups.anyOf must be an array");
+      } else {
+        for (const [index, group] of flow.inputGroups.anyOf.entries()) {
+          if (!isObject(group)) {
+            push(errors, file, `inputGroups.anyOf[${index}] must be an object`);
+            continue;
+          }
+          if (!Array.isArray(group.fields) || group.fields.length === 0) {
+            push(errors, file, `inputGroups.anyOf[${index}].fields must be a non-empty array`);
+          }
+        }
+      }
+    }
+  }
   if (flow.steps !== undefined && !Array.isArray(flow.steps)) push(errors, file, "flow.steps must be an array");
   for (const [index, step] of (flow.steps || []).entries()) {
     if (!isObject(step)) {

package/src/flow/inputResolver.js

@@ -4,11 +4,79 @@ function envNameFor(key, input) {
   return input.env || `NEPTUNE_${key.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase()}`;
 }
 
+function hasValue(value) {
+  return !(value === undefined || value === null || value === "");
+}
+
+function promptPassword(question, input) {
+  return new Promise((resolve, reject) => {
+    let value = "";
+    const stdin = process.stdin;
+    const stdout = process.stdout;
+
+    if (!stdin.isTTY || typeof stdin.setRawMode !== "function") {
+      const rl = readline.createInterface({
+        input: stdin,
+        output: stdout,
+        terminal: true
+      });
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve(answer === "" && input.default !== undefined ? input.default : answer);
+      });
+      return;
+    }
+
+    const wasRaw = stdin.isRaw;
+    stdout.write(question);
+    readline.emitKeypressEvents(stdin);
+    stdin.setRawMode(true);
+    stdin.resume();
+
+    const cleanup = () => {
+      stdin.removeListener("keypress", onKeypress);
+      stdin.setRawMode(Boolean(wasRaw));
+      stdout.write("\n");
+    };
+
+    function onKeypress(sequence, key = {}) {
+      if (key.ctrl && key.name === "c") {
+        cleanup();
+        reject(new Error("Input cancelled"));
+        return;
+      }
+      if (key.name === "return" || key.name === "enter") {
+        cleanup();
+        resolve(value === "" && input.default !== undefined ? input.default : value);
+        return;
+      }
+      if (key.name === "backspace" || key.name === "delete") {
+        if (value.length > 0) {
+          value = value.slice(0, -1);
+          stdout.write("\b \b");
+        }
+        return;
+      }
+      if (key.ctrl || key.meta || !sequence || /[\r\n]/.test(sequence)) {
+        return;
+      }
+      value += sequence;
+      stdout.write("*");
+    }
+
+    stdin.on("keypress", onKeypress);
+  });
+}
+
 function promptValue(key, input) {
   const label = input.prompt || key;
   const suffix = input.default !== undefined && input.default !== "" ? ` (${input.default})` : "";
   const question = `${label}${suffix}: `;
 
+  if (input.type === "password") {
+    return promptPassword(question, input);
+  }
+
   return new Promise((resolve) => {
     const rl = readline.createInterface({
       input: process.stdin,
@@ -16,47 +84,92 @@ function promptValue(key, input) {
       terminal: true
     });
 
-    if (input.type === "password") {
-      rl.stdoutMuted = true;
-      rl._writeToOutput = function writeToOutput(stringToWrite) {
-        if (!rl.stdoutMuted) {
-          rl.output.write(stringToWrite);
-        }
-      };
-    }
-
     rl.question(question, (answer) => {
       rl.close();
-      if (input.type === "password") {
-        process.stdout.write("\n");
-      }
       resolve(answer === "" && input.default !== undefined ? input.default : answer);
     });
   });
 }
 
+function readConfiguredInput(key, input, options) {
+  const envName = envNameFor(key, input);
+  if (Object.prototype.hasOwnProperty.call(options.set || {}, key)) {
+    return options.set[key];
+  }
+  if (process.env[envName] !== undefined) {
+    return process.env[envName];
+  }
+  if (options.cache && options.cache.inputs && options.cache.inputs[key] !== undefined) {
+    return options.cache.inputs[key];
+  }
+  if (options.profile && options.profile.inputs && options.profile.inputs[key] !== undefined) {
+    return options.profile.inputs[key];
+  }
+  return undefined;
+}
+
+function anyOfGroups(flow) {
+  const inputGroups = flow.inputGroups || {};
+  const groups = inputGroups.anyOf || [];
+  return Array.isArray(groups) ? groups : [];
+}
+
+function groupedKeys(flow) {
+  const keys = new Set();
+  for (const group of anyOfGroups(flow)) {
+    for (const key of group.fields || []) keys.add(key);
+  }
+  return keys;
+}
+
+async function resolveAnyOfGroups(flow, options, result) {
+  const definitions = flow.inputs || {};
+
+  for (const group of anyOfGroups(flow)) {
+    const fields = group.fields || [];
+    if (fields.some((key) => hasValue(result[key]))) {
+      continue;
+    }
+
+    let resolved = false;
+    if (!options.noInteractive && process.stdin.isTTY) {
+      if (group.prompt) {
+        process.stdout.write(`${group.prompt}\n`);
+      }
+      for (const key of fields) {
+        const input = definitions[key];
+        if (!input) continue;
+        const value = await promptValue(key, { ...input, default: undefined });
+        if (hasValue(value)) {
+          result[key] = value;
+          resolved = true;
+          break;
+        }
+      }
+    }
+
+    if (!resolved && !fields.some((key) => hasValue(result[key]))) {
+      const label = group.message || `One of ${fields.join(", ")} is required`;
+      throw new Error(`Missing required flow input group: ${label}`);
+    }
+  }
+}
+
 async function resolveInputs(flow, options) {
   const definitions = flow.inputs || {};
   const result = {};
+  const anyOfKeys = groupedKeys(flow);
 
   for (const [key, input] of Object.entries(definitions)) {
-    const envName = envNameFor(key, input);
-    let value;
-    if (Object.prototype.hasOwnProperty.call(options.set || {}, key)) {
-      value = options.set[key];
-    } else if (process.env[envName] !== undefined) {
-      value = process.env[envName];
-    } else if (options.cache && options.cache.inputs && options.cache.inputs[key] !== undefined) {
-      value = options.cache.inputs[key];
-    } else if (options.profile && options.profile.inputs && options.profile.inputs[key] !== undefined) {
-      value = options.profile.inputs[key];
-    } else if (!options.noInteractive && process.stdin.isTTY) {
+    let value = readConfiguredInput(key, input, options);
+    const deferInteractive = anyOfKeys.has(key) && !input.required;
+    if (value === undefined && !deferInteractive && !options.noInteractive && process.stdin.isTTY) {
       value = await promptValue(key, input);
-    } else if (input.default !== undefined) {
+    } else if (value === undefined && input.default !== undefined) {
       value = input.default;
     }
 
-    if (input.required && (value === undefined || value === null || value === "")) {
+    if (input.required && !hasValue(value)) {
       throw new Error(`Missing required flow input: ${key}`);
     }
     if (value !== undefined) {
@@ -64,9 +177,14 @@ async function resolveInputs(flow, options) {
     }
   }
 
+  await resolveAnyOfGroups(flow, options, result);
+
   return result;
 }
 
 module.exports = {
+  hasValue,
+  promptPassword,
+  promptValue,
   resolveInputs
 };

package/test/flow.test.js

@@ -213,3 +213,89 @@ test("skips response expectations during dry-run", async () => {
   assert.equal(result.flow, "dry-run-expect");
   assert.deepEqual(result.vars, []);
 });
+
+test("accepts one input from an anyOf input group", async () => {
+  const result = await runFlow({
+    name: "login-any-of",
+    inputs: {
+      email: { required: true },
+      password: { required: true, type: "password" },
+      code: { default: "" },
+      googleCode: { default: "" }
+    },
+    inputGroups: {
+      anyOf: [
+        { fields: ["code", "googleCode"], message: "email code or Google OTP" }
+      ]
+    },
+    steps: [
+      {
+        id: "login",
+        call: "auth.login",
+        body: {
+          email: "{{inputs.email}}",
+          password: "{{inputs.password}}",
+          code: "{{inputs.code}}",
+          googleCode: "{{inputs.googleCode}}"
+        }
+      }
+    ]
+  }, {
+    registry: loadApiRegistry(),
+    profile: loadProfile("local"),
+    cache: {},
+    cachePath: "/tmp/evt-cli-any-of-cache-test.json",
+    set: {
+      email: "user@example.com",
+      password: "secret",
+      googleCode: "123456"
+    },
+    dryRun: true,
+    noInteractive: true
+  });
+
+  assert.deepEqual(result.inputs.sort(), ["code", "email", "googleCode", "password"].sort());
+  assert.equal(result.steps.login.request.body.code, "");
+  assert.equal(result.steps.login.request.body.googleCode, "123456");
+});
+
+test("fails when no input from an anyOf input group is available", async () => {
+  await assert.rejects(
+    runFlow({
+      name: "login-any-of-missing",
+      inputs: {
+        email: { required: true },
+        password: { required: true, type: "password" },
+        code: { default: "" },
+        googleCode: { default: "" }
+      },
+      inputGroups: {
+        anyOf: [
+          { fields: ["code", "googleCode"], message: "email code or Google OTP" }
+        ]
+      },
+      steps: [
+        {
+          id: "login",
+          call: "auth.login",
+          body: {
+            email: "{{inputs.email}}",
+            password: "{{inputs.password}}"
+          }
+        }
+      ]
+    }, {
+      registry: loadApiRegistry(),
+      profile: { name: "test", baseUrl: "https://api.example.com", inputs: {} },
+      cache: {},
+      cachePath: "/tmp/evt-cli-any-of-missing-cache-test.json",
+      set: {
+        email: "user@example.com",
+        password: "secret"
+      },
+      dryRun: true,
+      noInteractive: true
+    }),
+    /Missing required flow input group: email code or Google OTP/
+  );
+});