fogact 1.2.5 → 1.2.7

package/lib/services/database.js

@@ -7,6 +7,7 @@ const DATA_DIR = path.join(__dirname, "..", "..", "data");
 const USERS_FILE = path.join(DATA_DIR, "users.json");
 const CODES_FILE = path.join(DATA_DIR, "codes.json");
 const USAGE_FILE = path.join(DATA_DIR, "usage.json");
+const CARD_MERGES_FILE = path.join(DATA_DIR, "card-merges.json");
 
 // 确保数据目录存在
 function ensureDataDir() {
@@ -136,6 +137,11 @@ const codeDb = {
       name: codeData.name || `Code-${Date.now()}`,
       service: codeData.service || "Claude Code",
       category: codeData.category || "标准运营",
+      subServiceType: codeData.subServiceType || codeData.category || "标准运营",
+      billingType: codeData.billingType || codeData.quota?.billingType || codeData.quota?.type || "quota",
+      cycleType: codeData.cycleType || codeData.quota?.cycleType || codeData.quota?.type || "fixed",
+      quotaUnit: codeData.quotaUnit || codeData.quota?.unit || "tokens",
+      resetTimezone: codeData.resetTimezone || codeData.quota?.resetTimezone || "Asia/Shanghai",
       status: codeData.status || "未使用",
       enabled: codeData.enabled !== undefined ? codeData.enabled : true,
       usedBy: codeData.usedBy || null,
@@ -148,9 +154,14 @@ const codeDb = {
         total: codeData.quota?.total || 100000,
         used: codeData.quota?.used || 0,
         dailyLimit: codeData.quota?.dailyLimit || 5000,
+        dailyQuota: codeData.quota?.dailyQuota || codeData.quota?.dailyLimit || 5000,
         dailyUsed: codeData.quota?.dailyUsed || 0,
         periodDays: codeData.quota?.periodDays || 30,
         periodLimit: codeData.quota?.periodLimit || 50000,
+        billingType: codeData.billingType || codeData.quota?.billingType || codeData.quota?.type || "quota",
+        cycleType: codeData.cycleType || codeData.quota?.cycleType || codeData.quota?.type || "fixed",
+        unit: codeData.quotaUnit || codeData.quota?.unit || "tokens",
+        resetTimezone: codeData.resetTimezone || codeData.quota?.resetTimezone || "Asia/Shanghai",
       },
       // 计费设置
       billing: {
@@ -303,6 +314,52 @@ const usageDb = {
   },
 };
 
+// 叠卡合并记录数据库操作
+const cardMergeDb = {
+  getAll() {
+    return readJsonFile(CARD_MERGES_FILE, []);
+  },
+
+  create(mergeData) {
+    const items = this.getAll();
+    const now = new Date().toISOString();
+    const newItem = {
+      id: mergeData.id || `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+      parentCodeId: mergeData.parentCodeId,
+      parentCode: mergeData.parentCode,
+      childCodeId: mergeData.childCodeId,
+      childCode: mergeData.childCode,
+      serviceType: mergeData.serviceType,
+      subServiceType: mergeData.subServiceType || "",
+      billingType: mergeData.billingType,
+      cycleType: mergeData.cycleType,
+      quotaUnit: mergeData.quotaUnit,
+      timezone: mergeData.timezone || "Asia/Shanghai",
+      mergeMode: mergeData.mergeMode,
+      parentDailyQuota: Number(mergeData.parentDailyQuota || 0),
+      childDailyQuota: Number(mergeData.childDailyQuota || 0),
+      childDays: Number(mergeData.childDays || 0),
+      childTotalValue: Number(mergeData.childTotalValue || 0),
+      addedDays: Number(mergeData.addedDays || 0),
+      addedQuota: Number(mergeData.addedQuota || 0),
+      oldExpiresAt: mergeData.oldExpiresAt || null,
+      newExpiresAt: mergeData.newExpiresAt || null,
+      createdAt: mergeData.createdAt || now,
+    };
+    items.push(newItem);
+    writeJsonFile(CARD_MERGES_FILE, items);
+    return newItem;
+  },
+
+  getByParent(parentCodeId) {
+    return this.getAll().filter((item) => item.parentCodeId === parentCodeId);
+  },
+
+  getByChild(childCodeId) {
+    return this.getAll().filter((item) => item.childCodeId === childCodeId);
+  },
+};
+
 // 初始化示例数据
 function initializeSampleData() {
   ensureDataDir();
@@ -504,5 +561,6 @@ module.exports = {
   userDb,
   codeDb,
   usageDb,
+  cardMergeDb,
   initializeSampleData,
 };

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,22 +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);
-  const service = padCell(result.serviceLabel || result.region || "Global", 9);
 
   if (!result.available) {
-    return `  ${mark} ${name} ${service} --        --      不可达  --`;
+    return `  ${mark} ${name} ping:${formatProbe(result.ping)} tcp:${formatProbe(result.tcp)} http:${formatProbe(result.http)}  不可达`;
   }
 
-  const latency = padCell(`${result.avgLatency}ms`, 8);
-  const jitter = padCell(`±${result.latencyStdDev}ms`, 7);
-  const stability = padCell(stabilityLabel(result.latencyStdDev), 6);
-  const score = padCell(`${getResultScore(result)}分`, 5);
-  const level = padCell(latencyLevel(result.avgLatency), 4);
   const bestMark = best && best === result ? " ★ 最优" : "";
-  return `  ${mark} ${name} ${service} ${latency} ${jitter} ${stability} ${score} ${level}${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 = {}) {
@@ -123,21 +203,16 @@ function formatNodeResults(results, options = {}) {
   const title = options.title || "节点测试结果";
 
   lines.push(`  ${title}`);
-  lines.push("  ────────────────────────────────────────────────────────────");
-  lines.push("  状态 节点         服务      延迟     波动    稳定性  评分  等级");
-  lines.push("  ────────────────────────────────────────────────────────────");
+  lines.push("  ───────────────────────────────────────────────────");
+  lines.push("");
 
   for (const result of sorted) {
     lines.push(formatNodeLine(result, best));
   }
 
-  lines.push("  ────────────────────────────────────────────────────────────");
+  lines.push("");
+  lines.push("  ───────────────────────────────────────────────────");
   lines.push(`  测试完成，共 ${results.length} 个节点，${availableCount} 个可用`);
-  if (best) {
-    lines.push(`  推荐节点: ${best.name || best.url} · ${best.avgLatency}ms · ${getResultScore(best)}分`);
-  } else {
-    lines.push("  暂无可用节点，请稍后重试或联系管理员");
-  }
   return lines.join("\n");
 }
 
@@ -146,4 +221,6 @@ module.exports = {
   selectBestNode,
   formatNodeResults,
   sortNodeResults,
+  probeNode,
+  testTcp,
 };

package/package.json

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