@icyouo/evt-cli 0.1.0

package/src/index.js

@@ -0,0 +1,238 @@
+const { parseArgs } = require("./util/args");
+const { parseJsonObject, stableJson } = require("./util/json");
+const { redact } = require("./util/redact");
+const { setConfigRoot } = require("./util/paths");
+const {
+  listApiFiles,
+  listProfiles,
+  loadProfile,
+  loadApiRegistry,
+  listFlows,
+  loadFlow
+} = require("./config/loaders");
+const { readCache, writeCache, clearCache, resolveCachePath } = require("./cache/sessionCache");
+const { executeEndpoint } = require("./http/client");
+const { runFlow } = require("./flow/runner");
+const { toCurl } = require("./http/requestBuilder");
+const { compareScanToRegistry, scanServices } = require("./config/serviceScanner");
+const { runLiveApiTest } = require("./api/liveTester");
+
+function print(value, json = false) {
+  if (json || typeof value !== "string") {
+    console.log(stableJson(value));
+  } else {
+    console.log(value);
+  }
+}
+
+function usage() {
+  return [
+    "Usage:",
+    "  evt profile list [--config-root ./cli]",
+    "  evt profile show <name>",
+    "  evt api list",
+    "  evt api show <id>",
+    "  evt api scan [--missing] [--scan-config path/to/scanner.json]",
+    "  evt api call <id> [--profile local] [--set k=v] [--body '{...}'] [--dry-run]",
+    "  evt api test-all [--profile local] [--include-dangerous] [--only namespace]",
+    "  evt validate",
+    "  evt flow list",
+    "  evt flow run <name> [--profile local] [--set k=v] [--dry-run]",
+    "  evt cache show|clear|path"
+  ].join("\n");
+}
+
+function commonRuntime(options) {
+  const profile = loadProfile(options.profile || "local");
+  const cachePath = resolveCachePath(options.cache);
+  const cache = readCache(cachePath);
+  return {
+    profile,
+    cachePath,
+    cache,
+    registry: loadApiRegistry()
+  };
+}
+
+async function handleProfile(tokens) {
+  const sub = tokens[0];
+  const options = parseArgs(tokens.slice(1));
+  setConfigRoot(options.configRoot);
+  if (sub === "list") {
+    print(listProfiles(), options.json);
+    return;
+  }
+  if (sub === "show") {
+    print(loadProfile(options._[0]), true);
+    return;
+  }
+  throw new Error(usage());
+}
+
+async function handleApi(tokens) {
+  const sub = tokens[0];
+  const options = parseArgs(tokens.slice(1));
+  setConfigRoot(options.configRoot);
+  const registry = loadApiRegistry();
+
+  if (sub === "list") {
+    print(Object.keys(registry).sort(), options.json);
+    return;
+  }
+  if (sub === "show") {
+    const endpoint = registry[options._[0]];
+    if (!endpoint) throw new Error(`Endpoint not found: ${options._[0]}`);
+    print(endpoint, true);
+    return;
+  }
+  if (sub === "scan") {
+    const scanned = scanServices({ scanConfig: options.scanConfig });
+    const comparison = compareScanToRegistry(scanned, registry);
+    const payload = options.missing ? comparison.missing : {
+      scanned,
+      covered: comparison.covered.length,
+      missing: comparison.missing
+    };
+    print(payload, true);
+    return;
+  }
+  if (sub === "call") {
+    const id = options._[0];
+    const endpoint = registry[id];
+    if (!endpoint) throw new Error(`Endpoint not found: ${id}`);
+    const runtime = commonRuntime(options);
+    const body = parseJsonObject(options.body, "--body");
+    const query = parseJsonObject(options.query, "--query");
+    const context = {
+      profile: runtime.profile,
+      cache: runtime.cache,
+      args: { ...(options.set || {}), ...body, ...query },
+      inputs: {},
+      env: process.env,
+      steps: {}
+    };
+    const result = await executeEndpoint(endpoint, {
+      ...runtime,
+      context,
+      body,
+      query,
+      cliHeaders: options.headers,
+      baseUrl: options.baseUrl,
+      dryRun: options.dryRun,
+      unsafe: options.unsafe
+    });
+    if (options.curl) {
+      print(result.curl || toCurl(result.request), false);
+      return;
+    }
+    print(options.dryRun ? { ...result, request: redact(result.request) } : result, options.json || options.dryRun);
+    return;
+  }
+  if (sub === "test-all") {
+    const runtime = commonRuntime(options);
+    const report = await runLiveApiTest(runtime, {
+      ...options,
+      includeDangerous: options.includeDangerous,
+      noLogin: options.noLogin
+    });
+    print({
+      ok: report.ok,
+      profile: report.profile,
+      total: report.total,
+      summary: report.summary,
+      login: report.login,
+      reportPath: report.reportPath
+    }, true);
+    return;
+  }
+  throw new Error(usage());
+}
+
+async function handleFlow(tokens) {
+  const sub = tokens[0];
+  const options = parseArgs(tokens.slice(1));
+  setConfigRoot(options.configRoot);
+  if (sub === "list") {
+    print(listFlows(), options.json);
+    return;
+  }
+  if (sub === "run") {
+    const name = options._[0];
+    const runtime = commonRuntime(options);
+    const flow = loadFlow(name);
+    const result = await runFlow(flow, {
+      ...runtime,
+      set: options.set || {},
+      cliHeaders: options.headers,
+      baseUrl: options.baseUrl,
+      dryRun: options.dryRun,
+      unsafe: options.unsafe,
+      noInteractive: Boolean(options.noInteractive) || !process.stdin.isTTY
+    });
+    print(redact(result), options.json || options.dryRun);
+    return;
+  }
+  throw new Error(usage());
+}
+
+async function handleCache(tokens) {
+  const sub = tokens[0];
+  const options = parseArgs(tokens.slice(1));
+  setConfigRoot(options.configRoot);
+  const cachePath = resolveCachePath(options.cache);
+  if (sub === "show") {
+    print(redact(readCache(cachePath)), true);
+    return;
+  }
+  if (sub === "clear") {
+    clearCache(cachePath);
+    print(`Cleared ${cachePath}`);
+    return;
+  }
+  if (sub === "path") {
+    print(cachePath);
+    return;
+  }
+  if (sub === "write") {
+    const value = parseJsonObject(options.body || options._[0], "cache write");
+    writeCache(cachePath, value);
+    print(`Wrote ${cachePath}`);
+    return;
+  }
+  throw new Error(usage());
+}
+
+async function handleValidate(tokens) {
+  const options = parseArgs(tokens);
+  setConfigRoot(options.configRoot);
+  const profiles = listProfiles();
+  for (const profile of profiles) loadProfile(profile);
+  const registry = loadApiRegistry();
+  for (const flow of listFlows()) loadFlow(flow);
+  print({
+    ok: true,
+    profiles: profiles.length,
+    apiFiles: listApiFiles().length,
+    endpoints: Object.keys(registry).length,
+    flows: listFlows().length
+  }, options.json);
+}
+
+async function run(argv) {
+  const [command, ...tokens] = argv;
+  if (!command || command === "help" || command === "--help") {
+    print(usage());
+    return;
+  }
+  if (command === "profile") return handleProfile(tokens);
+  if (command === "api") return handleApi(tokens);
+  if (command === "flow") return handleFlow(tokens);
+  if (command === "cache") return handleCache(tokens);
+  if (command === "validate") return handleValidate(tokens);
+  throw new Error(usage());
+}
+
+module.exports = {
+  run,
+  usage
+};

package/src/template/interpolate.js

@@ -0,0 +1,65 @@
+const crypto = require("node:crypto");
+
+function getPath(source, dottedPath) {
+  if (dottedPath === "now.iso") return new Date().toISOString();
+  if (dottedPath === "uuid") return crypto.randomUUID();
+
+  const parts = dottedPath.split(".");
+  let current = source;
+  for (const part of parts) {
+    if (current === undefined || current === null) return undefined;
+    current = current[part];
+  }
+  return current;
+}
+
+function interpolateString(value, context) {
+  const exact = value.match(/^\s*\{\{\s*([^}]+?)\s*\}\}\s*$/);
+  if (exact) {
+    return getPath(context, exact[1].trim());
+  }
+  return value.replace(/\{\{\s*([^}]+?)\s*\}\}/g, (_, expression) => {
+    const resolved = getPath(context, expression.trim());
+    return resolved === undefined || resolved === null ? "" : String(resolved);
+  });
+}
+
+function interpolate(value, context) {
+  if (typeof value === "string") {
+    return interpolateString(value, context);
+  }
+  if (Array.isArray(value)) {
+    return value.map((item) => interpolate(item, context));
+  }
+  if (value && typeof value === "object") {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, item]) => [key, interpolate(item, context)])
+    );
+  }
+  return value;
+}
+
+function pruneUndefined(value, options = {}) {
+  if (Array.isArray(value)) {
+    return value
+      .map((item) => pruneUndefined(item, options))
+      .filter((item) => item !== undefined && item !== null);
+  }
+  if (value && typeof value === "object") {
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+      const pruned = pruneUndefined(item, options);
+      if (pruned === undefined || pruned === null) continue;
+      if (options.dropEmptyStrings && pruned === "") continue;
+      result[key] = pruned;
+    }
+    return result;
+  }
+  return value;
+}
+
+module.exports = {
+  getPath,
+  interpolate,
+  pruneUndefined
+};

package/src/util/args.js

@@ -0,0 +1,74 @@
+function parseKeyValue(value, optionName) {
+  const index = value.indexOf("=");
+  if (index <= 0) {
+    throw new Error(`${optionName} expects key=value`);
+  }
+  return [value.slice(0, index), value.slice(index + 1)];
+}
+
+function camelOption(name) {
+  return name.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+}
+
+function parseArgs(tokens) {
+  const options = {
+    _: [],
+    set: {},
+    headers: {}
+  };
+
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = tokens[index];
+    if (!token.startsWith("--")) {
+      options._.push(token);
+      continue;
+    }
+
+    const raw = token.slice(2);
+    const equals = raw.indexOf("=");
+    const name = camelOption(equals >= 0 ? raw.slice(0, equals) : raw);
+    const inlineValue = equals >= 0 ? raw.slice(equals + 1) : undefined;
+    const booleanOption = new Set([
+      "dryRun",
+      "json",
+      "verbose",
+      "curl",
+      "noInteractive",
+      "unsafe",
+      "includeDangerous",
+      "noLogin",
+      "missing",
+      "help"
+    ]);
+
+    let value;
+    if (booleanOption.has(name)) {
+      value = inlineValue === undefined ? true : inlineValue !== "false";
+    } else if (inlineValue !== undefined) {
+      value = inlineValue;
+    } else {
+      index += 1;
+      if (index >= tokens.length) {
+        throw new Error(`--${raw} expects a value`);
+      }
+      value = tokens[index];
+    }
+
+    if (name === "set") {
+      const [key, parsedValue] = parseKeyValue(value, "--set");
+      options.set[key] = parsedValue;
+    } else if (name === "header") {
+      const [key, parsedValue] = parseKeyValue(value, "--header");
+      options.headers[key] = parsedValue;
+    } else {
+      options[name] = value;
+    }
+  }
+
+  return options;
+}
+
+module.exports = {
+  parseArgs,
+  parseKeyValue
+};

package/src/util/duration.js

@@ -0,0 +1,25 @@
+function parseDuration(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const raw = String(value).trim();
+  const match = raw.match(/^(\d+(?:\.\d+)?)(ms|s|m)?$/);
+  if (!match) {
+    throw new Error(`Invalid duration: ${value}`);
+  }
+  const amount = Number(match[1]);
+  const unit = match[2] || "ms";
+  if (unit === "ms") return amount;
+  if (unit === "s") return amount * 1000;
+  if (unit === "m") return amount * 60 * 1000;
+  throw new Error(`Invalid duration unit: ${unit}`);
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+module.exports = {
+  parseDuration,
+  sleep
+};

package/src/util/json.js

@@ -0,0 +1,24 @@
+function parseJsonObject(value, optionName) {
+  if (value === undefined || value === null || value === "") {
+    return {};
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch (error) {
+    throw new Error(`${optionName} must be valid JSON: ${error.message}`);
+  }
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new Error(`${optionName} must be a JSON object`);
+  }
+  return parsed;
+}
+
+function stableJson(value) {
+  return JSON.stringify(value, null, 2);
+}
+
+module.exports = {
+  parseJsonObject,
+  stableJson
+};

package/src/util/paths.js

@@ -0,0 +1,38 @@
+const path = require("node:path");
+
+const cliRoot = path.resolve(__dirname, "../..");
+let configuredRoot;
+
+function setConfigRoot(root) {
+  configuredRoot = root ? path.resolve(root) : undefined;
+}
+
+function configRoot() {
+  return path.resolve(process.env.EVT_CLI_ROOT || process.env.EVERYTHING_CLI_ROOT || configuredRoot || cliRoot);
+}
+
+function resolveCliPath(...parts) {
+  return path.resolve(configRoot(), ...parts);
+}
+
+function resolveConfigDir(name) {
+  const fs = require("node:fs");
+  const candidates = [
+    resolveCliPath(name),
+    resolveCliPath("data", name)
+  ];
+  return candidates.find((candidate) => fs.existsSync(candidate)) || candidates[0];
+}
+
+function defaultCachePath() {
+  return resolveCliPath(".cache", "session.local.json");
+}
+
+module.exports = {
+  cliRoot,
+  configRoot,
+  defaultCachePath,
+  resolveCliPath,
+  resolveConfigDir,
+  setConfigRoot
+};

package/src/util/redact.js

@@ -0,0 +1,49 @@
+const SENSITIVE_KEYS = new Set([
+  "authorization",
+  "password",
+  "token",
+  "googlecode",
+  "idtoken",
+  "temptoken",
+  "encodedbody"
+]);
+
+const REQUEST_CODE_PARENT_KEYS = new Set([
+  "body",
+  "inputs",
+  "args",
+  "set"
+]);
+
+function isSensitiveKey(key) {
+  return SENSITIVE_KEYS.has(String(key).toLowerCase());
+}
+
+function redact(value, parentKey = "") {
+  if (Array.isArray(value)) {
+    return value.map((item) => redact(item, parentKey));
+  }
+  if (!value || typeof value !== "object") {
+    return value;
+  }
+  return Object.fromEntries(
+    Object.entries(value).map(([key, item]) => [
+      key,
+      shouldRedactKey(key, parentKey) && item !== undefined && item !== null ? "***" : redact(item, key)
+    ])
+  );
+}
+
+function shouldRedactKey(key, parentKey) {
+  const normalized = String(key).toLowerCase();
+  if (isSensitiveKey(normalized)) {
+    return true;
+  }
+  return normalized === "code" && REQUEST_CODE_PARENT_KEYS.has(String(parentKey).toLowerCase());
+}
+
+module.exports = {
+  redact,
+  isSensitiveKey,
+  shouldRedactKey
+};