abelworkflow 0.6.5 → 0.7.0

package/lib/cli.mjs

@@ -3,17 +3,22 @@ import { cp, link, lstat, mkdir, readFile, readdir, readlink, realpath, rename,
 import { homedir } from "node:os";
 import { dirname, join, relative, resolve } from "node:path";
 import { stdin as input, stdout as output } from "node:process";
-import { createInterface } from "node:readline/promises";
 import { fileURLToPath } from "node:url";
+import * as p from "@clack/prompts";
+import c from "picocolors";
 import {
   assertInteractiveMenuSupported,
+  assertNotCancelled,
+  CancelledError,
+  confirmOrCancel,
   getRunCommandSpawnOptions,
   interactiveMenuDefaultValue,
   interactiveMenuDescriptors,
   parseArgs,
-  resolvePromptValue,
-  resolveSelectValue,
-  shouldUseVisibleSecretFallback
+  required,
+  requiredUnlessExisting,
+  resolvePasswordValue,
+  selectOrCancel
 } from "./cli/logic.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
@@ -99,19 +104,21 @@ const ignoredSkillPathPatterns = [
 ];
 
 function printHelp() {
-  console.log(`AbelWorkflow installer
-
-Usage:
-  npx abelworkflow
-  npx abelworkflow init
-  npx abelworkflow install
-  npx abelworkflow install --force
-  npx abelworkflow install --link-only
-  npx abelworkflow install --agents-dir /custom/path
-
-Default behavior:
+  console.log(`${c.bold("AbelWorkflow")} ${c.cyan("installer")}
+
+${c.bold("Usage:")}
+  ${c.cyan("npx abelworkflow")}
+  ${c.cyan("npx abelworkflow init")}
+  ${c.cyan("npx abelworkflow install")}
+  ${c.cyan("npx abelworkflow install --force")}
+  ${c.cyan("npx abelworkflow install --link-only")}
+  ${c.cyan("npx abelworkflow install --agents-dir /custom/path")}
+  ${c.cyan("npx abelworkflow --non-interactive")}
+
+${c.bold("Default behavior:")}
   - npx abelworkflow: open the interactive setup menu.
   - npx abelworkflow install: sync managed files and links explicitly.
+  - --non-interactive: auto-execute install (skip interactive menu); auto-enabled in CI.
 `);
 }
 
@@ -178,18 +185,18 @@ async function backupExistingPath(targetPath) {
   const backupPath = await createBackupPath(targetPath);
   await cp(targetPath, backupPath, { recursive: true, force: false });
   createdBackupPaths.add(targetPath);
-  console.log(`已备份已有配置: ${pathToLabel(targetPath)} -> ${pathToLabel(backupPath)}`);
+  p.log.message(`已备份已有配置: ${pathToLabel(targetPath)} -> ${pathToLabel(backupPath)}`);
   return backupPath;
 }
 
-async function backupIfNeeded(targetPath, force) {
+async function backupIfNeeded(targetPath) {
   if (!(await pathExists(targetPath))) {
     return null;
   }
 
   const backupPath = await createBackupPath(targetPath);
   await rename(targetPath, backupPath);
-  console.log(`已备份已有配置: ${pathToLabel(targetPath)} -> ${pathToLabel(backupPath)}`);
+  p.log.message(`已备份已有配置: ${pathToLabel(targetPath)} -> ${pathToLabel(backupPath)}`);
   return backupPath;
 }
 
@@ -449,7 +456,7 @@ async function createSymlink(targetPath, sourcePath, linkType, kind) {
   await symlink(sourcePath, targetPath, linkType);
 }
 
-async function ensureManagedLink(targetPath, sourcePath, kind, force, previousLinkedTargets) {
+async function ensureManagedLink(targetPath, sourcePath, kind, previousLinkedTargets) {
   await mkdir(dirname(targetPath), { recursive: true });
   const sourceResolved = resolve(sourcePath);
   const sourceExists = await pathTargetExists(sourcePath);
@@ -487,7 +494,7 @@ async function ensureManagedLink(targetPath, sourcePath, kind, force, previousLi
     if (wasPreviouslyManaged) {
       await rm(targetPath, { recursive: true, force: true });
     } else {
-      await backupIfNeeded(targetPath, force);
+      await backupIfNeeded(targetPath);
     }
   } else if (!sourceExists) {
     return { targetPath, status: "skipped" };
@@ -525,7 +532,7 @@ function shouldCopyManagedFile(error) {
   return ["EPERM", "EACCES", "EXDEV", "EINVAL", "UNKNOWN"].includes(error?.code);
 }
 
-async function linkSkillDirectories(baseDir, agentsDir, force, previousLinkedTargets) {
+async function linkSkillDirectories(baseDir, agentsDir, previousLinkedTargets) {
   const results = [];
   const skillsRoot = join(agentsDir, "skills");
   const skillNames = (await getDirectoryNames(skillsRoot)).filter((skillName) => skillName !== ".system");
@@ -536,7 +543,6 @@ async function linkSkillDirectories(baseDir, agentsDir, force, previousLinkedTar
         join(baseDir, "skills", skillName),
         join(skillsRoot, skillName),
         "dir",
-        force,
         previousLinkedTargets
       )
     );
@@ -664,19 +670,7 @@ function isWithinManagedRoot(targetPath, managedSourceRoot) {
   return relativePath !== ".." && !relativePath.startsWith(`..${isWindows() ? "\\" : "/"}`);
 }
 
-function getResultMarker(status) {
-  if (status === "unchanged") {
-    return "=";
-  }
-
-  if (status === "removed") {
-    return "-";
-  }
-
-  return "+";
-}
-
-async function linkClaude(agentsDir, force, previousLinkedTargets) {
+async function linkClaude(agentsDir, previousLinkedTargets) {
   const claudeDir = join(home, ".claude");
   await mkdir(claudeDir, { recursive: true });
   await removeIfNotDirectory(join(claudeDir, "commands"));
@@ -689,21 +683,19 @@ async function linkClaude(agentsDir, force, previousLinkedTargets) {
       join(claudeDir, "CLAUDE.md"),
       join(agentsDir, "AGENTS.md"),
       "file",
-      force,
       previousLinkedTargets
     ),
     await ensureManagedLink(
       join(claudeDir, "commands", "oc"),
       join(agentsDir, "commands", "oc"),
       "dir",
-      force,
       previousLinkedTargets
     ),
-    ...(await linkSkillDirectories(claudeDir, agentsDir, force, previousLinkedTargets))
+    ...(await linkSkillDirectories(claudeDir, agentsDir, previousLinkedTargets))
   ];
 }
 
-async function linkCodex(agentsDir, force, previousLinkedTargets) {
+async function linkCodex(agentsDir, previousLinkedTargets) {
   const results = [];
   const codexDir = join(home, ".codex");
   await mkdir(codexDir, { recursive: true });
@@ -717,11 +709,10 @@ async function linkCodex(agentsDir, force, previousLinkedTargets) {
       join(codexDir, "AGENTS.md"),
       join(agentsDir, "AGENTS.md"),
       "file",
-      force,
       previousLinkedTargets
     )
   );
-  results.push(...(await linkSkillDirectories(codexDir, agentsDir, force, previousLinkedTargets)));
+  results.push(...(await linkSkillDirectories(codexDir, agentsDir, previousLinkedTargets)));
 
   const commandFiles = await getCommandNames(join(agentsDir, "commands", "oc"));
   results.push(
@@ -738,7 +729,6 @@ async function linkCodex(agentsDir, force, previousLinkedTargets) {
         join(codexDir, "prompts", fileName),
         join(agentsDir, "commands", "oc", fileName),
         "file",
-        force,
         previousLinkedTargets
       )
     );
@@ -750,9 +740,17 @@ async function linkCodex(agentsDir, force, previousLinkedTargets) {
 async function installManagedWorkflow(options) {
   let previousMetadata = {};
   let managedChildren = {};
+  const s = p.spinner();
 
   if (!options.relinkOnly) {
-    ({ previousMetadata, managedChildren } = await syncManagedFiles(options.agentsDir));
+    s.start("正在同步工作流文件...");
+    try {
+      ({ previousMetadata, managedChildren } = await syncManagedFiles(options.agentsDir));
+    } catch (e) {
+      s.cancel(c.red(`同步失败: ${e.message}`));
+      throw e;
+    }
+    s.stop("工作流文件已同步");
   } else if (!(await pathExists(options.agentsDir))) {
     throw new Error(`${options.agentsDir} does not exist; remove --link-only or install first`);
   } else {
@@ -761,8 +759,18 @@ async function installManagedWorkflow(options) {
   }
 
   const previousLinkedTargets = previousMetadata.linkedTargets ?? {};
-  const claudeResults = await linkClaude(options.agentsDir, options.force, previousLinkedTargets);
-  const codexResults = await linkCodex(options.agentsDir, options.force, previousLinkedTargets);
+  s.start("正在链接 Claude / Codex...");
+  let claudeResults;
+  let codexResults;
+  try {
+    claudeResults = await linkClaude(options.agentsDir, previousLinkedTargets);
+    codexResults = await linkCodex(options.agentsDir, previousLinkedTargets);
+  } catch (e) {
+    s.cancel(c.red(`链接失败: ${e.message}`));
+    throw e;
+  }
+  s.stop("链接完成");
+
   const linkedTargets = Object.fromEntries(
     [...claudeResults, ...codexResults]
       .filter((result) => result.sourcePath)
@@ -783,14 +791,16 @@ async function installManagedWorkflow(options) {
     linkedTargets
   });
 
-  console.log(`Installed AbelWorkflow into ${options.agentsDir}`);
-  console.log("");
-  console.log("Linked targets:");
-  for (const result of [...claudeResults, ...codexResults]) {
-    console.log(`- ${getResultMarker(result.status)} ${result.targetPath}`);
-  }
-  console.log("");
-  console.log("Done. Re-run `npx abelworkflow@latest` to update the managed files.");
+  const resultLines = [...claudeResults, ...codexResults].map((result) => {
+    const icon = result.status === "unchanged" ? c.gray("=")
+      : result.status === "removed" ? c.yellow("−")
+        : c.green("+");
+    return `${icon}  ${pathToLabel(result.targetPath)}`;
+  }).join("\n");
+
+  p.note(resultLines, "链接结果");
+  p.log.step(`工作流目录: ${c.cyan(pathToLabel(options.agentsDir))}`);
+  p.log.message(`完成后可运行 ${c.cyan("npx abelworkflow@latest")} 更新托管文件`);
 }
 
 async function readJsonFileSafe(path, fallback = {}) {
@@ -882,121 +892,6 @@ async function updateDotenvFile(path, updates) {
   await writeFile(path, renderDotenv(current), "utf8");
 }
 
-function currentChoiceIndex(choices, defaultValue) {
-  if (defaultValue === undefined) {
-    return -1;
-  }
-  return choices.findIndex((choice) => choice.value === defaultValue);
-}
-
-async function setTerminalEcho(enabled) {
-  if (!input.isTTY || isWindows()) {
-    return;
-  }
-
-  const result = spawnSync("stty", [enabled ? "echo" : "-echo"], { stdio: ["inherit", "ignore", "ignore"] });
-  if (result.error) {
-    throw result.error;
-  }
-}
-
-async function promptText(message, options = {}) {
-  const { defaultValue, allowEmpty = false } = options;
-
-  while (true) {
-    const suffix = defaultValue !== undefined && defaultValue !== ""
-      ? ` [${defaultValue}]`
-      : "";
-    const rl = createInterface({ input, output });
-    let answer;
-    try {
-      answer = await rl.question(`${message}${suffix}: `);
-    } finally {
-      rl.close();
-    }
-
-    const resolved = resolvePromptValue(answer, { defaultValue, allowEmpty });
-    if (resolved.ok) {
-      return resolved.value;
-    }
-    console.log(resolved.error);
-  }
-}
-
-async function promptSecret(message, options = {}) {
-  const { defaultValue, allowEmpty = false } = options;
-
-  if (shouldUseVisibleSecretFallback({ inputIsTTY: input.isTTY, platform: getPlatform() })) {
-    while (true) {
-      const suffix = defaultValue !== undefined && defaultValue !== ""
-        ? " [直接回车保留现有值]"
-        : "";
-      const rl = createInterface({ input, output });
-      let answer;
-      try {
-        answer = await rl.question(`${message}${suffix}: `);
-      } finally {
-        rl.close();
-      }
-
-      const resolved = resolvePromptValue(answer, { defaultValue, allowEmpty });
-      if (resolved.ok) {
-        return resolved.value;
-      }
-      console.log(resolved.error);
-    }
-  }
-
-  while (true) {
-    const suffix = defaultValue !== undefined && defaultValue !== ""
-      ? " [直接回车保留现有值]"
-      : "";
-    const rl = createInterface({ input, output, terminal: true });
-    let answer;
-    try {
-      await setTerminalEcho(false);
-      answer = await rl.question(`${message}${suffix}: `);
-      output.write("\n");
-    } finally {
-      await setTerminalEcho(true);
-      rl.close();
-    }
-
-    const resolved = resolvePromptValue(answer, { defaultValue, allowEmpty });
-    if (resolved.ok) {
-      return resolved.value;
-    }
-    console.log(resolved.error);
-  }
-}
-
-async function promptSelect(message, choices, options = {}) {
-  const defaultIndex = currentChoiceIndex(choices, options.defaultValue);
-  console.log(`\n${message}`);
-  choices.forEach((choice, index) => {
-    const defaultMarker = index === defaultIndex ? " [默认]" : "";
-    console.log(`  ${index + 1}. ${choice.label}${defaultMarker}`);
-  });
-
-  while (true) {
-    const fallbackValue = defaultIndex >= 0 ? String(defaultIndex + 1) : undefined;
-    const answer = await promptText("请输入序号", { defaultValue: fallbackValue, allowEmpty: defaultIndex >= 0 });
-    const resolved = resolveSelectValue(answer, choices);
-    if (resolved.ok) {
-      return resolved.value;
-    }
-    console.log(resolved.error);
-  }
-}
-
-async function promptConfirm(message, defaultValue = true) {
-  const value = await promptSelect(message, [
-    { value: true, label: "是" },
-    { value: false, label: "否" }
-  ], { defaultValue });
-  return value;
-}
-
 function commandExists(command) {
   const checker = isWindows() ? "where" : "which";
   const result = spawnSync(checker, [command], { stdio: "ignore" });
@@ -1017,22 +912,12 @@ async function runCommand(command, args) {
   });
 }
 
-function sanitizeProviderId(name) {
-  return name
-    .trim()
-    .toLowerCase()
-    .replace(/[\s.]+/gu, "-")
-    .replace(/[^a-z0-9_-]/gu, "")
-    .replace(/-+/gu, "-")
-    .replace(/^-|-$/gu, "") || "abelworkflow";
-}
-
 async function ensureWorkflowPresent(agentsDir) {
   if (await pathExists(join(agentsDir, "AGENTS.md"))) {
     return;
   }
 
-  console.log("未检测到已安装的 AbelWorkflow，先执行一次工作流同步。");
+  p.log.message("未检测到已安装的 AbelWorkflow，先执行一次工作流同步。");
   await installManagedWorkflow({
     agentsDir,
     force: false,
@@ -1044,101 +929,139 @@ async function configureGrokSearchEnv(agentsDir) {
   await ensureWorkflowPresent(agentsDir);
   const envPath = join(agentsDir, "skills", "grok-search", ".env");
   const existing = await readDotenvFile(envPath);
-  const baseUrl = await promptText("Grok API URL", {
-    defaultValue: existing.GROK_API_URL || "https://api.x.ai/v1"
+  const baseUrl = await p.text({
+    message: "Grok API URL",
+    defaultValue: existing.GROK_API_URL || "https://api.x.ai/v1",
+    validate: required()
   });
-  const apiKey = await promptSecret("Grok API Key", {
-    defaultValue: existing.GROK_API_KEY || undefined
+  assertNotCancelled(baseUrl);
+
+  const apiKey = await p.password({
+    message: "Grok API Key（输入 - 清除）",
+    mask: "*",
+    defaultValue: existing.GROK_API_KEY || undefined,
+    validate: requiredUnlessExisting(existing.GROK_API_KEY, "Grok API Key 不能为空")
   });
-  const model = await promptText("Grok 默认模型", {
-    defaultValue: existing.GROK_MODEL || "grok-4-fast"
+  assertNotCancelled(apiKey);
+  const finalApiKey = resolvePasswordValue(apiKey, existing.GROK_API_KEY);
+
+  const model = await p.text({
+    message: "Grok 默认模型",
+    defaultValue: existing.GROK_MODEL || "grok-4-fast",
+    validate: required()
+  });
+  assertNotCancelled(model);
+
+  const useTavily = await confirmOrCancel({
+    message: "是否同时配置 Tavily 作为额外搜索源？",
+    initialValue: Boolean(existing.TAVILY_API_KEY)
   });
-  const useTavily = await promptConfirm("是否同时配置 Tavily 作为额外搜索源？", Boolean(existing.TAVILY_API_KEY));
+
   const tavilyKey = useTavily
-    ? await promptSecret("Tavily API Key", { defaultValue: existing.TAVILY_API_KEY || undefined })
+    ? await p.password({
+        message: "Tavily API Key（输入 - 清除）",
+        mask: "*",
+        defaultValue: existing.TAVILY_API_KEY || undefined,
+        validate: requiredUnlessExisting(existing.TAVILY_API_KEY, "Tavily API Key 不能为空")
+      })
     : "";
+  if (useTavily) assertNotCancelled(tavilyKey);
+  const finalTavilyKey = useTavily ? resolvePasswordValue(tavilyKey, existing.TAVILY_API_KEY) : null;
 
   await updateDotenvFile(envPath, {
     GROK_API_URL: baseUrl,
-    GROK_API_KEY: apiKey,
+    GROK_API_KEY: finalApiKey,
     GROK_MODEL: model,
-    TAVILY_API_KEY: useTavily ? tavilyKey : null,
+    TAVILY_API_KEY: finalTavilyKey,
     TAVILY_ENABLED: useTavily ? "true" : null
   });
 
-  console.log(`已写入 ${pathToLabel(envPath)}`);
+  p.log.step(`已写入 ${pathToLabel(envPath)}`);
 }
 
 async function configureContext7Env(agentsDir) {
   await ensureWorkflowPresent(agentsDir);
   const envPath = join(agentsDir, "skills", "context7-auto-research", ".env");
   const existing = await readDotenvFile(envPath);
-  const apiKey = await promptSecret("Context7 API Key", {
-    defaultValue: existing.CONTEXT7_API_KEY || undefined,
-    allowEmpty: true
+  const apiKey = await p.password({
+    message: "Context7 API Key (可选，输入 - 清除)",
+    mask: "*",
+    defaultValue: existing.CONTEXT7_API_KEY || undefined
   });
+  assertNotCancelled(apiKey);
+  const finalApiKey = resolvePasswordValue(apiKey, existing.CONTEXT7_API_KEY);
 
   await updateDotenvFile(envPath, {
-    CONTEXT7_API_KEY: apiKey || null
+    CONTEXT7_API_KEY: finalApiKey
   });
 
-  console.log(`已写入 ${pathToLabel(envPath)}`);
+  p.log.step(`已写入 ${pathToLabel(envPath)}`);
+}
+
+function hasPromptEnhancerApiConfig(config) {
+  return [config.PE_API_URL, config.PE_API_KEY, config.PE_MODEL]
+    .every((value) => typeof value === "string" && value.trim() !== "");
 }
 
 function resolvePromptEnhancerMode(existing) {
-  if (existing.ANTHROPIC_API_KEY) {
-    return "anthropic";
-  }
-  if (existing.OPENAI_API_KEY) {
-    return "openai";
-  }
-  return "local";
+  return hasPromptEnhancerApiConfig(existing) ? "openai-compatible" : "agent";
 }
 
 async function configurePromptEnhancerEnv(agentsDir) {
   await ensureWorkflowPresent(agentsDir);
   const envPath = join(agentsDir, "skills", "prompt-enhancer", ".env");
   const existing = await readDotenvFile(envPath);
-  const mode = await promptSelect("请选择 prompt-enhancer 使用的提供方", [
-    { value: "anthropic", label: "Anthropic 兼容 Key" },
-    { value: "openai", label: "OpenAI 兼容 Key" },
-    { value: "local", label: "仅保留本地模板兜底，不写 API Key" }
-  ], { defaultValue: resolvePromptEnhancerMode(existing) });
-
-  if (mode === "anthropic") {
-    const apiKey = await promptSecret("ANTHROPIC_API_KEY", {
-      defaultValue: existing.ANTHROPIC_API_KEY || undefined
-    });
-    const model = await promptText("PE_MODEL", {
-      defaultValue: existing.PE_MODEL || "claude-sonnet-4-20250514"
-    });
+  const mode = await selectOrCancel({
+    message: "请选择 prompt-enhancer 的运行方式",
+    options: [
+      { value: "openai-compatible", label: "第三方 OpenAI 兼容接口" },
+      { value: "agent", label: "直接使用当前 Agent" }
+    ],
+    initialValue: resolvePromptEnhancerMode(existing)
+  });
 
-    await updateDotenvFile(envPath, {
-      ANTHROPIC_API_KEY: apiKey,
-      OPENAI_API_KEY: null,
-      PE_MODEL: model
+  if (mode === "openai-compatible") {
+    const apiUrl = await p.text({
+      message: "PE_API_URL",
+      defaultValue: existing.PE_API_URL || undefined,
+      validate: required()
     });
-  } else if (mode === "openai") {
-    const apiKey = await promptSecret("OPENAI_API_KEY", {
-      defaultValue: existing.OPENAI_API_KEY || undefined
+    assertNotCancelled(apiUrl);
+
+    const apiKey = await p.password({
+      message: "PE_API_KEY（输入 - 清除）",
+      mask: "*",
+      defaultValue: existing.PE_API_KEY || undefined,
+      validate: requiredUnlessExisting(existing.PE_API_KEY, "PE_API_KEY 不能为空")
     });
-    const model = await promptText("PE_MODEL", {
-      defaultValue: existing.PE_MODEL || "gpt-4o"
+    assertNotCancelled(apiKey);
+    const finalApiKey = resolvePasswordValue(apiKey, existing.PE_API_KEY);
+
+    const model = await p.text({
+      message: "PE_MODEL",
+      defaultValue: existing.PE_MODEL || undefined,
+      validate: required()
     });
+    assertNotCancelled(model);
 
     await updateDotenvFile(envPath, {
-      OPENAI_API_KEY: apiKey,
+      PE_API_URL: apiUrl,
+      PE_API_KEY: finalApiKey,
+      PE_MODEL: model,
       ANTHROPIC_API_KEY: null,
-      PE_MODEL: model
+      OPENAI_API_KEY: null
     });
   } else {
     await updateDotenvFile(envPath, {
+      PE_API_URL: null,
+      PE_API_KEY: null,
+      PE_MODEL: null,
       ANTHROPIC_API_KEY: null,
       OPENAI_API_KEY: null
     });
   }
 
-  console.log(`已写入 ${pathToLabel(envPath)}`);
+  p.log.step(`已写入 ${pathToLabel(envPath)}`);
 }
 
 function mergeClaudeSettingsWithDefaults(settings) {
@@ -1198,28 +1121,46 @@ function ensureApprovedClaudeApiKey(config, apiKey) {
 async function configureClaudeApi() {
   const settings = await readJsonFileSafe(claudeSettingsPath, {});
   const existing = getExistingClaudeApiConfig(settings);
-  const authType = await promptSelect("Claude Code 第三方 API 认证方式", [
-    { value: "api_key", label: "API Key" },
-    { value: "auth_token", label: "Auth Token" }
-  ], { defaultValue: existing.authType });
-  const baseUrl = await promptText("Claude Code Base URL", {
-    defaultValue: existing.baseUrl
+  const authType = await selectOrCancel({
+    message: "Claude Code 第三方 API 认证方式",
+    options: [
+      { value: "api_key", label: "API Key" },
+      { value: "auth_token", label: "Auth Token" }
+    ],
+    initialValue: existing.authType
   });
-  const key = await promptSecret(authType === "auth_token" ? "Claude Code Auth Token" : "Claude Code API Key", {
-    defaultValue: existing.key || undefined
+
+  const baseUrl = await p.text({
+    message: "Claude Code Base URL",
+    defaultValue: existing.baseUrl,
+    validate: required()
+  });
+  assertNotCancelled(baseUrl);
+
+  const key = await p.password({
+    message: authType === "auth_token" ? "Claude Code Auth Token（输入 - 清除）" : "Claude Code API Key（输入 - 清除）",
+    mask: "*",
+    defaultValue: existing.key || undefined,
+    validate: requiredUnlessExisting(existing.key, "API Key / Auth Token 不能为空")
   });
-  const model = await promptText("Claude Code 模型", {
-    defaultValue: existing.model || undefined
+  assertNotCancelled(key);
+  const finalKey = resolvePasswordValue(key, existing.key);
+
+  const model = await p.text({
+    message: "Claude Code 模型",
+    defaultValue: existing.model || undefined,
+    validate: required()
   });
+  assertNotCancelled(model);
 
   const nextSettings = mergeClaudeSettingsWithDefaults(settings);
   nextSettings.env.ANTHROPIC_BASE_URL = baseUrl;
 
   if (authType === "auth_token") {
-    nextSettings.env.ANTHROPIC_AUTH_TOKEN = key;
+    nextSettings.env.ANTHROPIC_AUTH_TOKEN = finalKey;
     delete nextSettings.env.ANTHROPIC_API_KEY;
   } else {
-    nextSettings.env.ANTHROPIC_API_KEY = key;
+    nextSettings.env.ANTHROPIC_API_KEY = finalKey;
     delete nextSettings.env.ANTHROPIC_AUTH_TOKEN;
   }
   for (const field of claudeModelEnvKeys) {
@@ -1230,10 +1171,10 @@ async function configureClaudeApi() {
 
   const metaConfig = await readJsonFileSafe(claudeMetaConfigPath, {});
   metaConfig.hasCompletedOnboarding = true;
-  ensureApprovedClaudeApiKey(metaConfig, key);
+  ensureApprovedClaudeApiKey(metaConfig, finalKey);
   await writeJsonFileWithBackup(claudeMetaConfigPath, metaConfig);
 
-  console.log(`已更新 ${pathToLabel(claudeSettingsPath)} (${authType}, ${baseUrl}, ${maskSecret(key)})`);
+  p.log.step(`已更新 ${pathToLabel(claudeSettingsPath)} (${authType}, ${baseUrl}, ${maskSecret(finalKey)})`);
 }
 
 function updateTopLevelTomlField(content, field, value) {
@@ -1723,13 +1664,24 @@ async function configureCodexApi() {
   const existing = await getExistingCodexApiConfig();
   const providerId = existing.providerId || "abelworkflow";
   const providerName = existing.providerName || providerId;
-  const baseUrl = await promptText("Codex Base URL", {
-    defaultValue: existing.baseUrl
+  const baseUrl = await p.text({
+    message: "Codex Base URL",
+    defaultValue: existing.baseUrl,
+    validate: required()
   });
-  const apiKey = await promptSecret("Codex 第三方 API Key", {
-    defaultValue: existing.apiKey || undefined
+  assertNotCancelled(baseUrl);
+
+  const apiKey = await p.password({
+    message: "Codex 第三方 API Key（输入 - 清除）",
+    mask: "*",
+    defaultValue: existing.apiKey || undefined,
+    validate: requiredUnlessExisting(existing.apiKey, "API Key 不能为空")
   });
-  const shouldDeploySubagents = await promptConfirm("是否部署 Codex subagents 配置？", true);
+  assertNotCancelled(apiKey);
+  const finalApiKey = resolvePasswordValue(apiKey, existing.apiKey);
+
+  const shouldDeploySubagents = await confirmOrCancel({ message: "是否部署 Codex subagents 配置？", initialValue: true });
+
   const envKey = existing.envKey || "OPENAI_API_KEY";
   const currentContent = await pathExists(codexConfigPath) ? await readFile(codexConfigPath, "utf8") : "";
   const templateContent = await loadBundledCodexConfigTemplate();
@@ -1747,16 +1699,16 @@ async function configureCodexApi() {
   await mkdir(dirname(codexConfigPath), { recursive: true });
   await writeFile(codexConfigPath, content, "utf8");
 
-  const auth = mergeCodexAuthData(await readJsonFileSafe(codexAuthPath, {}), envKey, apiKey, existing.legacyEnvKeys || []);
+  const auth = mergeCodexAuthData(await readJsonFileSafe(codexAuthPath, {}), envKey, finalApiKey, existing.legacyEnvKeys || []);
   await writeJsonFileWithBackup(codexAuthPath, auth);
 
-  console.log(`已更新 ${pathToLabel(codexConfigPath)} (${providerId}, ${baseUrl})`);
-  console.log(`已更新 ${pathToLabel(codexAuthPath)} (${maskSecret(apiKey)})`);
+  p.log.step(`已更新 ${pathToLabel(codexConfigPath)} (${providerId}, ${baseUrl})`);
+  p.log.step(`已更新 ${pathToLabel(codexAuthPath)} (${maskSecret(finalApiKey)})`);
   if (shouldDeploySubagents) {
     const deployed = await deployBundledCodexAgents();
-    console.log(`已部署 ${deployed.length} 个 Codex subagents 到 ${pathToLabel(join(home, ".codex", "agents"))}`);
+    p.log.step(`已部署 ${deployed.length} 个 Codex subagents 到 ${pathToLabel(join(home, ".codex", "agents"))}`);
   } else {
-    console.log("已跳过 Codex subagents 部署。");
+    p.log.message("已跳过 Codex subagents 部署。");
   }
 }
 
@@ -1827,16 +1779,25 @@ async function installCliTool(tool) {
 
   const installed = commandExists(toolConfig.command);
   if (installed) {
-    const shouldUpdate = await promptConfirm(`${toolConfig.label} 已检测到，是否继续执行 npm 强制安装/更新？`, false);
+    const shouldUpdate = await confirmOrCancel({
+      message: `${toolConfig.label} 已检测到，是否继续执行 npm 强制安装/更新？`,
+      initialValue: false
+    });
     if (!shouldUpdate) {
-      console.log(`跳过 ${toolConfig.label} 安装。`);
+      p.log.message(`跳过 ${toolConfig.label} 安装。`);
       return;
     }
   }
 
-  console.log(`开始安装 ${toolConfig.label}...`);
-  await runCommand("npm", ["install", "-g", toolConfig.packageName, "--force"]);
-  console.log(`${toolConfig.label} 安装完成。`);
+  const s = p.spinner();
+  s.start(`正在安装 ${toolConfig.label}...`);
+  try {
+    await runCommand("npm", ["install", "-g", toolConfig.packageName, "--force"]);
+    s.stop(`${toolConfig.label} 安装完成`);
+  } catch (e) {
+    s.cancel(c.red(`${toolConfig.label} 安装失败: ${e.message}`));
+    throw e;
+  }
 }
 
 async function runFullInit(options) {
@@ -1846,36 +1807,35 @@ async function runFullInit(options) {
     relinkOnly: false
   });
 
-  if (await promptConfirm("是否安装或更新 Claude Code CLI？", false)) {
+  if (await confirmOrCancel({ message: "是否安装或更新 Claude Code CLI？", initialValue: false })) {
     await installCliTool("claude");
   }
-  if (await promptConfirm("是否配置 Claude Code 第三方 API？", commandExists("claude"))) {
+  if (await confirmOrCancel({ message: "是否配置 Claude Code 第三方 API？", initialValue: commandExists("claude") })) {
     await configureClaudeApi();
   }
-  if (await promptConfirm("是否安装或更新 Codex CLI？", false)) {
+  if (await confirmOrCancel({ message: "是否安装或更新 Codex CLI？", initialValue: false })) {
     await installCliTool("codex");
   }
-  if (await promptConfirm("是否配置 Codex 第三方 API？", commandExists("codex"))) {
+  if (await confirmOrCancel({ message: "是否配置 Codex 第三方 API？", initialValue: commandExists("codex") })) {
     await configureCodexApi();
   }
-  if (await promptConfirm("是否填写 grok-search 环境变量？", true)) {
+  if (await confirmOrCancel({ message: "是否填写 grok-search 环境变量？", initialValue: false })) {
     await configureGrokSearchEnv(options.agentsDir);
   }
-  if (await promptConfirm("是否填写 context7-auto-research 环境变量？", true)) {
+  if (await confirmOrCancel({ message: "是否填写 context7-auto-research 环境变量？", initialValue: false })) {
     await configureContext7Env(options.agentsDir);
   }
-  if (await promptConfirm("是否填写 prompt-enhancer 环境变量？", true)) {
+  if (await confirmOrCancel({ message: "是否填写 prompt-enhancer 环境变量？", initialValue: false })) {
     await configurePromptEnhancerEnv(options.agentsDir);
   }
 
-  console.log("\nAbelWorkflow 完整初始化完成。");
+  p.log.success(c.green("AbelWorkflow 完整初始化完成"));
 }
 
 async function runInteractiveMenu(options) {
-  console.log("AbelWorkflow Setup");
-  console.log(`工作流目录: ${pathToLabel(options.agentsDir)}`);
+  p.intro(c.bold(c.bgCyan(c.black(" AbelWorkflow Setup "))));
+  p.log.message(`工作流目录: ${c.cyan(pathToLabel(options.agentsDir))}`);
 
-  const menuChoices = interactiveMenuDescriptors.map(({ value, label }) => ({ value, label }));
   const menuActions = {
     "full-init": async () => runFullInit(options),
     install: async () => installManagedWorkflow({
@@ -1892,14 +1852,63 @@ async function runInteractiveMenu(options) {
     "codex-api": async () => configureCodexApi()
   };
 
+  const buildOption = (d) => {
+    const opt = { value: d.value, label: d.label };
+    if (d.hint) {
+      opt.hint = d.hint;
+    }
+    return opt;
+  };
+
   while (true) {
-    const choice = await promptSelect("请选择操作", menuChoices, { defaultValue: interactiveMenuDefaultValue });
-    const descriptor = interactiveMenuDescriptors.find((item) => item.value === choice);
-    if (descriptor?.value === "exit") {
+    const selectOptions = [
+      ...interactiveMenuDescriptors
+        .filter((d) => d.group === "main")
+        .map(buildOption),
+      { value: "__sep_skills__", label: "─── 技能配置 ───", disabled: true },
+      ...interactiveMenuDescriptors
+        .filter((d) => d.group === "skill")
+        .map(buildOption),
+      { value: "__sep_cli__", label: "─── CLI 工具 ───", disabled: true },
+      ...interactiveMenuDescriptors
+        .filter((d) => d.group === "cli")
+        .map(buildOption),
+      { value: "__sep_exit__", label: "────────────────", disabled: true },
+      ...interactiveMenuDescriptors
+        .filter((d) => d.group === "exit")
+        .map(buildOption)
+    ];
+
+    const choice = await p.select({
+      message: "请选择操作",
+      options: selectOptions,
+      initialValue: interactiveMenuDefaultValue
+    });
+
+    if (p.isCancel(choice)) {
+      p.outro(c.gray("已退出"));
+      return;
+    }
+    if (choice === "exit") {
+      p.outro(c.gray("已退出"));
       return;
     }
 
-    await menuActions[descriptor.value]();
+    const action = menuActions[choice];
+    if (!action) {
+      p.log.warn(`未知菜单选项: ${choice}`);
+      continue;
+    }
+
+    try {
+      await action();
+    } catch (error) {
+      if (error instanceof CancelledError) {
+        p.log.warn("操作已取消，返回菜单");
+        continue;
+      }
+      throw error;
+    }
   }
 }
 
@@ -1914,26 +1923,57 @@ async function main() {
     return;
   }
 
+  // 非交互模式下菜单命令自动回退为 install
+  if (options.command === "menu" && options.nonInteractive) {
+    console.log("检测到非交互模式，自动执行工作流安装...");
+    options.command = "install";
+  }
+
   if (options.command === "install") {
-    await installManagedWorkflow(options);
+    try {
+      await installManagedWorkflow(options);
+    } catch (error) {
+      const message = `操作失败: ${error.message || String(error)}`;
+      // 非交互模式输出纯文本便于日志捕获/管道处理；交互模式使用 clack 格式化输出
+      if (options.nonInteractive) {
+        console.error(message);
+      } else {
+        p.outro(c.red(message));
+      }
+      process.exit(1);
+    }
     return;
   }
 
   assertInteractiveMenuSupported({
     command: options.command,
     inputIsTTY: input.isTTY,
-    outputIsTTY: output.isTTY
+    outputIsTTY: output.isTTY,
+    nonInteractive: options.nonInteractive
   });
 
-  await runInteractiveMenu(options);
+  try {
+    await runInteractiveMenu(options);
+  } catch (error) {
+    const message = `操作失败: ${error.message || String(error)}`;
+    // 非交互模式输出纯文本便于日志捕获/管道处理；交互模式使用 clack 格式化输出
+    if (options.nonInteractive) {
+      console.error(message);
+    } else {
+      p.outro(c.red(message));
+    }
+    process.exit(1);
+  }
 }
 
 export {
   buildCodexConfigContent,
   getRunCommandSpawnOptions,
+  hasPromptEnhancerApiConfig,
   main,
   mergeCodexAuthData,
   mergeClaudeSettingsWithDefaults,
+  resolvePromptEnhancerMode,
   resolveExistingCodexApiConfig,
   updateTomlSectionFields
 };