fogact 1.1.10 → 1.2.2

package/lib/services/backup-service.js

@@ -92,30 +92,74 @@ function createActivationBackup(service, filePaths, metadata = {}) {
   return backupRoot;
 }
 
+function restoreManifestBackup(backupRoot) {
+  const manifestPath = path.join(backupRoot, "manifest.json");
+  if (!fs.existsSync(manifestPath)) {
+    throw new Error("Backup manifest not found");
+  }
+
+  const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+  const restored = [];
+  for (const file of manifest.files || []) {
+    const backupPath = path.join(backupRoot, file.backupName);
+    if (!fs.existsSync(backupPath)) continue;
+    fs.mkdirSync(path.dirname(file.originalPath), { recursive: true });
+    if (file.isDirectory) {
+      if (fs.existsSync(file.originalPath)) {
+        fs.rmSync(file.originalPath, { recursive: true, force: true });
+      }
+      copyRecursive(backupPath, file.originalPath);
+    } else {
+      fs.copyFileSync(backupPath, file.originalPath);
+    }
+    restored.push(file.originalPath);
+  }
+
+  return restored;
+}
+
 function listBackups(service = null) {
   ensureBackupDir();
 
-  const files = fs.readdirSync(BACKUP_DIR);
+  const entries = fs.readdirSync(BACKUP_DIR, { withFileTypes: true });
   const backups = [];
 
-  for (const file of files) {
-    if (!file.endsWith(".json")) continue;
-
-    const filePath = path.join(BACKUP_DIR, file);
+  for (const entry of entries) {
+    const entryPath = path.join(BACKUP_DIR, entry.name);
+
+    if (entry.isDirectory()) {
+      const manifestPath = path.join(entryPath, "manifest.json");
+      if (!fs.existsSync(manifestPath)) continue;
+      try {
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+        if (!service || manifest.service === service) {
+          backups.push({
+            file: entry.name,
+            path: entryPath,
+            kind: "manifest",
+            originalPath: (manifest.files || []).map((file) => file.originalPath).join(", "),
+            ...manifest,
+          });
+        }
+      } catch (err) {
+        // Skip invalid backup folders.
+      }
+      continue;
+    }
 
+    if (!entry.name.endsWith(".json")) continue;
     try {
-      const content = fs.readFileSync(filePath, "utf8");
-      const backup = JSON.parse(content);
-
+      const backup = JSON.parse(fs.readFileSync(entryPath, "utf8"));
       if (!service || backup.service === service) {
         backups.push({
-          file,
-          path: filePath,
+          file: entry.name,
+          path: entryPath,
+          kind: "single",
           ...backup,
         });
       }
     } catch (err) {
-      // Skip invalid backup files
+      // Skip invalid backup files.
     }
   }
 
@@ -129,6 +173,10 @@ function restoreBackup(backupPath) {
     throw new Error("Backup file not found");
   }
 
+  if (fs.statSync(backupPath).isDirectory()) {
+    return restoreManifestBackup(backupPath);
+  }
+
   const content = fs.readFileSync(backupPath, "utf8");
   const backup = JSON.parse(content);
 
@@ -139,14 +187,18 @@ function restoreBackup(backupPath) {
 
   fs.writeFileSync(backup.originalPath, backup.content);
 
-  return backup.originalPath;
+  return [backup.originalPath];
 }
 
 function clearBackups(service = null) {
   const backups = listBackups(service);
 
   for (const backup of backups) {
-    fs.unlinkSync(backup.path);
+    if (fs.existsSync(backup.path) && fs.statSync(backup.path).isDirectory()) {
+      fs.rmSync(backup.path, { recursive: true, force: true });
+    } else if (fs.existsSync(backup.path)) {
+      fs.unlinkSync(backup.path);
+    }
   }
 
   return backups.length;

package/lib/services/fogact-api.js

@@ -6,7 +6,7 @@ const http = require("http");
 
 // 支持环境变量覆盖 API 地址；默认连接公网 FogAct 面板。
 const DEFAULT_API_BASE = "https://cliproxy.fogidc.com";
-const API_BASE = process.env.FOGACT_API_BASE || process.env.CLIPROXY_API_BASE || DEFAULT_API_BASE;
+const API_BASE = process.env.FOGACT_API_BASE || DEFAULT_API_BASE;
 
 function makeRequest(path, options = {}) {
   return new Promise((resolve, reject) => {
@@ -57,7 +57,6 @@ function makeRequest(path, options = {}) {
 
 async function verifyActivationCode(code, service) {
   try {
-    // 调用本地激活 API
     const response = await makeRequest("/api/activate", {
       method: "POST",
       body: {
@@ -67,17 +66,18 @@ async function verifyActivationCode(code, service) {
       },
     });
 
-    if (response.status === 200 && response.data.success) {
+    const normalized = normalizeActivationResponse(response);
+
+    if (response.status >= 200 && response.status < 300 && normalized.valid) {
       return {
         valid: true,
-        service: response.data.data.service,
-        expiresAt: response.data.data.expiresAt,
-        quota: response.data.data.quota,
-        nodes: response.data.data.nodes || [],
+        ...normalized.data,
+        data: normalized.data,
+        nodes: normalized.data.nodes || [],
       };
     }
 
-    return { valid: false, error: response.data.message || "Invalid code" };
+    return { valid: false, error: normalized.message || "Invalid code" };
   } catch (err) {
     return { valid: false, error: err.message };
   }
@@ -116,45 +116,59 @@ async function inspectActivationCode(code) {
 }
 
 async function redeemActivationCode(code, service) {
-  return verifyActivationCode(code, service);
+  const result = await inspectActivationCode(code);
+  return result.valid
+    ? { valid: true, service: result.service, expiresAt: result.expiresAt, quota: result.quota, nodes: result.nodes || [] }
+    : result;
 }
 
 async function getNodes(service) {
   try {
-    const response = await makeRequest(`/api/nodes?service=${service}`);
+    const response = await makeRequest(`/api/nodes?service=${encodeURIComponent(service || "")}`);
 
     if (response.status === 200 && Array.isArray(response.data.nodes)) {
       return response.data.nodes;
     }
 
-    // 返回默认节点
-    return [
-      { name: "FogAct Local Node", url: "http://localhost:34020", region: "Global" }
-    ];
+    return [{ name: "FogAct", url: API_BASE, region: "Global" }];
   } catch (err) {
-    console.error("Failed to fetch nodes:", err.message);
-    // 返回默认节点
-    return [
-      { name: "FogAct Local Node", url: "http://localhost:34020", region: "Global" }
-    ];
+    return [{ name: "FogAct", url: API_BASE, region: "Global" }];
   }
 }
 
+function requestUrl(urlString, options = {}) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(urlString);
+    const isHttps = url.protocol === "https:";
+    const client = isHttps ? https : http;
+    const req = client.request({
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method: options.method || "GET",
+      headers: { "User-Agent": `fogact/${packageJson.version}`, ...options.headers },
+      timeout: options.timeout || 8000,
+    }, (res) => {
+      res.resume();
+      res.on("end", () => resolve({ status: res.statusCode }));
+    });
+    req.on("timeout", () => req.destroy(new Error("Request timed out")));
+    req.on("error", reject);
+    req.end();
+  });
+}
+
 async function testNode(nodeUrl) {
   const start = Date.now();
 
   try {
-    const url = new URL("/health", nodeUrl);
-    const response = await makeRequest(url.pathname, {
-      method: "GET",
-      headers: { Host: url.hostname },
-    });
-
+    const healthUrl = new URL("/health", nodeUrl).toString();
+    const response = await requestUrl(healthUrl);
     const latency = Date.now() - start;
 
     return {
       url: nodeUrl,
-      available: response.status === 200,
+      available: response.status >= 200 && response.status < 500,
       latency,
     };
   } catch (err) {

package/lib/services/node-service.js

@@ -2,43 +2,114 @@
 
 const { testNode } = require("./fogact-api");
 
-async function testNodes(nodes) {
+async function testNodes(nodes, onProgress = null) {
   const results = [];
 
   for (const node of nodes) {
-    const result = await testNode(node.url);
+    if (onProgress) onProgress(node, results.length, nodes.length);
+    const probes = [];
+    for (let index = 0; index < 3; index += 1) {
+      const result = await testNode(node.url);
+      probes.push(result);
+    }
+
+    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;
+
     results.push({
       ...node,
-      ...result,
+      available,
+      reachable: available,
+      latency: avgLatency,
+      avgLatency,
+      latencyStdDev,
+      successRate,
+      score: scoreNode({ available, avgLatency, latencyStdDev, successRate }),
+      error: available ? undefined : probes.find((probe) => probe.error)?.error || "节点不可达",
     });
   }
 
   return results;
 }
 
-function selectBestNode(testResults) {
-  const available = testResults.filter((r) => r.available);
+function scoreNode(result) {
+  if (!result.available) return 0;
+  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);
+}
 
-  if (available.length === 0) {
-    return null;
-  }
+function getResultLatency(result) {
+  return typeof result.avgLatency === "number" && result.avgLatency >= 0
+    ? result.avgLatency
+    : result.latency;
+}
 
-  available.sort((a, b) => a.latency - b.latency);
+function getResultScore(result) {
+  return typeof result.score === "number"
+    ? result.score
+    : scoreNode({
+      available: result.available,
+      avgLatency: getResultLatency(result),
+      latencyStdDev: result.latencyStdDev || 0,
+      successRate: result.successRate || (result.available ? 1 : 0),
+    });
+}
 
+function selectBestNode(testResults) {
+  const available = testResults.filter((result) => result.available);
+  if (available.length === 0) return null;
+  available.sort((left, right) => getResultScore(right) - getResultScore(left) || getResultLatency(left) - getResultLatency(right));
   return available[0];
 }
 
+function latencyLabel(latency) {
+  if (latency <= 50) return `${latency}ms`;
+  if (latency <= 100) return `${latency}ms`;
+  if (latency <= 300) return `${latency}ms`;
+  return `${latency}ms`;
+}
+
+function stabilityLabel(stdDev) {
+  if (stdDev <= 5) return "稳定";
+  if (stdDev <= 15) return "良好";
+  if (stdDev <= 30) return "一般";
+  return "波动";
+}
+
 function formatNodeResults(results) {
+  const sorted = [...results].sort((left, right) => right.score - left.score || left.avgLatency - right.avgLatency);
+  const best = sorted.find((result) => result.available);
   const lines = [];
 
-  for (const result of results) {
-    const status = result.available ? "✓" : "✗";
-    const latency = result.available ? `${result.latency}ms` : "N/A";
-    const name = result.name || result.url;
+  lines.push("  节点测试结果");
+  lines.push("  ───────────────────────────────────────────────────");
+  lines.push("");
 
-    lines.push(`  ${status} ${name} - ${latency}`);
+  for (const result of sorted) {
+    const mark = result.available ? "✓" : "✗";
+    const name = String(result.name || result.url).padEnd(10);
+    if (!result.available) {
+      lines.push(`  ${mark} ${name} 不可达`);
+      continue;
+    }
+    const bestMark = best && best.url === result.url ? " ★ 最优" : "";
+    lines.push(`  ${mark} ${name} ${latencyLabel(result.avgLatency)} (±${result.latencyStdDev}ms)  ${stabilityLabel(result.latencyStdDev)}  ${result.score}分${bestMark}`);
   }
 
+  const availableCount = results.filter((result) => result.available).length;
+  lines.push("");
+  lines.push("  ───────────────────────────────────────────────────");
+  lines.push(`  测试完成，共 ${results.length} 个节点，${availableCount} 个可用`);
   return lines.join("\n");
 }
 

package/package.json

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