abelworkflow 0.2.0 → 0.6.1

package/lib/cli.mjs

@@ -12,10 +12,14 @@ const home = homedir();
 const defaultAgentsDir = join(home, ".agents");
 const installMetadataName = ".abelworkflow-install.json";
 const claudeSettingsPath = join(home, ".claude", "settings.json");
-const claudeVscodeConfigPath = join(home, ".claude", "config.json");
 const claudeMetaConfigPath = join(home, ".claude.json");
 const codexConfigPath = join(home, ".codex", "config.toml");
 const codexAuthPath = join(home, ".codex", "auth.json");
+const codexTemplateRoot = join(packageRoot, "lib", "templates", "codex");
+const codexTemplateConfigPath = join(codexTemplateRoot, "config-base.toml");
+const codexTemplateAgentsPath = join(codexTemplateRoot, "agents");
+const installBackupStamp = Date.now();
+const createdBackupPaths = new Set();
 const claudeModelEnvKeys = [
   "ANTHROPIC_MODEL",
   "ANTHROPIC_DEFAULT_OPUS_MODEL",
@@ -222,17 +226,38 @@ async function pathTargetExists(path) {
   }
 }
 
+async function createBackupPath(targetPath) {
+  let index = 0;
+  while (true) {
+    const backupPath = `${targetPath}.bak.${installBackupStamp}${index ? `-${index}` : ""}`;
+    if (!(await pathExists(backupPath))) {
+      return backupPath;
+    }
+    index += 1;
+  }
+}
+
+async function backupExistingPath(targetPath) {
+  if (createdBackupPaths.has(targetPath) || !(await pathExists(targetPath))) {
+    return null;
+  }
+
+  const backupPath = await createBackupPath(targetPath);
+  await cp(targetPath, backupPath, { recursive: true, force: false });
+  createdBackupPaths.add(targetPath);
+  console.log(`已备份已有配置: ${pathToLabel(targetPath)} -> ${pathToLabel(backupPath)}`);
+  return backupPath;
+}
+
 async function backupIfNeeded(targetPath, force) {
   if (!(await pathExists(targetPath))) {
     return null;
   }
-  if (!force) {
-    const backupPath = `${targetPath}.bak.${Date.now()}`;
-    await rename(targetPath, backupPath);
-    return backupPath;
-  }
-  await rm(targetPath, { recursive: true, force: true });
-  return null;
+
+  const backupPath = await createBackupPath(targetPath);
+  await rename(targetPath, backupPath);
+  console.log(`已备份已有配置: ${pathToLabel(targetPath)} -> ${pathToLabel(backupPath)}`);
+  return backupPath;
 }
 
 async function syncManagedFiles(agentsDir) {
@@ -298,8 +323,10 @@ async function replaceManagedEntry(source, target, entry) {
 
   const sourceStat = await lstat(source);
   if (sourceStat.isDirectory()) {
+    await backupExistingPath(target);
     await rm(target, { recursive: true, force: true });
   } else if (await pathExists(target)) {
+    await backupExistingPath(target);
     const targetStat = await lstat(target);
     if (targetStat.isDirectory()) {
       await rm(target, { recursive: true, force: true });
@@ -850,6 +877,11 @@ async function writeJsonFileSafe(path, data) {
   await writeFile(path, `${JSON.stringify(data, null, 2)}\n`, "utf8");
 }
 
+async function writeJsonFileWithBackup(path, data) {
+  await backupExistingPath(path);
+  await writeJsonFileSafe(path, data);
+}
+
 function parseDotenv(content) {
   const values = {};
   for (const rawLine of content.split(/\r?\n/u)) {
@@ -912,6 +944,7 @@ async function updateDotenvFile(path, updates) {
       current[key] = String(value);
     }
   }
+  await backupExistingPath(path);
   await mkdir(dirname(path), { recursive: true });
   await writeFile(path, renderDotenv(current), "utf8");
 }
@@ -1053,9 +1086,16 @@ function commandExists(command) {
   return result.status === 0;
 }
 
+function getRunCommandSpawnOptions(platform = getPlatform()) {
+  return {
+    stdio: "inherit",
+    shell: platform === "win32"
+  };
+}
+
 async function runCommand(command, args) {
   await new Promise((resolvePromise, rejectPromise) => {
-    const child = spawn(command, args, { stdio: "inherit" });
+    const child = spawn(command, args, getRunCommandSpawnOptions());
     child.on("error", rejectPromise);
     child.on("close", (code) => {
       if (code === 0) {
@@ -1276,54 +1316,90 @@ async function configureClaudeApi() {
     nextSettings.env[field] = model;
   }
 
-  await writeJsonFileSafe(claudeSettingsPath, nextSettings);
-
-  const vscodeConfig = await readJsonFileSafe(claudeVscodeConfigPath, {});
-  vscodeConfig.primaryApiKey = "abelworkflow";
-  await writeJsonFileSafe(claudeVscodeConfigPath, vscodeConfig);
+  await writeJsonFileWithBackup(claudeSettingsPath, nextSettings);
 
   const metaConfig = await readJsonFileSafe(claudeMetaConfigPath, {});
   metaConfig.hasCompletedOnboarding = true;
   ensureApprovedClaudeApiKey(metaConfig, key);
-  await writeJsonFileSafe(claudeMetaConfigPath, metaConfig);
+  await writeJsonFileWithBackup(claudeMetaConfigPath, metaConfig);
 
   console.log(`已更新 ${pathToLabel(claudeSettingsPath)} (${authType}, ${baseUrl}, ${maskSecret(key)})`);
 }
 
 function updateTopLevelTomlField(content, field, value) {
   const lineEnding = detectLineEnding(content);
-  const firstSectionMatch = content.match(/^\[/mu);
-  const topLevelEnd = firstSectionMatch?.index ?? content.length;
-  let topLevel = content.slice(0, topLevelEnd);
-  const rest = content.slice(topLevelEnd);
-  const fieldRegex = new RegExp(`^(#\\s*)?${escapeRegExp(field)}\\s*=\\s*["'][^"']*["'][ \\t]*(?:#.*)?\\r?$`, "mu");
-
   if (value === null) {
-    topLevel = collapseBlankLines(topLevel.replace(fieldRegex, ""), lineEnding);
-  } else {
-    const nextLine = `${field} = ${JSON.stringify(value)}`;
-    if (fieldRegex.test(topLevel)) {
-      topLevel = topLevel.replace(fieldRegex, nextLine);
-    } else {
-      topLevel = topLevel.trimEnd()
-        ? `${topLevel.trimEnd()}${lineEnding}${nextLine}${lineEnding}`
-        : `${nextLine}${lineEnding}`;
+    return removeTopLevelTomlField(content, field);
+  }
+
+  const { topLevel, rest } = splitTopLevelTomlContent(content);
+  const entry = extractTopLevelTomlEntries(content).find((item) => item.field === field);
+  const nextLine = `${field} = ${JSON.stringify(value)}`;
+  let nextTopLevel;
+
+  if (entry) {
+    const start = topLevel.indexOf(entry.raw);
+    if (start === -1) {
+      return content;
     }
+    nextTopLevel = `${topLevel.slice(0, start)}${nextLine}${topLevel.slice(start + entry.raw.length)}`;
+  } else {
+    nextTopLevel = topLevel.trimEnd()
+      ? `${topLevel.trimEnd()}${lineEnding}${nextLine}${lineEnding}`
+      : `${nextLine}${lineEnding}`;
+  }
+
+  nextTopLevel = nextTopLevel.trimEnd();
+
+  if (rest && nextTopLevel) {
+    nextTopLevel = `${nextTopLevel}${lineEnding}${lineEnding}`;
+  }
+
+  return `${nextTopLevel}${rest}`;
+}
+
+function removeTopLevelTomlField(content, field) {
+  const lineEnding = detectLineEnding(content);
+  const { topLevel, rest } = splitTopLevelTomlContent(content);
+  const entry = extractTopLevelTomlEntries(content).find((item) => item.field === field);
+  if (!entry) {
+    return content;
+  }
+
+  const start = topLevel.indexOf(entry.raw);
+  if (start === -1) {
+    return content;
   }
 
-  topLevel = topLevel.trimEnd();
+  let nextTopLevel = `${topLevel.slice(0, start)}${topLevel.slice(start + entry.raw.length)}`;
+  nextTopLevel = collapseBlankLines(nextTopLevel, lineEnding).trimEnd();
 
-  if (rest && topLevel) {
-    topLevel = `${topLevel}${lineEnding}${lineEnding}`;
+  if (rest && nextTopLevel) {
+    nextTopLevel = `${nextTopLevel}${lineEnding}${lineEnding}`;
   }
 
-  return `${topLevel}${rest}`;
+  return `${nextTopLevel}${rest}`;
 }
 
 function removeTomlSection(content, sectionName) {
   const lineEnding = detectLineEnding(content);
-  const sectionRegex = new RegExp(`(?:\\r?\\n)?\\[${escapeRegExp(sectionName)}\\][\\s\\S]*?(?=\\r?\\n\\[|$)`, "gu");
-  return collapseBlankLines(content.replace(sectionRegex, ""), lineEnding).trimEnd();
+  const sectionHeaderRegex = new RegExp(
+    `(?:^|\\r?\\n)\\[${escapeRegExp(sectionName)}\\](?:[ \\t]+#.*)?[ \\t]*\\r?$`,
+    "mu"
+  );
+  const headerMatch = sectionHeaderRegex.exec(content);
+  if (!headerMatch) {
+    return content;
+  }
+
+  const sectionStart = headerMatch[0].startsWith("\n") || headerMatch[0].startsWith("\r\n")
+    ? headerMatch.index + headerMatch[0].indexOf("[")
+    : headerMatch.index;
+  const headerLineEnd = content.indexOf(lineEnding, sectionStart);
+  const bodyStart = headerLineEnd === -1 ? content.length : headerLineEnd + lineEnding.length;
+  const nextSectionStart = findTomlSectionStart(content, bodyStart);
+  const sectionEnd = nextSectionStart === -1 ? content.length : nextSectionStart;
+  return collapseBlankLines(`${content.slice(0, sectionStart)}${content.slice(sectionEnd)}`, lineEnding).trimEnd();
 }
 
 function buildTomlSection(sectionName, values, lineEnding = "\n") {
@@ -1343,18 +1419,235 @@ function buildTomlSection(sectionName, values, lineEnding = "\n") {
   return `${lines.join(lineEnding)}${lineEnding}`;
 }
 
-function readTopLevelTomlString(content, field) {
-  let inSection = false;
-  for (const line of content.split(/\r?\n/u)) {
+function formatTomlValue(value) {
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "boolean") {
+    return value ? "true" : "false";
+  }
+  return String(value);
+}
+
+function getTomlLines(content) {
+  if (!content) {
+    return [];
+  }
+
+  const chunks = content.match(/[^\r\n]*(?:\r?\n|$)/gu) || [];
+  const lines = [];
+  let offset = 0;
+
+  for (const chunk of chunks) {
+    if (!chunk && offset >= content.length) {
+      break;
+    }
+
+    const lineEndingMatch = chunk.match(/\r?\n$/u);
+    const lineEnding = lineEndingMatch ? lineEndingMatch[0] : "";
+    lines.push({
+      line: lineEnding ? chunk.slice(0, -lineEnding.length) : chunk,
+      start: offset
+    });
+    offset += chunk.length;
+
+    if (!lineEnding && offset >= content.length) {
+      break;
+    }
+  }
+
+  return lines;
+}
+
+function findTomlSectionStart(content, fromIndex = 0) {
+  const scopedContent = content.slice(fromIndex);
+  let multilineDelimiter = "";
+
+  for (const { line, start } of getTomlLines(scopedContent)) {
     const trimmed = line.trim();
+
+    if (multilineDelimiter) {
+      if (line.includes(multilineDelimiter)) {
+        multilineDelimiter = "";
+      }
+      continue;
+    }
+
     if (!trimmed || trimmed.startsWith("#")) {
       continue;
     }
-    if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-      inSection = true;
+
+    if (/^\[[^\]]+\]\s*(?:#.*)?$/u.test(trimmed)) {
+      return fromIndex + start;
+    }
+
+    const match = line.match(/^\s*([A-Za-z0-9_]+)\s*=\s*(.*)$/u);
+    if (!match) {
+      continue;
+    }
+
+    const delimiter = getTomlMultilineStringDelimiter(match[2].trimStart());
+    if (delimiter && match[2].indexOf(delimiter, delimiter.length) === -1) {
+      multilineDelimiter = delimiter;
+    }
+  }
+
+  return -1;
+}
+
+function splitTopLevelTomlContent(content) {
+  const topLevelEnd = findTomlSectionStart(content);
+  return {
+    topLevel: topLevelEnd === -1 ? content : content.slice(0, topLevelEnd),
+    rest: topLevelEnd === -1 ? "" : content.slice(topLevelEnd)
+  };
+}
+
+function getTomlMultilineStringDelimiter(value) {
+  if (value.startsWith(`"""`)) {
+    return `"""`;
+  }
+  if (value.startsWith(`'''`)) {
+    return `'''`;
+  }
+  return "";
+}
+
+function extractTopLevelTomlEntries(content) {
+  const { topLevel } = splitTopLevelTomlContent(content);
+  const lineEnding = detectLineEnding(topLevel);
+  const lines = topLevel.split(/\r?\n/u);
+  const entries = [];
+
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index];
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
+      continue;
+    }
+
+    const match = line.match(/^\s*([A-Za-z0-9_]+)\s*=\s*(.*)$/u);
+    if (!match) {
+      continue;
+    }
+
+    const rawLines = [line];
+    const delimiter = getTomlMultilineStringDelimiter(match[2].trimStart());
+    if (delimiter && match[2].indexOf(delimiter, delimiter.length) === -1) {
+      for (index += 1; index < lines.length; index += 1) {
+        rawLines.push(lines[index]);
+        if (lines[index].includes(delimiter)) {
+          break;
+        }
+      }
+    }
+
+    entries.push({
+      field: match[1],
+      raw: rawLines.join(lineEnding)
+    });
+  }
+
+  return entries;
+}
+
+function mergeMissingTopLevelTomlEntries(content, entries) {
+  if (!entries.length) {
+    return content;
+  }
+
+  const lineEnding = detectLineEnding(content);
+  const { topLevel, rest } = splitTopLevelTomlContent(content);
+  const existingFields = new Set(extractTopLevelTomlEntries(content).map(({ field }) => field));
+  const missingEntries = entries.filter(({ field }) => !existingFields.has(field));
+  if (!missingEntries.length) {
+    return content;
+  }
+
+  let nextTopLevel = topLevel.trimEnd();
+  for (const entry of missingEntries) {
+    nextTopLevel = nextTopLevel
+      ? `${nextTopLevel}${lineEnding}${entry.raw}`
+      : entry.raw;
+  }
+
+  nextTopLevel = nextTopLevel.trimEnd();
+  if (rest && nextTopLevel) {
+    nextTopLevel = `${nextTopLevel}${lineEnding}${lineEnding}`;
+  }
+  return `${nextTopLevel}${rest}`;
+}
+
+function updateTomlBodyFields(body, values, lineEnding = "\n") {
+  const normalizedBody = body.replace(/\r?\n$/u, "");
+  const lines = normalizedBody ? normalizedBody.split(/\r?\n/u) : [];
+  const remaining = new Map(
+    Object.entries(values).filter(([, value]) => value !== undefined && value !== null && value !== "")
+  );
+  const managedFields = new Set(remaining.keys());
+  const seenFields = new Set();
+  const nextLines = [];
+
+  for (const rawLine of lines) {
+    const match = rawLine.match(/^(\s*)([A-Za-z0-9_]+)\s*=\s*.*$/u);
+    if (!match || !managedFields.has(match[2])) {
+      nextLines.push(rawLine);
+      continue;
+    }
+
+    if (seenFields.has(match[2])) {
       continue;
     }
-    if (inSection) {
+
+    nextLines.push(`${match[1]}${match[2]} = ${formatTomlValue(remaining.get(match[2]))}`);
+    seenFields.add(match[2]);
+    remaining.delete(match[2]);
+  }
+
+  for (const [field, value] of remaining) {
+    nextLines.push(`${field} = ${formatTomlValue(value)}`);
+  }
+
+  return nextLines.join(lineEnding);
+}
+
+function updateTomlSectionFields(content, sectionName, values) {
+  const lineEnding = detectLineEnding(content);
+  const sectionHeaderRegex = new RegExp(
+    `^\\[${escapeRegExp(sectionName)}\\](?:[ \\t]+#.*)?[ \\t]*\\r?$`,
+    "mu"
+  );
+  const headerMatch = sectionHeaderRegex.exec(content);
+
+  if (!headerMatch) {
+    const nextSection = buildTomlSection(sectionName, values, lineEnding).trimEnd();
+    return content.trimEnd()
+      ? `${content.trimEnd()}${lineEnding}${lineEnding}${nextSection}${lineEnding}`
+      : `${nextSection}${lineEnding}`;
+  }
+
+  const sectionStart = headerMatch.index;
+  const headerLineEnd = content.indexOf(lineEnding, sectionStart);
+  const bodyStart = headerLineEnd === -1 ? content.length : headerLineEnd + lineEnding.length;
+  const headerLine = content.slice(sectionStart, headerLineEnd === -1 ? content.length : headerLineEnd);
+  const nextSectionStart = findTomlSectionStart(content, bodyStart);
+  const sectionEnd = nextSectionStart === -1 ? content.length : nextSectionStart;
+  const prefix = content.slice(0, sectionStart);
+  const body = content.slice(bodyStart, sectionEnd);
+  const suffix = content.slice(sectionEnd);
+  const nextBody = updateTomlBodyFields(body, values, lineEnding);
+  const renderedSection = nextBody
+    ? `${headerLine}${lineEnding}${nextBody}${lineEnding}`
+    : `${headerLine}${lineEnding}`;
+
+  return `${prefix}${renderedSection}${suffix.replace(/^\r?\n/u, "")}`;
+}
+
+function readTopLevelTomlString(content, field) {
+  const { topLevel } = splitTopLevelTomlContent(content);
+  for (const line of topLevel.split(/\r?\n/u)) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) {
       continue;
     }
     const match = trimmed.match(new RegExp(`^${escapeRegExp(field)}\\s*=\\s*"([^"]+)"$`, "u"));
@@ -1366,78 +1659,242 @@ function readTopLevelTomlString(content, field) {
 }
 
 function parseTomlSection(content, sectionName) {
-  const match = content.match(new RegExp(`\\[${escapeRegExp(sectionName)}\\]\\r?\\n([\\s\\S]*?)(?=\\r?\\n\\[|$)`, "u"));
-  if (!match) {
+  const lineEnding = detectLineEnding(content);
+  const sectionHeaderRegex = new RegExp(
+    `^\\[${escapeRegExp(sectionName)}\\](?:[ \\t]+#.*)?[ \\t]*\\r?$`,
+    "mu"
+  );
+  const headerMatch = sectionHeaderRegex.exec(content);
+  if (!headerMatch) {
     return {};
   }
 
+  const sectionStart = headerMatch.index;
+  const headerLineEnd = content.indexOf(lineEnding, sectionStart);
+  const bodyStart = headerLineEnd === -1 ? content.length : headerLineEnd + lineEnding.length;
+  const nextSectionStart = findTomlSectionStart(content, bodyStart);
+  const body = content.slice(bodyStart, nextSectionStart === -1 ? content.length : nextSectionStart);
+
   const values = {};
-  for (const rawLine of match[1].split(/\r?\n/u)) {
+  for (const rawLine of body.split(/\r?\n/u)) {
     const line = rawLine.trim();
     if (!line || line.startsWith("#")) {
       continue;
     }
-    const stringMatch = line.match(/^([A-Za-z0-9_]+)\s*=\s*"([^"]*)"$/u);
+    const stringMatch = line.match(/^([A-Za-z0-9_]+)\s*=\s*"([^"]*)"\s*(?:#.*)?$/u);
     if (stringMatch) {
       values[stringMatch[1]] = stringMatch[2];
       continue;
     }
-    const boolMatch = line.match(/^([A-Za-z0-9_]+)\s*=\s*(true|false)$/u);
+    const boolMatch = line.match(/^([A-Za-z0-9_]+)\s*=\s*(true|false)\s*(?:#.*)?$/u);
     if (boolMatch) {
       values[boolMatch[1]] = boolMatch[2] === "true";
+      continue;
+    }
+    const numberMatch = line.match(/^([A-Za-z0-9_]+)\s*=\s*(-?\d+(?:\.\d+)?)\s*(?:#.*)?$/u);
+    if (numberMatch) {
+      values[numberMatch[1]] = Number(numberMatch[2]);
     }
   }
   return values;
 }
 
-async function getExistingCodexApiConfig() {
-  const content = await pathExists(codexConfigPath) ? await readFile(codexConfigPath, "utf8") : "";
-  const auth = await readJsonFileSafe(codexAuthPath, {});
+function stripCodexSubagentDefaults(content) {
+  const lineEnding = detectLineEnding(content);
+  let nextContent = removeTopLevelTomlField(content, "approvals_reviewer");
+  nextContent = removeTopLevelTomlField(nextContent, "developer_instructions");
+  nextContent = removeTomlSection(nextContent, "agents");
+
+  const featureValues = parseTomlSection(nextContent, "features");
+  delete featureValues.multi_agent;
+  delete featureValues.guardian_approval;
+  nextContent = removeTomlSection(nextContent, "features");
+
+  if (Object.keys(featureValues).length) {
+    const featuresSection = buildTomlSection("features", featureValues, lineEnding).trimEnd();
+    nextContent = nextContent.trimEnd()
+      ? `${nextContent.trimEnd()}${lineEnding}${lineEnding}${featuresSection}${lineEnding}`
+      : `${featuresSection}${lineEnding}`;
+  }
+
+  return nextContent;
+}
+
+function mergeCodexTemplateDefaults(content, templateContent) {
+  const defaultTopLevelFields = new Set([
+    "personality",
+    "disable_response_storage",
+    "approvals_reviewer",
+    "approval_policy",
+    "sandbox_mode",
+    "service_tier",
+    "model",
+    "model_reasoning_effort",
+    "developer_instructions"
+  ]);
+  const templateEntries = extractTopLevelTomlEntries(templateContent)
+    .filter(({ field }) => defaultTopLevelFields.has(field));
+  let nextContent = mergeMissingTopLevelTomlEntries(content, templateEntries);
+
+  for (const sectionName of ["agents", "features"]) {
+    const templateValues = parseTomlSection(templateContent, sectionName);
+    const currentValues = parseTomlSection(nextContent, sectionName);
+    const missingValues = Object.fromEntries(
+      Object.entries(templateValues).filter(([field]) => !(field in currentValues))
+    );
+    if (Object.keys(missingValues).length) {
+      nextContent = updateTomlSectionFields(nextContent, sectionName, missingValues);
+    }
+  }
+
+  return nextContent;
+}
+
+async function loadBundledCodexConfigTemplate() {
+  return readFile(codexTemplateConfigPath, "utf8");
+}
+
+async function deployBundledCodexAgents() {
+  const targetDir = join(home, ".codex", "agents");
+  await mkdir(targetDir, { recursive: true });
+  const entries = (await readdir(codexTemplateAgentsPath, { withFileTypes: true }))
+    .filter((entry) => entry.isFile() && entry.name.endsWith(".toml"))
+    .map((entry) => entry.name)
+    .sort((left, right) => left.localeCompare(right));
+
+  const deployed = [];
+  for (const name of entries) {
+    const source = join(codexTemplateAgentsPath, name);
+    const target = join(targetDir, name);
+    await backupExistingPath(target);
+    await cp(source, target, { force: true });
+    deployed.push(target);
+  }
+  return deployed;
+}
+
+function getDefaultCodexEnvKey(providerId) {
+  return `${providerId.toUpperCase().replace(/-/gu, "_")}_API_KEY`;
+}
+
+function resolveExistingCodexApiConfig(content, auth = {}) {
   const providerId = readTopLevelTomlString(content, "model_provider") || "abelworkflow";
   const provider = parseTomlSection(content, `model_providers.${providerId}`);
-  const envKey = provider.temp_env_key || "OPENAI_API_KEY";
+  const requiresOpenAiAuth = provider.requires_openai_auth !== false;
+  const configuredEnvKey = provider.temp_env_key || "";
+  const defaultEnvKey = requiresOpenAiAuth ? "OPENAI_API_KEY" : getDefaultCodexEnvKey(providerId);
+  const envKey = configuredEnvKey || defaultEnvKey;
+  const apiKeyCandidates = [
+    configuredEnvKey,
+    envKey,
+    defaultEnvKey,
+    "OPENAI_API_KEY"
+  ].filter(Boolean);
+  const apiKeyMatch = apiKeyCandidates.find((key) => typeof auth[key] === "string" && auth[key]);
+  const apiKey = apiKeyMatch ? auth[apiKeyMatch] : "";
+
   return {
     providerId,
-    providerName: provider.name || (providerId === "abelworkflow" ? "AbelWorkflow" : providerId),
+    providerName: provider.name || providerId,
     baseUrl: provider.base_url || "https://api.openai.com/v1",
     envKey,
-    apiKey: auth[envKey] || ""
+    legacyEnvKeys: configuredEnvKey && configuredEnvKey !== envKey ? [configuredEnvKey] : [],
+    apiKey
   };
 }
 
+async function getExistingCodexApiConfig() {
+  const content = await pathExists(codexConfigPath) ? await readFile(codexConfigPath, "utf8") : "";
+  const auth = await readJsonFileSafe(codexAuthPath, {});
+  return resolveExistingCodexApiConfig(content, auth);
+}
+
 async function configureCodexApi() {
   const existing = await getExistingCodexApiConfig();
   const providerId = existing.providerId || "abelworkflow";
-  const providerName = existing.providerName || "AbelWorkflow";
+  const providerName = existing.providerName || providerId;
   const baseUrl = await promptText("Codex Base URL", {
     defaultValue: existing.baseUrl
   });
   const apiKey = await promptSecret("Codex 第三方 API Key", {
     defaultValue: existing.apiKey || undefined
   });
-  const envKey = `${providerId.toUpperCase().replace(/-/gu, "_")}_API_KEY`;
+  const shouldDeploySubagents = await promptConfirm("是否部署 Codex subagents 配置？", true);
+  const envKey = existing.envKey || "OPENAI_API_KEY";
+  const currentContent = await pathExists(codexConfigPath) ? await readFile(codexConfigPath, "utf8") : "";
+  const templateContent = await loadBundledCodexConfigTemplate();
+  const content = buildCodexConfigContent(currentContent, {
+    templateContent,
+    mergeMissingTemplateDefaults: true,
+    includeSubagentDefaults: shouldDeploySubagents,
+    providerId,
+    providerName,
+    baseUrl,
+    envKey
+  });
 
-  let content = await pathExists(codexConfigPath) ? await readFile(codexConfigPath, "utf8") : "";
+  await backupExistingPath(codexConfigPath);
+  await mkdir(dirname(codexConfigPath), { recursive: true });
+  await writeFile(codexConfigPath, content, "utf8");
+
+  const auth = mergeCodexAuthData(await readJsonFileSafe(codexAuthPath, {}), envKey, apiKey, existing.legacyEnvKeys || []);
+  await writeJsonFileWithBackup(codexAuthPath, auth);
+
+  console.log(`已更新 ${pathToLabel(codexConfigPath)} (${providerId}, ${baseUrl})`);
+  console.log(`已更新 ${pathToLabel(codexAuthPath)} (${maskSecret(apiKey)})`);
+  if (shouldDeploySubagents) {
+    const deployed = await deployBundledCodexAgents();
+    console.log(`已部署 ${deployed.length} 个 Codex subagents 到 ${pathToLabel(join(home, ".codex", "agents"))}`);
+  } else {
+    console.log("已跳过 Codex subagents 部署。");
+  }
+}
+
+function buildCodexConfigContent(currentContent, {
+  templateContent = "",
+  mergeMissingTemplateDefaults = false,
+  includeSubagentDefaults = true,
+  providerId,
+  providerName,
+  baseUrl,
+  envKey
+}) {
+  const effectiveTemplateContent = includeSubagentDefaults
+    ? templateContent
+    : stripCodexSubagentDefaults(templateContent);
+  const hasCurrentContent = Boolean(currentContent.trim());
+  let content = hasCurrentContent ? currentContent : effectiveTemplateContent;
+  if (!includeSubagentDefaults && hasCurrentContent) {
+    content = stripCodexSubagentDefaults(content);
+  }
+  if (hasCurrentContent && mergeMissingTemplateDefaults && effectiveTemplateContent.trim()) {
+    content = mergeCodexTemplateDefaults(content, effectiveTemplateContent);
+  }
   const lineEnding = detectLineEnding(content);
+  if (includeSubagentDefaults && readTopLevelTomlString(content, "approvals_reviewer") === "guardian_subagent") {
+    content = updateTopLevelTomlField(content, "approvals_reviewer", "reviewer");
+  }
   content = updateTopLevelTomlField(content, "model_provider", providerId);
-  content = removeTomlSection(content, `model_providers.${providerId}`);
-  content = `${content.trimEnd() ? `${content.trimEnd()}${lineEnding}${lineEnding}` : ""}${buildTomlSection(`model_providers.${providerId}`, {
+  content = updateTopLevelTomlField(content, "preferred_auth_method", "apikey");
+  content = updateTomlSectionFields(content, `model_providers.${providerId}`, {
     name: providerName,
     base_url: baseUrl,
     wire_api: "responses",
     temp_env_key: envKey,
     requires_openai_auth: true
-  }, lineEnding)}`;
-
-  await mkdir(dirname(codexConfigPath), { recursive: true });
-  await writeFile(codexConfigPath, `${content.trim()}${lineEnding}`, "utf8");
-
-  const auth = await readJsonFileSafe(codexAuthPath, {});
-  auth[envKey] = apiKey;
-  await writeJsonFileSafe(codexAuthPath, auth);
+  });
+  return `${content.trim()}${lineEnding}`;
+}
 
-  console.log(`已更新 ${pathToLabel(codexConfigPath)} (${providerId}, ${baseUrl})`);
-  console.log(`已更新 ${pathToLabel(codexAuthPath)} (${maskSecret(apiKey)})`);
+function mergeCodexAuthData(auth, envKey, apiKey, legacyEnvKeys = []) {
+  const nextAuth = auth && typeof auth === "object" ? { ...auth } : {};
+  for (const key of legacyEnvKeys) {
+    if (key && key !== envKey) {
+      delete nextAuth[key];
+    }
+  }
+  nextAuth[envKey] = apiKey;
+  return nextAuth;
 }
 
 async function installCliTool(tool) {
@@ -1577,7 +2034,21 @@ async function main() {
   await runInteractiveMenu(options);
 }
 
-main().catch((error) => {
-  console.error(error instanceof Error ? error.message : String(error));
-  process.exit(1);
-});
+export {
+  buildCodexConfigContent,
+  getRunCommandSpawnOptions,
+  main,
+  mergeCodexAuthData,
+  mergeClaudeSettingsWithDefaults,
+  resolveExistingCodexApiConfig,
+  updateTomlSectionFields
+};
+
+const isDirectExecution = process.argv[1] ? resolve(process.argv[1]) === __filename : false;
+
+if (isDirectExecution) {
+  main().catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}