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"];
const LOCAL_MAX_AGE_SEC = 86400; // 24 hours: router data older than this will fallback to server

function normalizeIPv4(raw) {
  if (typeof raw !== "string") return null;
  const parts = raw.split(".");
  if (parts.length !== 4) return null;
  for (const part of parts) {
    if (!/^\d{1,3}$/.test(part)) return null;
    const n = Number(part);
    if (!Number.isInteger(n) || n < 0 || n > 255) return null;
  }
  return parts.map((part) => String(Number(part))).join(".");
}

function normalizeIPv6(raw) {
  if (typeof raw !== "string") return null;
  let value = raw;
  if (value.startsWith("[") || value.endsWith("]")) {
    if (!(value.startsWith("[") && value.endsWith("]"))) return null;
    value = value.slice(1, -1);
  }

  if (!value || !/^[0-9a-f:]+$/i.test(value)) return null;
  if ((value.match(/::/g) || []).length > 1) return null;

  const hasCompression = value.includes("::");
  const sides = value.split("::");
  const left = sides[0] ? sides[0].split(":") : [];
  const right = sides.length > 1 && sides[1] ? sides[1].split(":") : [];
  const groups = left.concat(right);

  if (groups.some((part) => !/^[0-9a-f]{1,4}$/i.test(part))) return null;
  if (hasCompression) {
    if (groups.length >= 8) return null;
  } else if (groups.length !== 8) {
    return null;
  }

  return value.toLowerCase();
}

function isValidHostOrIp(raw) {
  if (!raw || typeof raw !== "string") return false;
  const s = raw.trim().toLowerCase();
  if (normalizeIPv4(s) || normalizeIPv6(s)) return true;
  // RFC 1123 domain regex
  const domainRe = /^([a-z0-9]([a-z0-9-]*[a-z0-9])?\.)+(?=[a-z0-9-]{2,}$)(?=[a-z0-9-]*[a-z])[a-z0-9]([a-z0-9-]*[a-z0-9])?$/i;
  return domainRe.test(s);
}

function isRouterDataFresh(routerObj) {
  if (!routerObj || typeof routerObj !== "object") return false;
  const updatedAt = routerObj.updated_at;
  if (!updatedAt) return true;
  const updatedTime = Date.parse(updatedAt);
  if (Number.isNaN(updatedTime)) return true;
  const ageSec = (Date.now() - updatedTime) / 1000;
  return ageSec <= LOCAL_MAX_AGE_SEC;
}

function extractValue(obj, sourceName) {
  if (!obj || typeof obj !== "object") {
    throw new Error(`${sourceName} payload is not an object`);
  }
  let value = "";
  for (const key of JSON_VALUE_KEYS) {
    const candidate = obj[key];
    if (typeof candidate === "string") {
      const trimmed = candidate.trim().toLowerCase();
      if (trimmed) {
        value = trimmed;
        break;
      }
    }
  }

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

  if (!isValidHostOrIp(value)) {
    throw new Error(`${sourceName} value '${value}' is not a valid domain or IP address`);
  }

  return value;
}

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

async function fetchRuntimeJson(url, sourceName) {
  let body, statusCode;
  if (typeof $substore !== "undefined" && $substore?.http?.get) {
    const res = await $substore.http.get({
      url,
      headers: {
        Accept: "application/json",
        "Cache-Control": "no-cache"
      },
      timeout: 5000
    });
    body = res.body;
    statusCode = res.statusCode;
  } else if (typeof $httpClient !== "undefined" && $httpClient.get) {
    const res = await new Promise((resolve, reject) => {
      $httpClient.get({ url, timeout: 5000, headers: { Accept: "application/json" } }, (error, response, data) => {
        if (error) reject(new Error(error));
        else resolve({ statusCode: response.status || response.statusCode, body: data });
      });
    });
    body = res.body;
    statusCode = res.statusCode;
  } else {
    throw new Error(`${sourceName} no supported http client ($substore.http or $httpClient) found`);
  }

  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 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");
    if (!isRouterDataFresh(routerObj)) {
      throw new Error(`router data stale: updated_at=${routerObj.updated_at} exceeds ${LOCAL_MAX_AGE_SEC}s`);
    }
    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-z0-9-]{2,}$)(?=[a-z0-9-]*[a-z])[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
  const ipv4 = normalizeIPv4(raw);
  if (ipv4) return ipv4;

  const ipv6 = normalizeIPv6(raw);
  if (ipv6) return ipv6;

  if (domainRe.test(raw)) return raw;

  logWithTime(`[vmess-domain-rotator] invalid override domain format: "${raw}", ignoring`);
  return null;
}

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;
}