@icyouo/evt-cli 0.1.0

package/src/config/yaml.js

@@ -0,0 +1,161 @@
+function prepareLines(text) {
+  return text
+    .replace(/\r\n/g, "\n")
+    .split("\n")
+    .map((raw, number) => ({
+      number: number + 1,
+      indent: raw.match(/^ */)[0].length,
+      text: raw.trimEnd()
+    }))
+    .filter((line) => {
+      const trimmed = line.text.trim();
+      return trimmed !== "" && !trimmed.startsWith("#");
+    });
+}
+
+function splitKeyValue(text) {
+  const index = text.indexOf(":");
+  if (index < 0) {
+    return null;
+  }
+  return [text.slice(0, index).trim(), text.slice(index + 1).trim()];
+}
+
+function parseScalar(raw) {
+  const value = raw.trim();
+  if (value === "") return "";
+  if (value === "null" || value === "~") return null;
+  if (value === "true") return true;
+  if (value === "false") return false;
+  if (value === "{}") return {};
+  if (value === "[]") return [];
+  if (value === "\"\"") return "";
+  if (value === "''") return "";
+  if ((value.startsWith("\"") && value.endsWith("\"")) || (value.startsWith("'") && value.endsWith("'"))) {
+    const body = value.slice(1, -1);
+    return value.startsWith("\"") ? body.replace(/\\"/g, "\"") : body.replace(/''/g, "'");
+  }
+  if (/^-?\d+(?:\.\d+)?$/.test(value)) {
+    return Number(value);
+  }
+  return value;
+}
+
+function parseBlock(lines, startIndex, indent) {
+  let index = startIndex;
+  while (index < lines.length && lines[index].indent < indent) {
+    index += 1;
+  }
+  if (index >= lines.length) {
+    return { value: {}, index };
+  }
+  const line = lines[index];
+  if (line.indent !== indent) {
+    throw new Error(`Invalid YAML indentation at line ${line.number}`);
+  }
+  return line.text.trimStart().startsWith("- ")
+    ? parseSequence(lines, index, indent)
+    : parseMapping(lines, index, indent);
+}
+
+function parseMapping(lines, startIndex, indent) {
+  const result = {};
+  let index = startIndex;
+
+  while (index < lines.length) {
+    const line = lines[index];
+    if (line.indent < indent) break;
+    if (line.indent > indent) {
+      throw new Error(`Unexpected indentation at line ${line.number}`);
+    }
+
+    const text = line.text.trim();
+    if (text.startsWith("- ")) break;
+
+    const pair = splitKeyValue(text);
+    if (!pair) {
+      throw new Error(`Expected key: value at line ${line.number}`);
+    }
+
+    const [key, rawValue] = pair;
+    index += 1;
+    if (rawValue === "") {
+      if (index < lines.length && lines[index].indent > indent) {
+        const child = parseBlock(lines, index, lines[index].indent);
+        result[key] = child.value;
+        index = child.index;
+      } else {
+        result[key] = {};
+      }
+    } else {
+      result[key] = parseScalar(rawValue);
+    }
+  }
+
+  return { value: result, index };
+}
+
+function parseSequence(lines, startIndex, indent) {
+  const result = [];
+  let index = startIndex;
+
+  while (index < lines.length) {
+    const line = lines[index];
+    if (line.indent < indent) break;
+    if (line.indent > indent) {
+      throw new Error(`Unexpected indentation at line ${line.number}`);
+    }
+
+    const text = line.text.trim();
+    if (!text.startsWith("- ")) break;
+    const itemText = text.slice(2).trim();
+    index += 1;
+
+    if (itemText === "") {
+      const child = parseBlock(lines, index, lines[index].indent);
+      result.push(child.value);
+      index = child.index;
+      continue;
+    }
+
+    const pair = splitKeyValue(itemText);
+    if (!pair) {
+      result.push(parseScalar(itemText));
+      continue;
+    }
+
+    const item = {};
+    const [key, rawValue] = pair;
+    if (rawValue === "") {
+      if (index < lines.length && lines[index].indent > indent) {
+        const child = parseBlock(lines, index, lines[index].indent);
+        item[key] = child.value;
+        index = child.index;
+      } else {
+        item[key] = {};
+      }
+    } else {
+      item[key] = parseScalar(rawValue);
+    }
+
+    if (index < lines.length && lines[index].indent > indent) {
+      const child = parseMapping(lines, index, lines[index].indent);
+      Object.assign(item, child.value);
+      index = child.index;
+    }
+
+    result.push(item);
+  }
+
+  return { value: result, index };
+}
+
+function parseYaml(text) {
+  const lines = prepareLines(text);
+  if (lines.length === 0) return {};
+  return parseBlock(lines, 0, lines[0].indent).value;
+}
+
+module.exports = {
+  parseYaml
+};

package/src/flow/inputResolver.js

@@ -0,0 +1,72 @@
+const readline = require("node:readline");
+
+function envNameFor(key, input) {
+  return input.env || `NEPTUNE_${key.replace(/[^a-zA-Z0-9]/g, "_").toUpperCase()}`;
+}
+
+function promptValue(key, input) {
+  const label = input.prompt || key;
+  const suffix = input.default !== undefined && input.default !== "" ? ` (${input.default})` : "";
+  const question = `${label}${suffix}: `;
+
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({
+      input: process.stdin,
+      output: process.stdout,
+      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);
+    });
+  });
+}
+
+async function resolveInputs(flow, options) {
+  const definitions = flow.inputs || {};
+  const result = {};
+
+  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) {
+      value = await promptValue(key, input);
+    } else if (input.default !== undefined) {
+      value = input.default;
+    }
+
+    if (input.required && (value === undefined || value === null || value === "")) {
+      throw new Error(`Missing required flow input: ${key}`);
+    }
+    if (value !== undefined) {
+      result[key] = value;
+    }
+  }
+
+  return result;
+}
+
+module.exports = {
+  resolveInputs
+};

package/src/flow/runner.js

@@ -0,0 +1,156 @@
+const { executeEndpoint } = require("../http/client");
+const { getPath, interpolate, pruneUndefined } = require("../template/interpolate");
+const { parseDuration, sleep } = require("../util/duration");
+const { resolveInputs } = require("./inputResolver");
+const { writeCache } = require("../cache/sessionCache");
+
+function isTruthyWhen(value) {
+  return !(value === undefined || value === null || value === false || value === "" || value === "false");
+}
+
+function normalizeExpect(expect) {
+  if (!expect) return [];
+  return Array.isArray(expect) ? expect : [expect];
+}
+
+function assertExpectation(stepId, result, expectation) {
+  const path = expectation.path;
+  if (!path) {
+    throw new Error(`Flow step ${stepId} has expect without path`);
+  }
+  const actual = getPath(result, path);
+  if ("equals" in expectation && actual !== expectation.equals) {
+    throw new Error(`Flow step ${stepId} expected ${path} to equal ${expectation.equals}, got ${actual}`);
+  }
+  if (expectation.exists && (actual === undefined || actual === null || actual === "")) {
+    throw new Error(`Flow step ${stepId} expected ${path} to exist`);
+  }
+}
+
+async function maybeWait(value, dryRun) {
+  const ms = parseDuration(value);
+  if (!dryRun) {
+    await sleep(ms);
+  }
+  return ms;
+}
+
+async function runFlow(flow, options) {
+  const inputs = await resolveInputs(flow, options);
+  const steps = {};
+  const timeline = [];
+  const baseContext = {
+    profile: options.profile,
+    cache: options.cache || {},
+    args: options.set || {},
+    inputs,
+    env: process.env,
+    vars: {},
+    steps
+  };
+
+  for (const step of flow.steps || []) {
+    if (step.when !== undefined) {
+      const shouldRun = interpolate(step.when, baseContext);
+      if (!isTruthyWhen(shouldRun)) {
+        timeline.push({ id: step.id, skipped: true });
+        continue;
+      }
+    }
+
+    if (step.wait !== undefined && !step.call) {
+      const ms = await maybeWait(step.wait, options.dryRun);
+      timeline.push({ wait: ms, dryRun: Boolean(options.dryRun) });
+      continue;
+    }
+
+    if (!step.call) {
+      throw new Error("Flow step must declare call or wait");
+    }
+
+    const endpoint = options.registry[step.call];
+    if (!endpoint) {
+      throw new Error(`Unknown endpoint in flow: ${step.call}`);
+    }
+
+    const result = await executeEndpoint(endpoint, {
+      ...options,
+      context: baseContext,
+      cache: baseContext.cache,
+      body: step.body || {},
+      query: step.query || {},
+      headers: step.headers || {}
+    });
+
+    const id = step.id || step.call;
+    if (!options.dryRun) {
+      for (const expectation of normalizeExpect(step.expect)) {
+        assertExpectation(id, result, expectation);
+      }
+    }
+    steps[id] = result;
+    if (step.extract && !options.dryRun) {
+      for (const [key, sourcePath] of Object.entries(step.extract)) {
+        baseContext.vars[key] = getPath(result, sourcePath);
+      }
+    }
+    if (step.cache && !options.dryRun) {
+      Object.assign(baseContext.cache, pruneUndefined(interpolate(step.cache, baseContext)));
+    }
+    timeline.push({
+      id,
+      call: step.call,
+      dryRun: Boolean(options.dryRun),
+      status: result.status,
+      request: result.request,
+      extract: step.extract ? Object.keys(step.extract) : undefined
+    });
+
+    if (step.afterWait !== undefined) {
+      const ms = await maybeWait(step.afterWait, options.dryRun);
+      timeline.push({ id, afterWait: ms, dryRun: Boolean(options.dryRun) });
+    }
+  }
+
+  let savedCache;
+  if (flow.save && flow.save.cache && !options.dryRun) {
+    const rendered = pruneUndefined(interpolate(flow.save.cache, baseContext));
+    const saveContext = {
+      cache: rendered,
+      flow: {
+        name: flow.name
+      },
+      steps
+    };
+    for (const requiredPath of flow.save.required || []) {
+      const value = getPath(saveContext, requiredPath);
+      if (value === undefined || value === null || value === "") {
+        throw new Error(`Flow ${flow.name} did not produce required save value: ${requiredPath}`);
+      }
+    }
+    savedCache = {
+      ...(options.cache || {}),
+      ...rendered,
+      updatedAt: new Date().toISOString(),
+      lastFlow: {
+        name: flow.name,
+        finishedAt: new Date().toISOString()
+      }
+    };
+    writeCache(options.cachePath, savedCache);
+  }
+
+  return {
+    flow: flow.name,
+    inputs: Object.keys(inputs),
+    vars: Object.keys(baseContext.vars),
+    timeline,
+    steps,
+    savedCache: Boolean(savedCache)
+  };
+}
+
+module.exports = {
+  runFlow,
+  isTruthyWhen
+};

package/src/http/client.js

@@ -0,0 +1,46 @@
+const { buildRequest, toCurl } = require("./requestBuilder");
+
+async function executeEndpoint(endpoint, options) {
+  if (endpoint.dangerous && !options.dryRun && !options.unsafe) {
+    throw new Error(`Endpoint ${endpoint.id} is dangerous. Re-run with --unsafe to execute it.`);
+  }
+  const request = buildRequest(endpoint, options);
+  if (options.dryRun) {
+    return {
+      dryRun: true,
+      request,
+      curl: toCurl(request)
+    };
+  }
+
+  const response = await fetch(request.url, {
+    method: request.method,
+    headers: request.headers,
+    body: request.encodedBody
+  });
+
+  const text = await response.text();
+  let parsed = text;
+  try {
+    parsed = text ? JSON.parse(text) : null;
+  } catch (_) {
+    // Keep raw text for non-JSON responses.
+  }
+
+  if (!response.ok) {
+    throw new Error(`HTTP ${response.status}: ${typeof parsed === "string" ? parsed : JSON.stringify(parsed)}`);
+  }
+  if (parsed && typeof parsed === "object" && "code" in parsed && parsed.code !== 0) {
+    throw new Error(`API ${parsed.code}: ${parsed.msg || "Business error"}`);
+  }
+
+  return {
+    status: response.status,
+    response: parsed,
+    data: parsed && typeof parsed === "object" && "data" in parsed ? parsed.data : parsed
+  };
+}
+
+module.exports = {
+  executeEndpoint
+};

package/src/http/requestBuilder.js

@@ -0,0 +1,218 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const { URL, URLSearchParams } = require("node:url");
+const { materializeEndpointSchema } = require("../config/schema");
+const { interpolate, pruneUndefined } = require("../template/interpolate");
+const { redact } = require("../util/redact");
+
+function mergeObjects(...values) {
+  return Object.assign({}, ...values.filter((value) => value && typeof value === "object"));
+}
+
+function resolveBaseUrl(profile, endpoint, override) {
+  if (override) return override;
+  if (profile.baseUrls) {
+    return profile.baseUrls[endpoint.service || "default"] || profile.baseUrls.default || profile.baseUrl;
+  }
+  return profile.baseUrl;
+}
+
+function joinUrl(baseUrl, endpointPath) {
+  if (/^https?:\/\//i.test(endpointPath)) {
+    return endpointPath;
+  }
+  if (!baseUrl) {
+    throw new Error("Missing baseUrl");
+  }
+  return `${baseUrl.replace(/\/+$/, "")}/${String(endpointPath).replace(/^\/+/, "")}`;
+}
+
+function renderPath(endpointPath, context, dryRun) {
+  const source = mergeObjects(context.inputs, context.vars, context.args);
+  return String(interpolate(endpointPath, context)).replace(/:([A-Za-z_][A-Za-z0-9_]*)/g, (token, key) => {
+    const value = source[key];
+    if (value === undefined || value === null || value === "") {
+      if (!dryRun) {
+        throw new Error(`Missing path parameter: ${key}`);
+      }
+      return token;
+    }
+    return encodeURIComponent(String(value));
+  });
+}
+
+function encodeBody(bodyType, body, options = {}) {
+  if (!body || Object.keys(body).length === 0) return undefined;
+  if (bodyType === "formUrlEncoded") {
+    return new URLSearchParams(body).toString();
+  }
+  if (bodyType === "json") {
+    return JSON.stringify(body);
+  }
+  if (bodyType === "multipart") {
+    if (options.dryRun) {
+      return undefined;
+    }
+    const form = new FormData();
+    for (const [key, value] of Object.entries(body)) {
+      if (value === undefined || value === null) continue;
+      if (key === "file" || key === "filePath") {
+        const filePath = String(value);
+        const file = fs.readFileSync(filePath);
+        const contentType = body.contentType || "application/octet-stream";
+        const filename = body.filename || path.basename(filePath);
+        form.append("file", new Blob([file], { type: contentType }), filename);
+        continue;
+      }
+      if (key === "filename" || key === "contentType") continue;
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          form.append(key, String(item));
+        }
+      } else {
+        form.append(key, String(value));
+      }
+    }
+    return form;
+  }
+  if (bodyType === "raw") {
+    return typeof body === "string" ? body : JSON.stringify(body);
+  }
+  throw new Error(`Unsupported bodyType: ${bodyType}`);
+}
+
+function contentTypeFor(bodyType) {
+  if (bodyType === "formUrlEncoded") return "application/x-www-form-urlencoded";
+  if (bodyType === "json") return "application/json";
+  return undefined;
+}
+
+function applyAuth(headers, endpoint, profile, cache, dryRun) {
+  if (!endpoint.auth) return;
+  const token = cache.token;
+  if (!token && !dryRun) {
+    throw new Error(`Endpoint ${endpoint.id} requires login token. Run login flow first.`);
+  }
+  if (!token) return;
+  const auth = profile.auth || {};
+  const headerName = auth.header || "Authorization";
+  headers[headerName] = auth.scheme === "bearer" ? `Bearer ${token}` : token;
+}
+
+function buildRequest(endpoint, options) {
+  const context = options.context;
+  const schemaValues = materializeEndpointSchema(endpoint, context, {
+    body: options.body || {},
+    query: options.query || {}
+  }, { dryRun: options.dryRun });
+  const schemaContext = {
+    ...context,
+    args: mergeObjects(schemaValues.path, context.args)
+  };
+  const endpointHeaders = interpolate(endpoint.headers || {}, context);
+  const stepHeaders = interpolate(options.headers || {}, context);
+  const cliHeaders = options.cliHeaders || {};
+  const bodyType = options.bodyType || endpoint.bodyType || "json";
+  const method = String(options.method || endpoint.method || "GET").toUpperCase();
+
+  const renderedEndpointBody = pruneUndefined(interpolate(endpoint.body || {}, context));
+  const renderedBodyOverride = pruneUndefined(interpolate(options.body || {}, context));
+  const renderedEndpointQuery = pruneUndefined(interpolate(endpoint.query || {}, context));
+  const renderedQueryOverride = pruneUndefined(interpolate(options.query || {}, context));
+
+  const body = pruneUndefined(mergeObjects(schemaValues.body, renderedEndpointBody, renderedBodyOverride));
+  const query = pruneUndefined(mergeObjects(schemaValues.query, renderedEndpointQuery, renderedQueryOverride));
+
+  const headers = pruneUndefined(
+    mergeObjects(
+      { Accept: "application/json" },
+      interpolate(options.profile.headers || {}, context),
+      endpointHeaders,
+      stepHeaders,
+      cliHeaders
+    ),
+    { dropEmptyStrings: true }
+  );
+
+  const contentType = contentTypeFor(bodyType);
+  if (contentType && method !== "GET" && method !== "DELETE") {
+    headers["Content-Type"] = contentType;
+  }
+  if (bodyType === "multipart") {
+    delete headers["Content-Type"];
+  }
+  applyAuth(headers, endpoint, options.profile, options.cache || {}, options.dryRun);
+
+  const baseUrl = resolveBaseUrl(options.profile, endpoint, options.baseUrl);
+  const endpointPath = renderPath(endpoint.path, schemaContext, options.dryRun);
+  const url = new URL(joinUrl(baseUrl, endpointPath));
+  for (const [key, value] of Object.entries(query)) {
+    if (value === undefined || value === null) continue;
+    url.searchParams.set(key, String(value));
+  }
+
+  return {
+    endpoint: endpoint.id,
+    method,
+    url: url.toString(),
+    headers,
+    bodyType,
+    body,
+    encodedBody: method === "GET" ? undefined : encodeBody(bodyType, body, { dryRun: options.dryRun })
+  };
+}
+
+function encodeCurlBody(request) {
+  const safeBody = redact(request.body || {});
+  if (request.bodyType === "formUrlEncoded") {
+    return new URLSearchParams(safeBody).toString();
+  }
+  if (request.bodyType === "json") {
+    return JSON.stringify(safeBody);
+  }
+  if (typeof safeBody === "string") {
+    return safeBody;
+  }
+  return JSON.stringify(safeBody);
+}
+
+function addMultipartCurlParts(parts, request) {
+  const safeBody = redact(request.body || {});
+  for (const [key, value] of Object.entries(safeBody)) {
+    if (value === undefined || value === null) continue;
+    if (key === "file" || key === "filePath") {
+      parts.push("-F", JSON.stringify(`file=@${value}`));
+      continue;
+    }
+    if (key === "filename" || key === "contentType") continue;
+    if (Array.isArray(value)) {
+      for (const item of value) {
+        parts.push("-F", JSON.stringify(`${key}=${item}`));
+      }
+    } else {
+      parts.push("-F", JSON.stringify(`${key}=${value}`));
+    }
+  }
+}
+
+function toCurl(request) {
+  const parts = ["curl", "-X", request.method, JSON.stringify(request.url)];
+  for (const [key, value] of Object.entries(redact(request.headers))) {
+    parts.push("-H", JSON.stringify(`${key}: ${value}`));
+  }
+  if (request.bodyType === "multipart") {
+    addMultipartCurlParts(parts, request);
+    return parts.join(" ");
+  }
+  if (request.encodedBody !== undefined) {
+    parts.push("--data", JSON.stringify(encodeCurlBody(request)));
+  }
+  return parts.join(" ");
+}
+
+module.exports = {
+  buildRequest,
+  toCurl,
+  mergeObjects,
+  resolveBaseUrl
+};