vmess-domain-rotator/substore/operator_template.js

/*
  Sub-Store operator (production-friendly)
  - Pull dynamic value from router/runtime and server/runtime JSON
  - Replace vmess server field for matched nodes
*/

const ROUTER_VALUE_JSON_URL = "http://192.168.50.1:8080/current_ip.json";
const SERVER_VALUE_JSON_URL = "https://git.dewofaurora.de/aurora/vmess-domain-rotator/raw/runtime-state/runtime/current_domain.json";
const ROUTER_MIN_SPEED_MB_PER_S = 5;
const VALUE_SOURCE_MODE = "server_only"; // default | server_only | router_only

const NODE_NAME_REGEX = /(argo|cf|vm|优选)/i;
const CACHE_KEY = `vmess-domain-rotator:${VALUE_SOURCE_MODE}`;
const CACHE_TTL_MS = 5 * 60 * 1000;
const JSON_VALUE_KEYS = ["domain", "ip"];

function logWithTime(message) {
  const ts = new Date().toISOString();
  console.log(`[${ts}] ${message}`);
}

async function fetchRuntimeJson(url, sourceName) {
  const $ = $substore;
  const { body, statusCode } = await $.http.get({
    url,
    headers: {
      Accept: "application/json",
      "Cache-Control": "no-cache"
    },
    timeout: 5000
  });

  if (statusCode < 200 || statusCode >= 300) {
    throw new Error(`${sourceName} http status ${statusCode}`);
  }

  let obj;
  try {
    obj = JSON.parse(body || "{}");
  } catch (e) {
    throw new Error(`${sourceName} invalid json: ${e.message}`);
  }

  return obj;
}

function extractValue(obj, sourceName) {
  let value = "";
  for (const key of JSON_VALUE_KEYS) {
    value = String(obj[key] || "").trim().toLowerCase();
    if (value) break;
  }

  if (!value) {
    throw new Error(`${sourceName} empty value field, expected one of: ${JSON_VALUE_KEYS.join(", ")}`);
  }

  return value;
}

function parseRouterSpeedMBps(routerObj) {
  const raw = String(routerObj?.top_candidates?.[0]?.download_speed || "").trim();
  if (!raw) {
    return { mbPerSec: null, raw: "", status: "missing", unit: "" };
  }

  const compact = raw.replace(/\s+/g, "");
  const normalized = compact.toLowerCase();
  const match = compact.match(/([0-9]+(?:\.[0-9]+)?)/);
  if (!match) {
    return { mbPerSec: null, raw, status: "invalid", unit: "" };
  }

  const numeric = Number(match[1]);
  if (!Number.isFinite(numeric) || numeric < 0) {
    return { mbPerSec: null, raw, status: "invalid", unit: "" };
  }

  let mbPerSec = numeric;
  let unit = "MB/s";

  if (compact.includes("MB/s")) {
    mbPerSec = numeric;
    unit = "MB/s";
  } else if (compact.includes("KB/s")) {
    mbPerSec = numeric / 1024;
    unit = "KB/s";
  } else if (compact.includes("GB/s")) {
    mbPerSec = numeric * 1024;
    unit = "GB/s";
  } else if (compact.includes("B/s")) {
    mbPerSec = numeric / (1024 * 1024);
    unit = "B/s";
  } else if (normalized.includes("mbps") || normalized.includes("mb/s")) {
    mbPerSec = numeric / 8;
    unit = "Mbps";
  } else if (normalized.includes("gbps") || normalized.includes("gb/s")) {
    mbPerSec = (numeric * 1024) / 8;
    unit = "Gbps";
  } else if (normalized.includes("kbps") || normalized.includes("kb/s")) {
    mbPerSec = (numeric / 1024) / 8;
    unit = "Kbps";
  } else if (normalized.includes("bps") || normalized.includes("b/s")) {
    mbPerSec = (numeric / (1024 * 1024)) / 8;
    unit = "b/s";
  }

  return { mbPerSec, raw, status: "ok", unit };
}


async function selectValueRouterFirst() {
  const telemetry = {
    router: { ok: false, value: "", status: "", sourceType: "", error: "", speedRaw: "", speedMBps: null, speedParse: "missing", speedUnit: "" },
    server: { ok: false, value: "", status: "", sourceType: "", error: "" }
  };

  try {
    const routerObj = await fetchRuntimeJson(ROUTER_VALUE_JSON_URL, "router");
    const routerValue = extractValue(routerObj, "router");
    const speed = parseRouterSpeedMBps(routerObj);

    telemetry.router.ok = true;
    telemetry.router.value = routerValue;
    telemetry.router.status = String(routerObj?.status || "");
    telemetry.router.sourceType = String(routerObj?.source_type || "");
    telemetry.router.speedRaw = speed.raw;
    telemetry.router.speedMBps = speed.mbPerSec;
    telemetry.router.speedParse = speed.status;
    telemetry.router.speedUnit = speed.unit;
  } catch (e) {
    telemetry.router.error = String(e.message || e);
  }

  try {
    const serverObj = await fetchRuntimeJson(SERVER_VALUE_JSON_URL, "server");
    const serverValue = extractValue(serverObj, "server");

    telemetry.server.ok = true;
    telemetry.server.value = serverValue;
    telemetry.server.status = String(serverObj?.status || "");
    telemetry.server.sourceType = String(serverObj?.source_type || "");
  } catch (e) {
    telemetry.server.error = String(e.message || e);
  }

  if (!telemetry.router.ok && !telemetry.server.ok) {
    throw new Error(`router failed: ${telemetry.router.error}; server failed: ${telemetry.server.error}`);
  }

  if (!telemetry.router.ok && telemetry.server.ok) {
    return { value: telemetry.server.value, chosenSource: "server", reason: "router_fail", telemetry };
  }

  if (telemetry.router.ok && !telemetry.server.ok) {
    return { value: telemetry.router.value, chosenSource: "router", reason: "server_fail", telemetry };
  }

  if (telemetry.router.speedParse === "ok" && telemetry.router.speedMBps < ROUTER_MIN_SPEED_MB_PER_S) {
    return { value: telemetry.server.value, chosenSource: "server", reason: "router_low_speed", telemetry };
  }

  return { value: telemetry.router.value, chosenSource: "router", reason: "router_preferred", telemetry };
}

async function selectValueByMode() {
  if (VALUE_SOURCE_MODE === "default") {
    return selectValueRouterFirst();
  }

  if (VALUE_SOURCE_MODE === "server_only") {
    const serverObj = await fetchRuntimeJson(SERVER_VALUE_JSON_URL, "server");
    const serverValue = extractValue(serverObj, "server");
    return {
      value: serverValue,
      chosenSource: "server",
      reason: "server_only_mode",
      telemetry: {
        router: { ok: false, value: "", status: "", sourceType: "", error: "skipped_by_mode", speedRaw: "", speedMBps: null, speedParse: "missing", speedUnit: "" },
        server: { ok: true, value: serverValue, status: String(serverObj?.status || ""), sourceType: String(serverObj?.source_type || ""), error: "" }
      }
    };
  }

  if (VALUE_SOURCE_MODE === "router_only") {
    const routerObj = await fetchRuntimeJson(ROUTER_VALUE_JSON_URL, "router");
    const routerValue = extractValue(routerObj, "router");
    const speed = parseRouterSpeedMBps(routerObj);
    return {
      value: routerValue,
      chosenSource: "router",
      reason: "router_only_mode",
      telemetry: {
        router: {
          ok: true,
          value: routerValue,
          status: String(routerObj?.status || ""),
          sourceType: String(routerObj?.source_type || ""),
          error: "",
          speedRaw: speed.raw,
          speedMBps: speed.mbPerSec,
          speedParse: speed.status,
          speedUnit: speed.unit
        },
        server: { ok: false, value: "", status: "", sourceType: "", error: "skipped_by_mode" }
      }
    };
  }

  throw new Error(`invalid VALUE_SOURCE_MODE=${VALUE_SOURCE_MODE}, expected: default | server_only | router_only`);
}

function extractOverrideDomain() {
  const args = typeof $arguments !== "undefined" ? $arguments : {};

  // --- domain_override 开关：默认 true，显式设为 false/0/off/no 时禁用域名覆盖 ---
  const overrideRaw = String(args?.domain_override ?? "").trim().toLowerCase();
  if (overrideRaw && ["false", "0", "off", "no"].includes(overrideRaw)) {
    logWithTime(`[vmess-domain-rotator] domain override disabled by domain_override=${overrideRaw}`);
    return null;
  }

  // --- domain 参数 ---
  const raw = String(args?.domain || "").trim().toLowerCase();
  if (!raw) return null;

  // 基本格式校验：域名或 IPv4/IPv6
  const domainRe = /^([a-z0-9]([a-z0-9-]*[a-z0-9])?\.)+[a-z]{2,}$/;
  const ipv4Re = /^(\d{1,3}\.){3}\d{1,3}$/;
  const ipv6Re = /^\[?[0-9a-f:]+\]?$/;

  if (!domainRe.test(raw) && !ipv4Re.test(raw) && !ipv6Re.test(raw)) {
    logWithTime(`[vmess-domain-rotator] invalid override domain format: "${raw}", ignoring`);
    return null;
  }

  return raw;
}

async function operator(proxies = [], targetPlatform, context) {
  // --- URL parameter override (highest priority) ---
  const overrideDomain = extractOverrideDomain();

  const cache = scriptResourceCache;
  let value = overrideDomain || cache.get(CACHE_KEY);
  let decision = null;
  let isOverride = !!overrideDomain;

  if (!value) {
    try {
      decision = await selectValueByMode();
      value = decision.value;
      cache.set(CACHE_KEY, value, CACHE_TTL_MS);
    } catch (e) {
      logWithTime(`[vmess-domain-rotator] fetch failed: ${e.message}`);
      return proxies;
    }
  }

  let updated = 0;
  for (const p of proxies) {
    if (!p || p.type !== "vmess") continue;
    if (!NODE_NAME_REGEX.test(p.name || "")) continue;

    if (p.server !== value) {
      p.server = value;
      updated += 1;
    }
  }

  if (decision) {
    const t = decision.telemetry;
    logWithTime(
      `[vmess-domain-rotator] mode=${VALUE_SOURCE_MODE}, chosen=${decision.chosenSource}, reason=${decision.reason}, router_status=${t.router.status || "n/a"}, server_status=${t.server.status || "n/a"}, router_speed_raw=${t.router.speedRaw || "n/a"}, router_speed_mb_per_s=${t.router.speedMBps == null ? "n/a" : t.router.speedMBps.toFixed(3)}, speed_parse=${t.router.speedParse}, threshold_mb_per_s=${ROUTER_MIN_SPEED_MB_PER_S}, value=${value}, updated=${updated}, total=${proxies.length}, target=${targetPlatform}`
    );
  } else if (isOverride) {
    logWithTime(
      `[vmess-domain-rotator] mode=override, chosen=url_param, value=${value}, updated=${updated}, total=${proxies.length}, target=${targetPlatform}`
    );
  } else {
    logWithTime(`[vmess-domain-rotator] mode=${VALUE_SOURCE_MODE}, chosen=cache, value=${value}, updated=${updated}, total=${proxies.length}, target=${targetPlatform}`);
  }

  return proxies;
}