fogact 1.1.3

package/lib/commands/restore.js

@@ -0,0 +1,102 @@
+"use strict";
+
+const prompts = require("prompts");
+const { listBackups, restoreBackup, clearBackups } = require("../services/backup-service");
+
+async function runRestoreCommand(options = {}) {
+  console.log("");
+  console.log("=== Restore Backup ===");
+  console.log("");
+
+  // Step 1: Select service
+  let service = options.service;
+  if (!service) {
+    const response = await prompts({
+      type: "select",
+      name: "service",
+      message: "Select service",
+      choices: [
+        { title: "Claude Code", value: "claude" },
+        { title: "Codex", value: "codex" },
+        { title: "All services", value: null },
+      ],
+    });
+
+    if (response.service === undefined) {
+      console.log("Restore cancelled.");
+      return;
+    }
+
+    service = response.service;
+  }
+
+  // Step 2: List backups
+  const backups = listBackups(service);
+
+  if (backups.length === 0) {
+    console.log("No backups found.");
+    console.log("");
+    return;
+  }
+
+  console.log(`Found ${backups.length} backup(s):`);
+  console.log("");
+
+  // Step 3: Select backup or clear all
+  const choices = backups.map((backup, index) => ({
+    title: `${backup.service} - ${new Date(backup.timestamp).toLocaleString()}`,
+    value: backup.path,
+  }));
+
+  choices.push({ title: "Clear all backups", value: "__clear__" });
+
+  const response = await prompts({
+    type: "select",
+    name: "backup",
+    message: "Select backup to restore",
+    choices,
+  });
+
+  if (!response.backup) {
+    console.log("Restore cancelled.");
+    return;
+  }
+
+  // Step 4: Handle clear all
+  if (response.backup === "__clear__") {
+    const confirm = await prompts({
+      type: "confirm",
+      name: "value",
+      message: "Are you sure you want to clear all backups?",
+      initial: false,
+    });
+
+    if (!confirm.value) {
+      console.log("Clear cancelled.");
+      return;
+    }
+
+    const count = clearBackups(service);
+    console.log("");
+    console.log(`✓ Cleared ${count} backup(s)`);
+    console.log("");
+    return;
+  }
+
+  // Step 5: Restore backup
+  console.log("");
+  console.log("Restoring backup...");
+
+  try {
+    const restoredPath = restoreBackup(response.backup);
+    console.log(`✓ Backup restored: ${restoredPath}`);
+    console.log("");
+    console.log("Please restart your application to apply changes.");
+    console.log("");
+  } catch (err) {
+    console.log(`✗ Restore failed: ${err.message}`);
+    console.log("");
+  }
+}
+
+module.exports = { runRestoreCommand };

package/lib/commands/test.js

@@ -0,0 +1,40 @@
+"use strict";
+
+const { getNodes } = require("../services/cliproxy-api");
+const { testNodes, formatNodeResults } = require("../services/node-service");
+
+async function runTestCommand() {
+  console.log("");
+  console.log("=== Node Testing ===");
+  console.log("");
+
+  // Test Claude nodes
+  console.log("Testing Claude Code nodes...");
+  const claudeNodes = await getNodes("claude");
+
+  if (claudeNodes.length > 0) {
+    const claudeResults = await testNodes(claudeNodes);
+    console.log("");
+    console.log(formatNodeResults(claudeResults));
+  } else {
+    console.log("  No Claude nodes available");
+  }
+
+  console.log("");
+
+  // Test Codex nodes
+  console.log("Testing Codex nodes...");
+  const codexNodes = await getNodes("codex");
+
+  if (codexNodes.length > 0) {
+    const codexResults = await testNodes(codexNodes);
+    console.log("");
+    console.log(formatNodeResults(codexResults));
+  } else {
+    console.log("  No Codex nodes available");
+  }
+
+  console.log("");
+}
+
+module.exports = { runTestCommand };

package/lib/config/claude.js

@@ -0,0 +1,81 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+function getClaudeDir() {
+  return path.join(os.homedir(), ".claude");
+}
+
+function getClaudeSettingsPath() {
+  return path.join(getClaudeDir(), "settings.json");
+}
+
+function getClaudeStatePath() {
+  return path.join(os.homedir(), ".claude.json");
+}
+
+function getClaudeConfigPath() {
+  return getClaudeSettingsPath();
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function readJsonFile(filePath, fallback = {}) {
+  if (!fs.existsSync(filePath)) {
+    return fallback;
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (err) {
+    return fallback;
+  }
+}
+
+function writeJsonFile(filePath, value) {
+  ensureDir(path.dirname(filePath));
+  fs.writeFileSync(filePath, JSON.stringify(value, null, 2), "utf8");
+}
+
+function readClaudeConfig() {
+  return readJsonFile(getClaudeSettingsPath(), {});
+}
+
+function writeClaudeConfig(apiKey, baseUrl) {
+  const settingsPath = getClaudeSettingsPath();
+  const statePath = getClaudeStatePath();
+  const settings = readJsonFile(settingsPath, {});
+  const { ANTHROPIC_API_KEY, ...existingEnv } = settings.env || {};
+
+  writeJsonFile(settingsPath, {
+    ...settings,
+    env: {
+      ...existingEnv,
+      ANTHROPIC_BASE_URL: baseUrl,
+      ANTHROPIC_AUTH_TOKEN: apiKey,
+    },
+  });
+
+  const state = readJsonFile(statePath, {});
+  writeJsonFile(statePath, {
+    ...state,
+    hasCompletedOnboarding: true,
+  });
+
+  return settingsPath;
+}
+
+module.exports = {
+  getClaudeDir,
+  getClaudeConfigPath,
+  getClaudeSettingsPath,
+  getClaudeStatePath,
+  readClaudeConfig,
+  writeClaudeConfig,
+};

package/lib/config/codex.js

@@ -0,0 +1,164 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+const YUNYI_PROVIDER = "yunyi";
+const YUNYI_MODEL = "gpt-5.3-codex";
+const BLOCK_START = "# >>> yunyi activator codex >>>";
+const BLOCK_END = "# <<< yunyi activator codex <<<";
+
+function getCodexDir() {
+  return path.join(os.homedir(), ".codex");
+}
+
+function getCodexConfigPath() {
+  return path.join(getCodexDir(), "config.toml");
+}
+
+function getCodexAuthPath() {
+  return path.join(getCodexDir(), "auth.json");
+}
+
+function ensureDir(dirPath) {
+  if (!fs.existsSync(dirPath)) {
+    fs.mkdirSync(dirPath, { recursive: true });
+  }
+}
+
+function readCodexConfig() {
+  const configPath = getCodexConfigPath();
+  if (!fs.existsSync(configPath)) {
+    return "";
+  }
+
+  try {
+    return fs.readFileSync(configPath, "utf8");
+  } catch (err) {
+    return "";
+  }
+}
+
+function readCodexAuth() {
+  const authPath = getCodexAuthPath();
+  if (!fs.existsSync(authPath)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(authPath, "utf8"));
+  } catch (err) {
+    return {};
+  }
+}
+
+function stripYunyiBlock(content) {
+  const lines = String(content || "").split(/\r?\n/);
+  const kept = [];
+  let inBlock = false;
+  let currentSection = null;
+  let inYunyiProvider = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (trimmed === BLOCK_START) {
+      inBlock = true;
+      continue;
+    }
+    if (trimmed === BLOCK_END) {
+      inBlock = false;
+      continue;
+    }
+    if (inBlock) {
+      continue;
+    }
+
+    const section = trimmed.match(/^\[([^\]]+)\]$/);
+    if (section) {
+      currentSection = section[1].trim();
+      inYunyiProvider = currentSection.toLowerCase().startsWith("model_providers.yunyi");
+      if (inYunyiProvider) {
+        continue;
+      }
+      kept.push(line);
+      continue;
+    }
+
+    if (inYunyiProvider) {
+      continue;
+    }
+
+    const isRootYunyiSetting =
+      !currentSection &&
+      (
+        trimmed === "# 云驿 API 中转配置" ||
+        /^#?\s*model_provider\s*=/.test(trimmed) ||
+        /^#?\s*model\s*=/.test(trimmed) ||
+        /^#?\s*model_reasoning_effort\s*=/.test(trimmed) ||
+        /^#?\s*disable_response_storage\s*=/.test(trimmed) ||
+        /^#?\s*preferred_auth_method\s*=/.test(trimmed)
+      );
+
+    if (!isRootYunyiSetting) {
+      kept.push(line);
+    }
+  }
+
+  return kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+}
+
+function buildCodexConfig(existingContent, baseUrl, apiKey) {
+  const cleaned = stripYunyiBlock(existingContent);
+  const yunyiConfig = [
+    BLOCK_START,
+    `model_provider = "${YUNYI_PROVIDER}"`,
+    `model = "${YUNYI_MODEL}"`,
+    'model_reasoning_effort = "high"',
+    "disable_response_storage = true",
+    'preferred_auth_method = "apikey"',
+    "",
+    `[model_providers.${YUNYI_PROVIDER}]`,
+    `name = "${YUNYI_PROVIDER}"`,
+    `base_url = "${baseUrl}"`,
+    'wire_api = "responses"',
+    `experimental_bearer_token = "${apiKey}"`,
+    "requires_openai_auth = true",
+    BLOCK_END,
+  ].join("\n");
+
+  const result = cleaned ? `${yunyiConfig}\n\n${cleaned}` : yunyiConfig;
+  return result.endsWith("\n") ? result : `${result}\n`;
+}
+
+function writeCodexConfig(apiKey, baseUrl) {
+  const configPath = getCodexConfigPath();
+  const authPath = getCodexAuthPath();
+  ensureDir(getCodexDir());
+
+  const config = buildCodexConfig(readCodexConfig(), baseUrl, apiKey);
+  fs.writeFileSync(configPath, config, "utf8");
+
+  const { YUNYI_API_KEY, ...auth } = readCodexAuth();
+  fs.writeFileSync(
+    authPath,
+    JSON.stringify({ ...auth, auth_mode: "apikey", OPENAI_API_KEY: apiKey }, null, 2),
+    "utf8"
+  );
+
+  return configPath;
+}
+
+module.exports = {
+  BLOCK_START,
+  BLOCK_END,
+  YUNYI_MODEL,
+  getCodexDir,
+  getCodexConfigPath,
+  getCodexAuthPath,
+  readCodexConfig,
+  readCodexAuth,
+  stripYunyiBlock,
+  buildCodexConfig,
+  writeCodexConfig,
+};

package/lib/config/upstream.js

@@ -0,0 +1,79 @@
+"use strict";
+
+const fs = require("fs");
+const path = require("path");
+
+const PROJECT_ROOT = path.join(__dirname, "..", "..");
+const DEFAULT_CONFIG_PATH = path.join(PROJECT_ROOT, "config", "upstream.json");
+const EXAMPLE_CONFIG_PATH = path.join(PROJECT_ROOT, "config", "upstream.example.json");
+
+function readJsonFile(filePath) {
+  if (!fs.existsSync(filePath)) {
+    return {};
+  }
+
+  try {
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+  } catch (err) {
+    throw new Error(`Invalid upstream config JSON: ${filePath}`);
+  }
+}
+
+function trimTrailingSlash(value) {
+  return String(value || "").trim().replace(/\/+$/, "");
+}
+
+function loadUpstreamConfig(options = {}) {
+  const configPath = options.configPath || process.env.CLIPROXY_UPSTREAM_CONFIG || DEFAULT_CONFIG_PATH;
+  const fileConfig = readJsonFile(configPath);
+  const baseUrl = trimTrailingSlash(
+    process.env.NEWAPI_BASE_URL ||
+    process.env.UPSTREAM_BASE_URL ||
+    fileConfig.baseUrl ||
+    fileConfig.url
+  );
+  const apiKey = String(
+    process.env.NEWAPI_API_KEY ||
+    process.env.UPSTREAM_API_KEY ||
+    fileConfig.apiKey ||
+    fileConfig.key ||
+    ""
+  ).trim();
+  const timeoutMs = parseInt(
+    process.env.NEWAPI_TIMEOUT_MS || fileConfig.timeoutMs || "10000",
+    10
+  ) || 10000;
+
+  return {
+    provider: fileConfig.provider || "newapi",
+    baseUrl,
+    apiKey,
+    services: fileConfig.services || {},
+    timeoutMs,
+    configPath,
+    configured: Boolean(baseUrl && apiKey),
+  };
+}
+
+function getServiceBaseUrl(config, service) {
+  const serviceConfig = (config.services && config.services[service]) || {};
+  return trimTrailingSlash(serviceConfig.baseUrl || config.baseUrl);
+}
+
+function requireUpstreamConfig(options = {}) {
+  const config = loadUpstreamConfig(options);
+  if (!config.configured) {
+    throw new Error(
+      `Upstream NewAPI config is incomplete. Copy ${path.relative(PROJECT_ROOT, EXAMPLE_CONFIG_PATH)} to ${path.relative(PROJECT_ROOT, DEFAULT_CONFIG_PATH)} and set baseUrl/apiKey, or use NEWAPI_BASE_URL and NEWAPI_API_KEY.`
+    );
+  }
+  return config;
+}
+
+module.exports = {
+  DEFAULT_CONFIG_PATH,
+  EXAMPLE_CONFIG_PATH,
+  getServiceBaseUrl,
+  loadUpstreamConfig,
+  requireUpstreamConfig,
+};

package/lib/index.js

@@ -0,0 +1,164 @@
+"use strict";
+
+const { Command } = require("commander");
+const prompts = require("prompts");
+const packageJson = require("../package.json");
+const { runActivateCommand } = require("./commands/activate");
+const { runTestCommand } = require("./commands/test");
+const { runRestoreCommand } = require("./commands/restore");
+const { runActivationWizard } = require("./services/activation-orchestrator");
+
+function printBanner() {
+  console.log("FogAct 多平台激活器");
+  console.log("一键激活 Codex / Claude / OpenCode / OpenClaw");
+  console.log("");
+}
+
+async function runInteractiveMenu() {
+  await runActivationWizard();
+}
+
+async function runToolsMenu() {
+  printBanner();
+
+  const response = await prompts(
+    {
+      type: "select",
+      name: "action",
+      message: "请选择操作",
+      choices: [
+        { title: "多平台激活", value: "activate" },
+        { title: "测试节点", value: "test" },
+        { title: "恢复备份", value: "restore" },
+        { title: "启动 Web UI", value: "web" },
+        { title: "退出", value: "exit" },
+      ],
+      initial: 0,
+    },
+    { onCancel: () => false }
+  );
+
+  switch (response.action) {
+    case "activate":
+      await runActivationWizard();
+      break;
+    case "test":
+      await runTestCommand();
+      break;
+    case "restore":
+      await runRestoreCommand();
+      break;
+    case "web":
+      runWebServer();
+      break;
+    default:
+      console.log("再见。");
+      console.log("");
+      break;
+  }
+}
+
+function runWebServer() {
+  require("../bin/web-server");
+}
+
+function buildProgram() {
+  const program = new Command();
+
+  program
+    .name("fogact")
+    .description(packageJson.description)
+    .version(packageJson.version)
+    .addHelpText(
+      "after",
+      [
+        "",
+        "Examples:",
+        "  npx fogact",
+        "  fogact",
+        "  fogact activate --service codex --yes --all",
+        "  fogact activate --service claude --api-key sk-... --yes",
+        "  fogact activate --code K1DHPY3P-4B2W-F1A4-DC4P-Y74TCQZXPNYT",
+        "  fogact test",
+        "  fogact restore --service claude",
+      ].join("\n")
+    );
+
+  program
+    .command("activate")
+    .description("Open the multi-platform activation flow")
+    .option("-s, --service <service>", "target service: claude or codex")
+    .option("-k, --api-key <apiKey>", "NewAPI key; defaults to config/upstream.json or NEWAPI_API_KEY")
+    .option("-y, --yes", "auto-confirm activation plan")
+    .option("--auto", "alias for --yes")
+    .option("--all", "configure optional platforms even when their config files do not exist")
+    .option("--platforms <ids>", "comma-separated platform ids to activate")
+    .option("--skip-verify", "skip upstream /v1/models key verification")
+    .option("--upstream-config <path>", "path to upstream config JSON")
+    .option("-c, --code <code>", "activation / redeem code")
+    .option("--legacy", "use legacy activation-code node switching flow")
+    .option("--no-redeem", "do not mark activation code as redeemed after writing config")
+    .action(runActivateCommand);
+
+  program
+    .command("wizard")
+    .description("Open FogIDC-style activation wizard")
+    .option("-s, --service <service>", "target service: claude or codex")
+    .option("-k, --api-key <apiKey>", "NewAPI key")
+    .option("-c, --code <code>", "activation / redeem code")
+    .option("--platforms <ids>", "comma-separated platform ids to activate")
+    .option("--all", "select all configurable platforms")
+    .option("--yes", "auto-confirm activation plan")
+    .option("--skip-verify", "skip upstream /v1/models key verification")
+    .option("--upstream-config <path>", "path to upstream config JSON")
+    .option("--no-redeem", "do not mark activation code as redeemed after writing config")
+    .action(runActivationWizard);
+
+  program
+    .command("test")
+    .description("Test CLIProxy nodes")
+    .action(runTestCommand);
+
+  program
+    .command("restore")
+    .description("Restore a previous backup")
+    .option("-s, --service <service>", "target service: claude or codex")
+    .action(runRestoreCommand);
+
+  program
+    .command("web")
+    .description("Start the local Web UI")
+    .action(runWebServer);
+
+  program
+    .command("interactive")
+    .description("Open the activation wizard")
+    .action(runInteractiveMenu);
+
+  program
+    .command("menu")
+    .description("Open tools menu")
+    .action(runToolsMenu);
+
+  return program;
+}
+
+async function runCli(argv = process.argv) {
+  const args = argv.slice(2);
+
+  if (args.length === 0) {
+    await runToolsMenu();
+    return;
+  }
+
+  const program = buildProgram();
+  await program.parseAsync(argv);
+}
+
+module.exports = {
+  buildProgram,
+  runCli,
+  runInteractiveMenu,
+  runToolsMenu,
+  runWebServer,
+};

package/lib/platforms/claude-code.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const fs = require("fs");
+const { getServiceBaseUrl } = require("../config/upstream");
+const {
+  getClaudeDir,
+  getClaudeSettingsPath,
+  getClaudeStatePath,
+  writeClaudeConfig,
+} = require("../config/claude");
+
+function createClaudeCodePlatform() {
+  return {
+    id: "claude-code",
+    name: "Claude Code",
+    services: ["claude"],
+    required: true,
+    detect() {
+      return {
+        installed: fs.existsSync(getClaudeDir()) || fs.existsSync(getClaudeSettingsPath()),
+        paths: [getClaudeSettingsPath(), getClaudeStatePath()],
+      };
+    },
+    activate(context) {
+      const baseUrl = getServiceBaseUrl(context.upstream, "claude");
+      const settingsPath = writeClaudeConfig(context.apiKey, baseUrl);
+      return {
+        success: true,
+        files: [settingsPath, getClaudeStatePath()],
+      };
+    },
+  };
+}
+
+module.exports = { createClaudeCodePlatform };

package/lib/platforms/codex-cli.js

@@ -0,0 +1,35 @@
+"use strict";
+
+const fs = require("fs");
+const { getServiceBaseUrl } = require("../config/upstream");
+const {
+  getCodexDir,
+  getCodexConfigPath,
+  getCodexAuthPath,
+  writeCodexConfig,
+} = require("../config/codex");
+
+function createCodexCliPlatform() {
+  return {
+    id: "codex-cli",
+    name: "Codex CLI",
+    services: ["codex"],
+    required: true,
+    detect() {
+      return {
+        installed: fs.existsSync(getCodexDir()) || fs.existsSync(getCodexConfigPath()) || fs.existsSync(getCodexAuthPath()),
+        paths: [getCodexConfigPath(), getCodexAuthPath()],
+      };
+    },
+    activate(context) {
+      const baseUrl = getServiceBaseUrl(context.upstream, "codex");
+      const configPath = writeCodexConfig(context.apiKey, baseUrl);
+      return {
+        success: true,
+        files: [configPath, getCodexAuthPath()],
+      };
+    },
+  };
+}
+
+module.exports = { createCodexCliPlatform };