fogact 1.1.3

package/lib/services/backup-service.js

@@ -0,0 +1,162 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const BACKUP_DIR = process.env.CLIPROXY_BACKUP_DIR ||
+  process.env.FOGIDC_BACKUP_DIR ||
+  path.join(os.homedir(), ".fogact", "backups");
+
+function ensureBackupDir() {
+  if (!fs.existsSync(BACKUP_DIR)) {
+    fs.mkdirSync(BACKUP_DIR, { recursive: true });
+  }
+}
+
+function createBackup(service, configPath) {
+  ensureBackupDir();
+
+  if (!fs.existsSync(configPath)) {
+    return null;
+  }
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupName = `${service}-${timestamp}.json`;
+  const backupPath = path.join(BACKUP_DIR, backupName);
+
+  const content = fs.readFileSync(configPath, "utf8");
+
+  const backup = {
+    service,
+    originalPath: configPath,
+    timestamp: new Date().toISOString(),
+    content,
+  };
+
+  fs.writeFileSync(backupPath, JSON.stringify(backup, null, 2));
+
+  return backupPath;
+}
+
+function copyRecursive(sourcePath, targetPath) {
+  const stat = fs.statSync(sourcePath);
+  if (stat.isDirectory()) {
+    fs.mkdirSync(targetPath, { recursive: true });
+    for (const entry of fs.readdirSync(sourcePath, { withFileTypes: true })) {
+      copyRecursive(path.join(sourcePath, entry.name), path.join(targetPath, entry.name));
+    }
+    return;
+  }
+
+  fs.mkdirSync(path.dirname(targetPath), { recursive: true });
+  fs.copyFileSync(sourcePath, targetPath);
+}
+
+function createActivationBackup(service, filePaths, metadata = {}) {
+  ensureBackupDir();
+
+  const existingPaths = [...new Set(filePaths || [])]
+    .filter(Boolean)
+    .filter((filePath) => fs.existsSync(filePath));
+
+  if (existingPaths.length === 0) {
+    return null;
+  }
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const backupRoot = path.join(BACKUP_DIR, `${service}-${timestamp}`);
+  fs.mkdirSync(backupRoot, { recursive: true });
+
+  const files = existingPaths.map((filePath, index) => {
+    const stat = fs.statSync(filePath);
+    const backupName = `${String(index + 1).padStart(2, "0")}-${path.basename(filePath)}`;
+    const backupPath = path.join(backupRoot, backupName);
+    copyRecursive(filePath, backupPath);
+    return {
+      originalPath: filePath,
+      backupName,
+      isDirectory: stat.isDirectory(),
+      size: stat.size,
+    };
+  });
+
+  const manifest = {
+    version: 1,
+    service,
+    timestamp: new Date().toISOString(),
+    metadata,
+    files,
+  };
+  fs.writeFileSync(path.join(backupRoot, "manifest.json"), JSON.stringify(manifest, null, 2));
+
+  return backupRoot;
+}
+
+function listBackups(service = null) {
+  ensureBackupDir();
+
+  const files = fs.readdirSync(BACKUP_DIR);
+  const backups = [];
+
+  for (const file of files) {
+    if (!file.endsWith(".json")) continue;
+
+    const filePath = path.join(BACKUP_DIR, file);
+
+    try {
+      const content = fs.readFileSync(filePath, "utf8");
+      const backup = JSON.parse(content);
+
+      if (!service || backup.service === service) {
+        backups.push({
+          file,
+          path: filePath,
+          ...backup,
+        });
+      }
+    } catch (err) {
+      // Skip invalid backup files
+    }
+  }
+
+  backups.sort((a, b) => new Date(b.timestamp) - new Date(a.timestamp));
+
+  return backups;
+}
+
+function restoreBackup(backupPath) {
+  if (!fs.existsSync(backupPath)) {
+    throw new Error("Backup file not found");
+  }
+
+  const content = fs.readFileSync(backupPath, "utf8");
+  const backup = JSON.parse(content);
+
+  const targetDir = path.dirname(backup.originalPath);
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  fs.writeFileSync(backup.originalPath, backup.content);
+
+  return backup.originalPath;
+}
+
+function clearBackups(service = null) {
+  const backups = listBackups(service);
+
+  for (const backup of backups) {
+    fs.unlinkSync(backup.path);
+  }
+
+  return backups.length;
+}
+
+module.exports = {
+  createActivationBackup,
+  createBackup,
+  listBackups,
+  restoreBackup,
+  clearBackups,
+};

package/lib/services/cliproxy-api.js

@@ -0,0 +1,174 @@
+"use strict";
+
+const https = require("https");
+const http = require("http");
+
+// 支持环境变量配置 API 地址
+const API_BASE = process.env.CLIPROXY_API_BASE || "http://localhost:34020";
+
+function makeRequest(path, options = {}) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(path, API_BASE);
+    const isHttps = url.protocol === "https:";
+    const client = isHttps ? https : http;
+
+    const reqOptions = {
+      hostname: url.hostname,
+      port: url.port || (isHttps ? 443 : 80),
+      path: url.pathname + url.search,
+      method: options.method || "GET",
+      headers: {
+        "Content-Type": "application/json",
+        "User-Agent": "fogact/1.1.3",
+        ...options.headers,
+      },
+    };
+
+    const req = client.request(reqOptions, (res) => {
+      let data = "";
+
+      res.on("data", (chunk) => {
+        data += chunk;
+      });
+
+      res.on("end", () => {
+        try {
+          const parsed = JSON.parse(data);
+          resolve({ status: res.statusCode, data: parsed });
+        } catch (err) {
+          resolve({ status: res.statusCode, data: data });
+        }
+      });
+    });
+
+    req.on("error", (err) => {
+      reject(err);
+    });
+
+    if (options.body) {
+      req.write(JSON.stringify(options.body));
+    }
+
+    req.end();
+  });
+}
+
+async function verifyActivationCode(code, service) {
+  try {
+    // 调用本地激活 API
+    const response = await makeRequest("/api/activate", {
+      method: "POST",
+      body: {
+        code,
+        service,
+        username: process.env.USER || process.env.USERNAME || "cli-user"
+      },
+    });
+
+    if (response.status === 200 && response.data.success) {
+      return {
+        valid: true,
+        service: response.data.data.service,
+        expiresAt: response.data.data.expiresAt,
+        quota: response.data.data.quota,
+        nodes: response.data.data.nodes || [],
+      };
+    }
+
+    return { valid: false, error: response.data.message || "Invalid code" };
+  } catch (err) {
+    return { valid: false, error: err.message };
+  }
+}
+
+function normalizeActivationResponse(response) {
+  const payload = response && response.data && typeof response.data === "object" ? response.data : {};
+  const data = payload.data && typeof payload.data === "object" ? payload.data : payload;
+  return {
+    valid: Boolean(payload.success || payload.valid),
+    message: payload.message,
+    data,
+  };
+}
+
+async function inspectActivationCode(code) {
+  try {
+    const response = await makeRequest("/api/verify", {
+      method: "POST",
+      body: { code },
+    });
+    const normalized = normalizeActivationResponse(response);
+
+    if (response.status >= 200 && response.status < 300 && normalized.valid) {
+      return {
+        valid: true,
+        ...normalized.data,
+        data: normalized.data,
+      };
+    }
+
+    return { valid: false, error: normalized.message || "Invalid activation code" };
+  } catch (err) {
+    return { valid: false, error: err.message };
+  }
+}
+
+async function redeemActivationCode(code, service) {
+  return verifyActivationCode(code, service);
+}
+
+async function getNodes(service) {
+  try {
+    const response = await makeRequest(`/api/nodes?service=${service}`);
+
+    if (response.status === 200 && Array.isArray(response.data.nodes)) {
+      return response.data.nodes;
+    }
+
+    // 返回默认节点
+    return [
+      { name: "Default Node", url: "https://yunyi.cfd", region: "Global" }
+    ];
+  } catch (err) {
+    console.error("Failed to fetch nodes:", err.message);
+    // 返回默认节点
+    return [
+      { name: "Default Node", url: "https://yunyi.cfd", region: "Global" }
+    ];
+  }
+}
+
+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 latency = Date.now() - start;
+
+    return {
+      url: nodeUrl,
+      available: response.status === 200,
+      latency,
+    };
+  } catch (err) {
+    return {
+      url: nodeUrl,
+      available: false,
+      latency: -1,
+      error: err.message,
+    };
+  }
+}
+
+module.exports = {
+  inspectActivationCode,
+  redeemActivationCode,
+  verifyActivationCode,
+  getNodes,
+  testNode,
+};