fogact 1.1.10 → 1.2.2

package/lib/services/activation-orchestrator.js

@@ -2,10 +2,9 @@
 
 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 { maskKey, verifyNewApiKey } = require("./newapi");
+const { getNodes, inspectActivationCode, testNode, verifyActivationCode } = require("./fogact-api");
+const { maskKey } = require("./newapi");
 
 const SUPPORTED_SERVICES = ["codex", "claude"];
 const SERVICE_LABELS = {
@@ -149,6 +148,9 @@ function normalizeEntitlement(raw = {}, fallbackServices = []) {
 function extractApiKeyFromEntitlement(entitlement, fallback) {
   const raw = entitlement && entitlement.raw ? entitlement.raw : {};
   const credential = raw.credential || raw.credentials || {};
+  if (raw.proxy === true) {
+    return String(raw.apiKey || raw.key || raw.token || fallback || "").trim();
+  }
   return String(
     raw.apiKey ||
     raw.key ||
@@ -176,6 +178,16 @@ function extractBaseUrlFromEntitlement(entitlement) {
   ).trim().replace(/\/+$/, "");
 }
 
+function extractProxyBaseUrlFromEntitlement(entitlement) {
+  const raw = entitlement && entitlement.raw ? entitlement.raw : {};
+  const service = raw.serviceKey || (entitlement.services && entitlement.services[0]);
+  return String(
+    raw.baseUrl ||
+    (raw.publicBaseUrl && service === "codex" ? `${String(raw.publicBaseUrl).replace(/\/+$/, "")}/v1` : raw.publicBaseUrl) ||
+    ""
+  ).trim().replace(/\/+$/, "");
+}
+
 function isServiceAllowed(entitlement, service) {
   return !entitlement.services.length || entitlement.services.includes(service);
 }
@@ -219,21 +231,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 能力，无法自动识别。请联系管理员重新生成激活码。");
@@ -253,75 +261,22 @@ async function promptService(defaultService, entitlement = normalizeEntitlement(
   return response.service || null;
 }
 
-async function promptApiKey(defaultApiKey) {
-  if (defaultApiKey) {
-    return defaultApiKey;
-  }
-
-  const response = await prompts({
-    type: "password",
-    name: "apiKey",
-    message: "请输入 NewAPI API Key",
-    validate: (value) => value && value.trim() ? true : "API Key 不能为空",
-  }, { onCancel: () => false });
-
-  return response.apiKey ? response.apiKey.trim() : null;
-}
-
-async function promptBaseUrl(defaultBaseUrl) {
-  if (defaultBaseUrl) {
-    return defaultBaseUrl;
-  }
-
-  const response = await prompts({
-    type: "text",
-    name: "baseUrl",
-    message: "请输入 NewAPI Base URL",
-    validate: (value) => value && value.trim() ? true : "Base URL 不能为空",
-  }, { onCancel: () => false });
-
-  return response.baseUrl ? response.baseUrl.trim().replace(/\/+$/, "") : null;
-}
-
 async function promptActivationCode(defaultCode) {
   if (defaultCode) {
     return defaultCode;
   }
 
   const response = await prompts({
-    type: "text",
+    type: "password",
     name: "code",
-    message: "请输入激活码 / 兑换码",
+    message: "请输入激活码:",
     validate: (value) => value && value.trim() ? true : "激活码不能为空",
   }, { onCancel: () => false });
 
   return response.code ? response.code.trim() : null;
 }
 
-async function promptCredentialType(options, upstream) {
-  if (options.code) {
-    return "code";
-  }
-  if (options.apiKey || upstream.apiKey) {
-    return "api-key";
-  }
-
-  const response = await prompts({
-    type: "select",
-    name: "credentialType",
-    message: "请选择激活方式",
-    hint: "↑↓ 选择，回车确认",
-    choices: [
-      { title: "输入激活码 / 兑换码", value: "code" },
-      { title: "输入 NewAPI API Key", value: "api-key" },
-    ],
-    initial: 0,
-  }, { onCancel: () => false });
-
-  return response.credentialType || null;
-}
-
-async function confirmActivation(yes) {
+async function confirmActivation(yes, service) {
   if (yes) {
     return true;
   }
@@ -329,7 +284,7 @@ async function confirmActivation(yes) {
   const response = await prompts({
     type: "confirm",
     name: "confirmed",
-    message: "确认开始激活？",
+    message: `确认激活 ${getServiceLabel(service)} 配置?`,
     initial: true,
   }, { onCancel: () => false });
 
@@ -353,6 +308,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 +321,109 @@ 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(`  激活码:     ${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 (redeemResult) {
-    console.log(`  兑换: ${redeemResult.valid ? "已完成" : `未完成（${redeemResult.error || "接口不可用"}）`}`);
-  }
-  console.log("  提示: 重启相关工具后生效");
+  if (failed.length) {
+    console.log(`  激活完成：${succeeded.length} 成功，${failed.length} 失败，${skipped.length} 跳过`);
+  }
+  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("");
 }
 
@@ -431,6 +434,28 @@ async function selectPlatforms(detectedPlatforms, options = {}) {
   return getActivationTargets(detectedPlatforms, Boolean(options.all));
 }
 
+async function verifyPrimaryNode() {
+  const nodes = await getNodes("codex");
+  const primary = nodes[0];
+  if (!primary) return null;
+
+  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 };
+  }
+
+  console.log(`  ✗ ${primary.name || "FogAct"} 连接失败`);
+  console.log(`    地址: ${primary.url}`);
+  console.log("");
+  return null;
+}
+
 async function resolveCodeCredential(options, upstream) {
   const code = await promptActivationCode(options.code);
   if (!code) {
@@ -438,7 +463,7 @@ async function resolveCodeCredential(options, upstream) {
   }
 
   console.log("");
-  console.log("正在读取激活码能力...");
+  console.log("正在验证激活码...");
   const inspection = await inspectActivationCode(code);
   if (!inspection.valid) {
     console.log(`✗ 无法读取激活码能力: ${inspection.error || "接口未返回有效信息"}`);
@@ -447,199 +472,98 @@ async function resolveCodeCredential(options, upstream) {
 
   const entitlement = normalizeEntitlement(inspection, options.service ? [options.service] : []);
   const apiKey = extractApiKeyFromEntitlement(entitlement, code);
-  const entitlementBaseUrl = extractBaseUrlFromEntitlement(entitlement);
+  const entitlementBaseUrl = extractProxyBaseUrlFromEntitlement(entitlement);
+  if (!apiKey || !entitlementBaseUrl || entitlement.raw.proxy !== true) {
+    console.log("✗ 激活接口没有返回 FogAct 中转配置，请联系管理员检查服务端代理设置。");
+    return { cancelled: true };
+  }
   return {
     activationCode: code,
     apiKey,
     entitlement,
-    upstream: entitlementBaseUrl ? { ...upstream, baseUrl: entitlementBaseUrl } : upstream,
+    upstream: { services: {}, baseUrl: entitlementBaseUrl, proxy: true },
     inspection,
   };
 }
 
-async function resolveApiKeyCredential(options, upstream) {
-  const apiKey = await promptApiKey(options.apiKey || upstream.apiKey);
-  if (!apiKey) {
-    return { cancelled: true };
-  }
-  return {
-    apiKey,
-    entitlement: normalizeEntitlement({}, options.service ? [options.service] : []),
-    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;
+  let activationRecord = 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 || "接口不可用"}`);
-    }
+  if (activationCode && failures.length === 0) {
+    activationRecord = await verifyActivationCode(activationCode, service);
   }
 
-  return { backupPath, results, redeemResult };
+  return { backupPath, results, redeemResult: null, activationRecord };
 }
 
-async function verifyCredential(upstream, apiKey, options = {}) {
-  if (options.skipVerify) {
-    console.log("跳过 NewAPI 连通性验证。");
-    return { valid: true, skipped: true };
-  }
-
-  console.log("正在验证 NewAPI Key...");
-  const verification = await verifyNewApiKey(upstream, apiKey);
-  if (!verification.valid) {
-    console.log(`✗ NewAPI 验证失败: ${verification.error}`);
-    return verification;
-  }
-  console.log(`✓ NewAPI 验证通过（可见 ${verification.models.length} 个模型）`);
-  return verification;
-}
-
-async function runNewApiActivation(options = {}) {
-  const baseUpstream = loadUpstreamConfig({ configPath: options.upstreamConfig });
-  const upstream = { ...baseUpstream };
-  upstream.baseUrl = await promptBaseUrl(upstream.baseUrl);
-  if (!upstream.baseUrl) {
-    console.log("Activation cancelled.");
-    return { success: false, cancelled: true };
-  }
-
-  const apiKey = await promptApiKey(options.apiKey || upstream.apiKey);
-  if (!apiKey) {
-    console.log("Activation cancelled.");
-    return { success: false, cancelled: true };
-  }
-
-  const entitlement = normalizeEntitlement({}, options.service ? [options.service] : []);
-  const service = await promptService(options.service, entitlement);
-  if (!service) {
-    console.log("Activation cancelled.");
-    return { success: false, cancelled: true };
-  }
-
-  console.log("");
-  const verification = await verifyCredential(upstream, apiKey, options);
-  if (!verification.valid) {
-    return { success: false, verification };
-  }
-
-  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);
-
-  if (!(await confirmActivation(Boolean(options.yes || options.auto)))) {
-    console.log("Activation cancelled.");
-    return { success: false, cancelled: true };
-  }
-
-  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);
-
-  return {
-    success: failures.length === 0,
-    backupPath: activation.backupPath,
-    results: activation.results,
-  };
-}
 
 async function runActivationWizard(options = {}) {
-  printBanner();
-  const baseUpstream = loadUpstreamConfig({ configPath: options.upstreamConfig });
-  const credentialType = !options.code && options.apiKey ? "api-key" : "code";
+  if (!options.noNodeCheck) {
+    const node = await verifyPrimaryNode();
+    if (!node) {
+      return { success: false, cancelled: true };
+    }
+  }
 
-  const credential = credentialType === "code"
-    ? await resolveCodeCredential(options, baseUpstream)
-    : await resolveApiKeyCredential(options, baseUpstream);
+  const credential = await resolveCodeCredential(options, {});
   if (credential.cancelled) {
     console.log("已取消。");
     return { success: false, cancelled: true };
   }
 
   const upstream = { ...credential.upstream };
-  upstream.baseUrl = await promptBaseUrl(upstream.baseUrl);
   if (!upstream.baseUrl) {
     console.log("已取消。");
     return { success: false, cancelled: true };
   }
 
-  const service = await promptService(options.service, credential.entitlement, { allowPrompt: credentialType === "api-key" });
+  const service = await promptService(options.service, credential.entitlement, { allowPrompt: false });
   if (!service) {
     console.log("已取消。");
     return { success: false, cancelled: true };
   }
 
-  console.log("");
-  if (credentialType === "api-key") {
-    const verification = await verifyCredential(upstream, credential.apiKey, 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,
@@ -649,7 +573,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,
@@ -667,5 +592,4 @@ module.exports = {
   normalizeServices,
   parsePlatformIds,
   runActivationWizard,
-  runNewApiActivation,
 };