fogact 1.2.6 → 1.2.7

package/lib/services/node-service.js

@@ -1,38 +1,122 @@
 "use strict";
 
+const { execFile } = require("child_process");
+const net = require("net");
 const { testNode } = require("./fogact-api");
 
+const PROBE_TIMEOUT_MS = 5000;
+
+function parseNodeUrl(nodeUrl) {
+  const url = new URL(nodeUrl);
+  return {
+    hostname: url.hostname,
+    port: Number(url.port || (url.protocol === "https:" ? 443 : 80)),
+    protocol: url.protocol,
+  };
+}
+
+function execPing(hostname) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const child = execFile("ping", ["-c", "1", "-W", "2", hostname], { timeout: 3000 }, (error, stdout) => {
+      if (error) {
+        resolve({ ok: false, latency: -1, error: error.message });
+        return;
+      }
+      const match = String(stdout).match(/time[=<]([0-9.]+)\s*ms/i);
+      resolve({ ok: true, latency: match ? Math.round(Number(match[1])) : Date.now() - start });
+    });
+    child.on("error", (error) => resolve({ ok: false, latency: -1, error: error.message }));
+  });
+}
+
+function testTcp(hostname, port, timeout = PROBE_TIMEOUT_MS) {
+  return new Promise((resolve) => {
+    const start = Date.now();
+    const socket = net.createConnection({ host: hostname, port });
+    let settled = false;
+
+    const done = (result) => {
+      if (settled) return;
+      settled = true;
+      socket.destroy();
+      resolve(result);
+    };
+
+    socket.setTimeout(timeout);
+    socket.once("connect", () => done({ ok: true, latency: Date.now() - start }));
+    socket.once("timeout", () => done({ ok: false, latency: -1, error: "TCP timeout" }));
+    socket.once("error", (error) => done({ ok: false, latency: -1, error: error.message }));
+  });
+}
+
+async function probeNode(node) {
+  const { hostname, port } = parseNodeUrl(node.url);
+  const [ping, tcp, http] = await Promise.all([
+    execPing(hostname),
+    testTcp(hostname, port),
+    testNode(node.url),
+  ]);
+
+  return {
+    ping,
+    tcp,
+    http: {
+      ok: Boolean(http.available),
+      latency: Number(http.latency || -1),
+      error: http.error,
+    },
+  };
+}
+
+function getSuccessfulLatencies(probes) {
+  return probes.flatMap((probe) => [probe.ping, probe.tcp, probe.http])
+    .filter((entry) => entry && entry.ok && Number(entry.latency) >= 0)
+    .map((entry) => Number(entry.latency));
+}
+
+function summarizeProbeResults(probes) {
+  const last = probes[probes.length - 1] || {};
+  const latencies = getSuccessfulLatencies(probes);
+  const avgLatency = latencies.length
+    ? Math.round(latencies.reduce((sum, value) => sum + value, 0) / latencies.length)
+    : -1;
+  const latencyStdDev = latencies.length
+    ? Math.round(Math.sqrt(latencies.reduce((sum, value) => sum + Math.pow(value - avgLatency, 2), 0) / latencies.length))
+    : 0;
+  const successRate = probes.length
+    ? probes.filter((probe) => probe.tcp?.ok && probe.http?.ok).length / probes.length
+    : 0;
+  const available = probes.some((probe) => probe.tcp?.ok && probe.http?.ok);
+
+  return {
+    available,
+    reachable: available,
+    latency: avgLatency,
+    avgLatency,
+    latencyStdDev,
+    successRate,
+    ping: last.ping || { ok: false, latency: -1 },
+    tcp: last.tcp || { ok: false, latency: -1 },
+    http: last.http || { ok: false, latency: -1 },
+    error: available ? undefined : last.http?.error || last.tcp?.error || last.ping?.error || "节点不可达",
+  };
+}
+
 async function testNodes(nodes, onProgress = null) {
   const results = [];
 
   for (const node of nodes) {
     const probes = [];
     for (let index = 0; index < 3; index += 1) {
-      const result = await testNode(node.url);
-      probes.push(result);
+      probes.push(await probeNode(node));
     }
 
-    const availableProbes = probes.filter((probe) => probe.available);
-    const latencies = availableProbes.map((probe) => probe.latency);
-    const avgLatency = latencies.length
-      ? Math.round(latencies.reduce((sum, value) => sum + value, 0) / latencies.length)
-      : -1;
-    const latencyStdDev = latencies.length
-      ? Math.round(Math.sqrt(latencies.reduce((sum, value) => sum + Math.pow(value - avgLatency, 2), 0) / latencies.length))
-      : 0;
-    const successRate = availableProbes.length / probes.length;
-    const available = successRate > 0 && avgLatency >= 0;
-
+    const summary = summarizeProbeResults(probes);
     results.push({
       ...node,
-      available,
-      reachable: available,
-      latency: avgLatency,
-      avgLatency,
-      latencyStdDev,
-      successRate,
-      score: scoreNode({ available, avgLatency, latencyStdDev, successRate }),
-      error: available ? undefined : probes.find((probe) => probe.error)?.error || "节点不可达",
+      ...summary,
+      score: scoreNode(summary),
     });
 
     if (onProgress) onProgress(node, results.length, nodes.length);
@@ -46,7 +130,9 @@ function scoreNode(result) {
   const latencyScore = Math.max(0, 100 - Math.round(result.avgLatency / 4));
   const stabilityScore = Math.max(0, 100 - result.latencyStdDev * 2);
   const reliabilityScore = Math.round((result.successRate || 0) * 100);
-  return Math.round(latencyScore * 0.7 + stabilityScore * 0.2 + reliabilityScore * 0.1);
+  const pingBonus = result.ping?.ok ? 5 : 0;
+  const tcpBonus = result.tcp?.ok ? 5 : 0;
+  return Math.min(100, Math.round(latencyScore * 0.6 + stabilityScore * 0.2 + reliabilityScore * 0.2 + pingBonus + tcpBonus));
 }
 
 function getResultLatency(result) {
@@ -63,6 +149,8 @@ function getResultScore(result) {
       avgLatency: getResultLatency(result),
       latencyStdDev: result.latencyStdDev || 0,
       successRate: result.successRate || (result.available ? 1 : 0),
+      ping: result.ping,
+      tcp: result.tcp,
     });
 }
 
@@ -77,13 +165,6 @@ function sortNodeResults(results) {
   return [...results].sort((left, right) => getResultScore(right) - getResultScore(left) || getResultLatency(left) - getResultLatency(right));
 }
 
-function latencyLevel(latency) {
-  if (latency <= 50) return "优秀";
-  if (latency <= 100) return "良好";
-  if (latency <= 300) return "一般";
-  return "较慢";
-}
-
 function stabilityLabel(stdDev) {
   if (stdDev <= 5) return "稳定";
   if (stdDev <= 15) return "良好";
@@ -97,16 +178,21 @@ function padCell(value, width) {
   return `${text}${" ".repeat(Math.max(0, width - displayWidth))}`;
 }
 
+function formatProbe(entry) {
+  if (!entry?.ok) return "--";
+  return `${entry.latency}ms`;
+}
+
 function formatNodeLine(result, best) {
   const mark = result.available ? "✓" : "✗";
   const name = padCell(result.name || result.url || "FogAct", 12);
 
   if (!result.available) {
-    return `  ${mark} ${name} 不可达`;
+    return `  ${mark} ${name} ping:${formatProbe(result.ping)} tcp:${formatProbe(result.tcp)} http:${formatProbe(result.http)}  不可达`;
   }
 
   const bestMark = best && best === result ? " ★ 最优" : "";
-  return `  ${mark} ${name} ${result.avgLatency}ms (±${result.latencyStdDev}ms)  ${stabilityLabel(result.latencyStdDev)}  ${getResultScore(result)}分${bestMark}`;
+  return `  ${mark} ${name} ping:${formatProbe(result.ping)} tcp:${formatProbe(result.tcp)} http:${formatProbe(result.http)}  ${result.avgLatency}ms (±${result.latencyStdDev}ms)  ${stabilityLabel(result.latencyStdDev)}  ${getResultScore(result)}分${bestMark}`;
 }
 
 function formatNodeResults(results, options = {}) {
@@ -135,4 +221,6 @@ module.exports = {
   selectBestNode,
   formatNodeResults,
   sortNodeResults,
+  probeNode,
+  testTcp,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fogact",
-  "version": "1.2.6",
+  "version": "1.2.7",
   "description": "FogAct activation helper for Claude Code and Codex",
   "keywords": [
     "fogact",