fogact 1.2.6 → 1.2.8

package/lib/index.js

@@ -17,6 +17,12 @@ const MENU_CHOICES = [
   { title: "4. 退出", value: "exit" },
 ];
 
+const MENU_COLORS = {
+  test: "\x1b[34m",
+  exit: "\x1b[90m",
+};
+const ANSI_RESET = "\x1b[0m";
+
 const UPDATE_TIMEOUT_MS = 2500;
 
 function parseVersion(version) {
@@ -158,7 +164,9 @@ function renderMenu(cursor = 0) {
   ];
 
   MENU_CHOICES.forEach((choice, index) => {
-    lines.push(`${index === cursor ? "❯" : " "} ${choice.title}`);
+    const color = MENU_COLORS[choice.value] || "";
+    const title = color ? `${color}${choice.title}${ANSI_RESET}` : choice.title;
+    lines.push(`${index === cursor ? "❯" : " "} ${title}`);
   });
 
   lines.push("");

package/lib/services/node-service.js

@@ -1,38 +1,145 @@
 "use strict";
 
+const { execFile } = require("child_process");
+const net = require("net");
 const { testNode } = require("./fogact-api");
 
+const PROBE_TIMEOUT_MS = 5000;
+const ANSI = {
+  reset: "\x1b[0m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+};
+
+function shouldColorize(options = {}) {
+  if (options.color === true || process.env.FORCE_COLOR) return true;
+  if (options.color === false || process.env.NO_COLOR) return false;
+  return Boolean(process.stdout.isTTY);
+}
+
+function colorize(value, color, enabled) {
+  if (!enabled || !color) return String(value);
+  return `${ANSI[color]}${value}${ANSI.reset}`;
+}
+
+function latencyColor(latency) {
+  if (latency < 60) return "green";
+  if (latency < 150) return "yellow";
+  return "red";
+}
+
+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 +153,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 +172,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 +188,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 +201,26 @@ function padCell(value, width) {
   return `${text}${" ".repeat(Math.max(0, width - displayWidth))}`;
 }
 
-function formatNodeLine(result, best) {
-  const mark = result.available ? "✓" : "✗";
+function formatProbe(entry, colorEnabled) {
+  if (!entry?.ok) return colorize("--", "red", colorEnabled);
+  const value = `${entry.latency}ms`;
+  return colorize(value, latencyColor(entry.latency), colorEnabled);
+}
+
+function formatNodeLine(result, best, colorEnabled) {
+  const mark = colorize(result.available ? "✓" : "✗", result.available ? "green" : "red", colorEnabled);
   const name = padCell(result.name || result.url || "FogAct", 12);
+  const ping = `ping:${formatProbe(result.ping, colorEnabled)}`;
+  const tcp = `tcp:${formatProbe(result.tcp, colorEnabled)}`;
+  const http = `http:${formatProbe(result.http, colorEnabled)}`;
 
   if (!result.available) {
-    return `  ${mark} ${name} 不可达`;
+    return `  ${mark} ${name} ${ping} ${tcp} ${http}  ${colorize("不可达", "red", colorEnabled)}`;
   }
 
-  const bestMark = best && best === result ? " ★ 最优" : "";
-  return `  ${mark} ${name} ${result.avgLatency}ms (±${result.latencyStdDev}ms)  ${stabilityLabel(result.latencyStdDev)}  ${getResultScore(result)}分${bestMark}`;
+  const latency = colorize(`${result.avgLatency}ms`, latencyColor(result.avgLatency), colorEnabled);
+  const bestMark = best && best === result ? ` ${colorize("★ 最优", "yellow", colorEnabled)}` : "";
+  return `  ${mark} ${name} ${ping} ${tcp} ${http}  ${latency} (±${result.latencyStdDev}ms)  ${stabilityLabel(result.latencyStdDev)}  ${getResultScore(result)}分${bestMark}`;
 }
 
 function formatNodeResults(results, options = {}) {
@@ -115,13 +229,14 @@ function formatNodeResults(results, options = {}) {
   const availableCount = results.filter((result) => result.available).length;
   const lines = [];
   const title = options.title || "节点测试结果";
+  const colorEnabled = shouldColorize(options);
 
   lines.push(`  ${title}`);
   lines.push("  ───────────────────────────────────────────────────");
   lines.push("");
 
   for (const result of sorted) {
-    lines.push(formatNodeLine(result, best));
+    lines.push(formatNodeLine(result, best, colorEnabled));
   }
 
   lines.push("");
@@ -135,4 +250,7 @@ module.exports = {
   selectBestNode,
   formatNodeResults,
   sortNodeResults,
+  probeNode,
+  testTcp,
+  shouldColorize,
 };

package/package.json

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