fogact 1.1.9 → 1.2.0

package/lib/services/activation-orchestrator.js

@@ -4,7 +4,7 @@ const prompts = require("prompts");
 const { detectPlatforms, getPlatforms } = require("../platforms");
 const { loadUpstreamConfig } = require("../config/upstream");
 const { createActivationBackup } = require("./backup-service");
-const { inspectActivationCode, redeemActivationCode } = require("./fogact-api");
+const { getNodes, inspectActivationCode, redeemActivationCode, testNode } = require("./fogact-api");
 const { maskKey, verifyNewApiKey } = require("./newapi");
 
 const SUPPORTED_SERVICES = ["codex", "claude"];
@@ -219,21 +219,17 @@ async function promptService(defaultService, entitlement = normalizeEntitlement(
     if (!isServiceAllowed(entitlement, normalized)) {
       throw new Error(`当前激活码不支持 ${getServiceLabel(normalized)}`);
     }
-    console.log(`能力范围: ${getServiceLabel(normalized)}`);
     return normalized;
   }
 
   const allowedServices = entitlement.services.length ? entitlement.services : [];
   if (allowedServices.length === 1) {
-    console.log(`能力范围: ${getServiceLabel(allowedServices[0])}`);
     return allowedServices[0];
   }
 
   if (!allowPrompt) {
     if (allowedServices.length > 1) {
       const service = allowedServices[0];
-      const labels = allowedServices.map(getServiceLabel).join(" / ");
-      console.log(`能力范围: ${labels}，本次自动激活 ${getServiceLabel(service)}`);
       return service;
     }
     console.log("✗ 激活码没有返回 Codex / Claude 能力，无法自动识别。请联系管理员重新生成激活码。");
@@ -289,10 +285,10 @@ async function promptActivationCode(defaultCode) {
   }
 
   const response = await prompts({
-    type: "text",
+    type: "password",
     name: "code",
-    message: "请输入激活码 / 兑换码",
-    validate: (value) => value && value.trim() ? true : "激活码不能为空",
+    message: "请输入 API Key / 激活码:",
+    validate: (value) => value && value.trim() ? true : "API Key / 激活码不能为空",
   }, { onCancel: () => false });
 
   return response.code ? response.code.trim() : null;
@@ -321,7 +317,7 @@ async function promptCredentialType(options, upstream) {
   return response.credentialType || null;
 }
 
-async function confirmActivation(yes) {
+async function confirmActivation(yes, service) {
   if (yes) {
     return true;
   }
@@ -329,7 +325,7 @@ async function confirmActivation(yes) {
   const response = await prompts({
     type: "confirm",
     name: "confirmed",
-    message: "确认开始激活？",
+    message: `确认激活 ${getServiceLabel(service)} 配置?`,
     initial: true,
   }, { onCancel: () => false });
 
@@ -353,6 +349,10 @@ function getBackupPaths(targets) {
   return targets.flatMap(({ detection }) => detection.paths || []);
 }
 
+function divider(width = 37) {
+  return `  ${"─".repeat(width)}`;
+}
+
 function printBanner() {
   console.log("");
   console.log("╭────────────────────────────────────────╮");
@@ -362,65 +362,112 @@ function printBanner() {
   console.log("");
 }
 
-function printDetection(service, detectedPlatforms, blockedPlatforms = []) {
-  console.log("检测结果:");
-  console.log(`  当前能力: ${getServiceLabel(service)}`);
-  for (const { platform, detection } of detectedPlatforms) {
-    const mark = canSelectPlatform(platform, detection) ? "✓" : "-";
-    console.log(`  ${mark} ${platform.name}：${getStatusLabel(platform, detection)}`);
-  }
-  for (const { platform } of blockedPlatforms) {
-    console.log(`  - ${platform.name}：当前激活码能力不包含`);
-  }
+function printCredentialProfile(service, upstream, apiKey, entitlement) {
   console.log("");
-}
-
-function printPlan(service, upstream, apiKey, targets, skipped = []) {
-  console.log("激活计划:");
-  console.log(`  能力: ${getServiceLabel(service)}`);
-  console.log(`  上游: ${upstream.baseUrl}`);
-  console.log(`  密钥: ${maskKey(apiKey)}`);
-  console.log("  平台:");
-  for (const { platform, detection } of targets) {
-    console.log(`    ✓ ${platform.name} (${getStatusLabel(platform, detection)})`);
-  }
-  for (const { platform } of skipped) {
-    console.log(`    - ${platform.name} (未选择)`);
+  console.log("  账号信息");
+  console.log(divider());
+  console.log(`  服务类型:   ${getServiceLabel(service)}`);
+  console.log(`  接入地址:   ${upstream.baseUrl}`);
+  console.log(`  API Key:    ${maskKey(apiKey)}`);
+  if (entitlement.planName) {
+    console.log(`  套餐名称:   ${entitlement.planName}`);
+  }
+  if (entitlement.raw && entitlement.raw.expiresAt) {
+    console.log(`  到期时间:   ${entitlement.raw.expiresAt}`);
+  }
+  const quota = entitlement.raw && entitlement.raw.quota;
+  if (quota && typeof quota === "object") {
+    const total = quota.total ?? quota.total_quota ?? quota.dailyLimit ?? quota.daily;
+    const used = quota.used ?? quota.used_quota ?? quota.dailyUsed;
+    if (total !== undefined) console.log(`  总配额:     ${total}`);
+    if (used !== undefined) console.log(`  已使用:     ${used}`);
   }
+  console.log("");
 }
 
-function printResultSummary(service, upstream, backupPath, results, redeemResult) {
+function printResultSummary(service, backupPath, results, redeemResult) {
   const succeeded = results.filter(({ result }) => result.success);
   const skipped = results.filter(({ result }) => !result.success && result.skipped);
   const failed = results.filter(({ result }) => !result.success && !result.skipped);
+  const byId = new Map(results.map((entry) => [entry.platform.id, entry]));
 
   console.log("");
-  console.log("激活结果:");
-  for (const { platform, result } of results) {
-    if (result.success) {
-      console.log(`  ✓ ${platform.name}`);
-      for (const file of result.files || []) {
-        console.log(`    ${file}`);
+  if (backupPath) {
+    console.log("  ✓ 备份已创建");
+  }
+
+  const printConfigured = (entry, label) => {
+    if (!entry) return false;
+    if (entry.result.success) {
+      console.log(`  ✓ ${label} 已激活`);
+      const files = entry.result.files || [];
+      if (files.length) console.log(`    配置: ${files.join(", ")}`);
+      return true;
+    }
+    if (!entry.result.skipped) {
+      console.log(`  ✗ ${label} 激活失败: ${entry.result.error || entry.result.message || "未知错误"}`);
+      return true;
+    }
+    return false;
+  };
+
+  if (service === "codex") {
+    printConfigured(byId.get("codex-cli"), "Codex CLI");
+  } else {
+    printConfigured(byId.get("claude-code"), "Claude Code");
+  }
+
+  const opencode = byId.get("opencode");
+  if (!printConfigured(opencode, "OpenCode")) {
+    console.log("");
+    console.log("  ℹ 已跳过 OpenCode 配置（未检测到安装）");
+    console.log("    如需使用，请先运行一次 opencode 初始化后重新激活");
+  }
+
+  const openclaw = byId.get("openclaw");
+  if (!printConfigured(openclaw, "OpenClaw")) {
+    console.log("");
+    console.log("  ℹ 已跳过 OpenClaw 配置（未检测到安装）");
+    console.log("    如需使用，请先运行一次 openclaw 初始化后重新激活");
+  }
+
+  const extensionResults = [byId.get("vscode-codex-plugin"), byId.get("cursor-codex-plugin")]
+    .filter(Boolean)
+    .filter((entry) => entry.result.success || !entry.result.skipped);
+  if (extensionResults.length) {
+    for (const entry of extensionResults) {
+      if (entry.result.success) {
+        console.log("");
+        console.log(`  ✓ ${entry.platform.name} 已激活`);
+        for (const file of entry.result.files || []) console.log(`    目录: ${file}`);
+      } else {
+        console.log("");
+        console.log(`  ⚠ ${entry.platform.name}: ${entry.result.error || entry.result.message || "无法激活"}`);
       }
-    } else if (result.skipped) {
-      console.log(`  - ${platform.name}: ${result.message || "已跳过"}`);
-    } else {
-      console.log(`  ✗ ${platform.name}: ${result.error || result.message || "失败"}`);
     }
+  } else if (service === "codex") {
+    console.log("");
+    console.log("  ℹ 已跳过编辑器插件配置（未检测到 Codex 插件）");
   }
 
   console.log("");
-  console.log("汇总:");
-  console.log(`  能力: ${getServiceLabel(service)}`);
-  console.log(`  上游: ${upstream.baseUrl}`);
-  console.log(`  成功: ${succeeded.length}`);
-  console.log(`  跳过: ${skipped.length}`);
-  console.log(`  失败: ${failed.length}`);
-  console.log(`  备份: ${backupPath || "无旧配置需要备份"}`);
+  if (failed.length) {
+    console.log(`  激活完成：${succeeded.length} 成功，${failed.length} 失败，${skipped.length} 跳过`);
+  }
   if (redeemResult) {
-    console.log(`  兑换: ${redeemResult.valid ? "已完成" : `未完成（${redeemResult.error || "接口不可用"}）`}`);
+    console.log(`  兑换记录: ${redeemResult.valid ? "已完成" : `未完成（${redeemResult.error || "接口不可用"}）`}`);
+  }
+  if (service === "claude") {
+    const tools = ["Claude Code"];
+    if (byId.get("opencode")?.result.success) tools.push("OpenCode");
+    if (byId.get("openclaw")?.result.success) tools.push("OpenClaw");
+    console.log(`  请重启相关工具（${tools.join("/")}）以应用新配置`);
+  } else {
+    const tools = ["Codex", "VSCode", "Cursor"];
+    if (byId.get("opencode")?.result.success) tools.push("OpenCode");
+    if (byId.get("openclaw")?.result.success) tools.push("OpenClaw");
+    console.log(`  请重启相关工具（${tools.join("/")}）以应用新配置`);
   }
-  console.log("  提示: 重启相关工具后生效");
   console.log("");
 }
 
@@ -428,31 +475,29 @@ async function selectPlatforms(detectedPlatforms, options = {}) {
   if (options.platforms) {
     return getActivationTargets(detectedPlatforms, false, options.platforms);
   }
-  if (options.yes || options.auto) {
-    return getActivationTargets(detectedPlatforms, Boolean(options.all));
-  }
+  return getActivationTargets(detectedPlatforms, Boolean(options.all));
+}
 
-  const choices = detectedPlatforms.map(({ platform, detection }) => {
-    const selectable = canSelectPlatform(platform, detection);
-    return {
-      title: `${platform.name}（${getStatusLabel(platform, detection)}）`,
-      value: platform.id,
-      selected: platform.required || detection.installed,
-      disabled: selectable ? false : "未安装，无法自动配置",
-    };
-  });
+async function verifyPrimaryNode() {
+  const nodes = await getNodes("codex");
+  const primary = nodes[0];
+  if (!primary) return null;
 
-  const response = await prompts({
-    type: "multiselect",
-    name: "platformIds",
-    message: "请选择要激活的平台",
-    choices,
-    min: 1,
-    hint: "空格选择，回车确认",
-  }, { onCancel: () => false });
+  console.log("");
+  console.log("  正在验证节点...");
+  const result = await testNode(primary.url);
+  if (result.available) {
+    console.log(`  ✓ ${primary.name || "FogAct"} 已连接`);
+    console.log(`    延迟: ${result.latency}ms`);
+    console.log(`    地址: ${primary.url}`);
+    console.log("");
+    return { node: primary, latency: result.latency };
+  }
 
-  const selectedIds = response.platformIds || [];
-  return getActivationTargets(detectedPlatforms, false, selectedIds);
+  console.log(`  ✗ ${primary.name || "FogAct"} 连接失败`);
+  console.log(`    地址: ${primary.url}`);
+  console.log("");
+  return null;
 }
 
 async function resolveCodeCredential(options, upstream) {
@@ -462,7 +507,7 @@ async function resolveCodeCredential(options, upstream) {
   }
 
   console.log("");
-  console.log("正在读取激活码能力...");
+  console.log("正在验证激活码...");
   const inspection = await inspectActivationCode(code);
   if (!inspection.valid) {
     console.log(`✗ 无法读取激活码能力: ${inspection.error || "接口未返回有效信息"}`);
@@ -494,47 +539,29 @@ async function resolveApiKeyCredential(options, upstream) {
 }
 
 async function activateTargets({ service, upstream, apiKey, targets, activationCode, options = {} }) {
-  console.log("");
-  console.log("正在创建备份...");
   const backupPath = createActivationBackup(service, getBackupPaths(targets), {
     upstream: upstream.baseUrl,
     targets: targets.map(({ platform }) => platform.id),
   });
-  if (backupPath) {
-    console.log(`✓ 备份完成: ${backupPath}`);
-  } else {
-    console.log("ℹ 没有旧配置需要备份");
-  }
 
-  console.log("");
-  console.log("正在激活平台...");
   const results = [];
   for (const { platform, detection } of targets) {
+    if (!canSelectPlatform(platform, detection)) {
+      results.push({ platform, result: { success: false, skipped: true, message: "未安装" } });
+      continue;
+    }
     try {
-      const result = platform.activate({ service, upstream, apiKey, detection });
+      const result = platform.activate({ service, upstream, apiKey, options, detection });
       results.push({ platform, result });
-      if (result.success) {
-        console.log(`✓ ${platform.name}`);
-      } else {
-        console.log(`⚠ ${platform.name}: ${result.message || "已跳过"}`);
-      }
     } catch (err) {
       results.push({ platform, result: { success: false, error: err.message } });
-      console.log(`✗ ${platform.name}: ${err.message}`);
     }
   }
 
   let redeemResult = null;
   const failures = results.filter(({ result }) => !result.success && !result.skipped);
   if (activationCode && failures.length === 0 && !options.noRedeem) {
-    console.log("");
-    console.log("正在完成兑换记录...");
     redeemResult = await redeemActivationCode(activationCode, service);
-    if (redeemResult.valid) {
-      console.log("✓ 兑换记录已完成");
-    } else {
-      console.log(`⚠ 兑换记录未完成: ${redeemResult.error || "接口不可用"}`);
-    }
   }
 
   return { backupPath, results, redeemResult };
@@ -587,19 +614,22 @@ async function runNewApiActivation(options = {}) {
   const detectedPlatforms = detectPlatforms(service);
   const selectedPlatformIds = options.platforms ? parsePlatformIds(options.platforms) : null;
   const targets = getActivationTargets(detectedPlatforms, Boolean(options.all), selectedPlatformIds);
-  const skipped = detectedPlatforms.filter((entry) => !targets.includes(entry));
 
-  console.log("");
-  printPlan(service, upstream, apiKey, targets, skipped);
+  printCredentialProfile(service, upstream, apiKey, entitlement);
 
-  if (!(await confirmActivation(Boolean(options.yes || options.auto)))) {
-    console.log("Activation cancelled.");
+  if (!(await confirmActivation(Boolean(options.yes || options.auto), service))) {
+    console.log("");
+    console.log("  已取消");
+    console.log("");
     return { success: false, cancelled: true };
   }
 
+  console.log("");
+  console.log("  正在写入配置...");
   const activation = await activateTargets({ service, upstream, apiKey, targets, options });
   const failures = activation.results.filter(({ result }) => !result.success && !result.skipped);
-  printResultSummary(service, upstream, activation.backupPath, activation.results, activation.redeemResult);
+  console.log("  配置完成");
+  printResultSummary(service, activation.backupPath, activation.results, activation.redeemResult);
 
   return {
     success: failures.length === 0,
@@ -609,7 +639,13 @@ async function runNewApiActivation(options = {}) {
 }
 
 async function runActivationWizard(options = {}) {
-  printBanner();
+  if (!options.noNodeCheck) {
+    const node = await verifyPrimaryNode();
+    if (!node) {
+      return { success: false, cancelled: true };
+    }
+  }
+
   const baseUpstream = loadUpstreamConfig({ configPath: options.upstreamConfig });
   const credentialType = !options.code && options.apiKey ? "api-key" : "code";
 
@@ -640,30 +676,29 @@ async function runActivationWizard(options = {}) {
     if (!verification.valid) {
       return { success: false, verification };
     }
-  } else {
-    console.log("✓ 已按激活码能力限制可选平台");
   }
 
   const allDetectedPlatforms = detectPlatforms(service);
   const allowedPlatforms = allDetectedPlatforms.filter((entry) => isPlatformAllowed(entry, credential.entitlement, service));
-  const blockedPlatforms = allDetectedPlatforms.filter((entry) => !allowedPlatforms.includes(entry));
-
-  console.log("");
-  printDetection(service, allowedPlatforms, blockedPlatforms);
 
   const targets = await selectPlatforms(allowedPlatforms, options);
   if (targets.length === 0) {
-    console.log("没有选择任何平台，已取消。");
+    console.log("");
+    console.log("  ✗ 当前环境没有可激活目标");
+    console.log("");
     return { success: false, cancelled: true };
   }
-  const skipped = allowedPlatforms.filter((entry) => !targets.includes(entry)).concat(blockedPlatforms);
 
-  printPlan(service, upstream, credential.apiKey, targets, skipped);
-  if (!(await confirmActivation(Boolean(options.yes || options.auto)))) {
-    console.log("已取消。");
+  printCredentialProfile(service, upstream, credential.apiKey, credential.entitlement);
+  if (!(await confirmActivation(Boolean(options.yes || options.auto), service))) {
+    console.log("");
+    console.log("  已取消");
+    console.log("");
     return { success: false, cancelled: true };
   }
 
+  console.log("");
+  console.log("  正在写入配置...");
   const activation = await activateTargets({
     service,
     upstream,
@@ -673,7 +708,8 @@ async function runActivationWizard(options = {}) {
     options,
   });
   const failures = activation.results.filter(({ result }) => !result.success && !result.skipped);
-  printResultSummary(service, upstream, activation.backupPath, activation.results, activation.redeemResult);
+  console.log("  配置完成");
+  printResultSummary(service, activation.backupPath, activation.results, activation.redeemResult);
 
   return {
     success: failures.length === 0,

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

@@ -121,40 +121,51 @@ async function redeemActivationCode(code, service) {
 
 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) {