@volc-emr/emr-cli 0.1.0-beta.1 → 0.1.0-beta.2

package/README.md

@@ -1,335 +1,147 @@
-# volc-emr-agent
+# emr-cli
 
-> 一个 **可控、可审计、可 dry-run** 的 Volcengine EMR CLI Agent。
->
-> Tool-first · Plan → Execute · LLM Planner（可选）· 真实 OpenAPI 调用 · 本地凭证 / 偏好记忆。
+一个面向 Volcengine EMR 的 CLI Agent。
 
-你用一句自然语言描述任务（例如"列出所有运行中的集群"、"清理一周前已关停的集群"、"帮我建一个 3.7.0 的 Hadoop 集群"），Agent 会：
+它把自然语言任务拆成 `Plan -> Execute`，再调用真实 OpenAPI 执行，适合本地开发和命令行运维场景。
 
-1. 由 LLM 生成一份结构化 `Plan`
-2. 高风险步骤前弹确认（或 `-y` 跳过）
-3. 交由 Executor 依次调用 Tool
-4. Tool 用 Zod 校验 LLM 输入 → 调用真实 EMR OpenAPI → 把结果写回 stdout
-5. 创建集群这类复合 Tool，会**再次**交互式向你追问缺失字段并回填常用默认值
+## 功能
 
----
+- 自然语言执行 EMR 任务
+- 支持 `dry-run` 查看计划
+- 高风险操作执行前确认
+- 本地保存 Volcengine 凭证和 LLM 配置
+- 当前内置 `listClusters`、`deleteCluster`、`createCluster`
 
-## 已对接的 EMR OpenAPI（Version=2023-08-15）
+## 环境要求
 
-| Tool | OpenAPI Action | 风险级别 | 说明 |
-|---|---|---|---|
-| `listClusters` | [ListClusters](https://www.volcengine.com/docs/6491/1208305) | low | 支持全字段过滤 / 分页 / 中文状态别名归一化 |
-| `findClustersToCleanup` | ListClusters | low | 组合查询：超过 N 天 + 处于 SHUTDOWN 类状态 |
-| `deleteCluster` | [ReleaseCluster](https://www.volcengine.com/docs/6491/1208304) | **high** | 自动识别归档 / 已释放 / 不存在 → 幂等跳过而非中断 |
-| `createCluster` | [CreateCluster](https://www.volcengine.com/docs/6491/1208307) | **high** | 交互式补全 13 类必填字段、PRE/POST 计费分支、节点组向导 |
-
----
+- Node.js `>= 18`
+- 一个兼容 OpenAI Chat Completions 的 LLM 接口
 
 ## 安装
 
+全局安装：
+
 ```bash
-# 通过 npm 全局安装（推荐）
 npm install -g @volc-emr/emr-cli@beta
-
-# 验证（CLI 命令名仍是 volc-emr-agent）
-volc-emr-agent --help
+emr-cli --help
 ```
 
-或者本地开发模式：
+本地开发：
 
 ```bash
-git clone <repo>
-cd console-cli
 npm install
 npm run build
-npm link        # 注册 `volc-emr-agent` 到 PATH
+npm link
+emr-cli --help
 ```
 
-**环境要求**：Node.js ≥ 18
+## 快速开始
 
----
-
-## 快速上手（三步）
+初始化配置：
 
 ```bash
-# 1) 初始化：填 AK/SK、地域，可选一起填 LLM
-volc-emr-agent init
-
-# 2) 跑第一条命令（只打印 Plan，不执行）
-volc-emr-agent run "列出所有运行中的集群" --dry-run
-
-# 3) 真正执行
-volc-emr-agent run "列出所有运行中的集群"
+emr-cli init
 ```
 
----
-
-## 凭证与配置
-
-优先级统一为：**CLI 参数 > 环境变量 > 本地配置文件**。
-
-### 本地配置文件位置
-
-| 文件 | 内容 | 权限 |
-|---|---|---|
-| `~/.volc-emr/config.json` | Volcengine AK/SK/Region + LLM endpoint/apiKey/model | `0600` |
-| `~/.volc-emr/create-cluster-memory.json` | 创建集群向导的常用偏好（VPC/子网/可用区/机型等） | `0600` |
-
-可通过 `VOLC_EMR_CONFIG_DIR` 环境变量整体改位置（测试 / 多环境友好）。
-
-### 写配置
+配置 LLM：
 
 ```bash
-# 交互式向导（支持同时配 LLM）
-volc-emr-agent init
-
-# 已有配置？加 --force 跳过确认
-volc-emr-agent init --force
-
-# 非交互（CI 友好）
-volc-emr-agent init \
-  --access-key "$VOLC_ACCESSKEY" \
-  --secret-key "$VOLC_SECRETKEY" \
-  --region cn-beijing
-
-# 单独写凭证
-volc-emr-agent config set-credentials \
-  --access-key xxx --secret-key yyy --region cn-beijing
-
-# 单独写 LLM
-volc-emr-agent config set-llm \
+emr-cli config set-llm \
   --endpoint https://ark.cn-beijing.volces.com/api/v3/chat/completions \
-  --api-key ark-xxx \
-  --model doubao-seed-character-251128
+  --api-key <your-api-key> \
+  --model <your-model>
 ```
 
-### 环境变量
+查看执行计划：
 
 ```bash
-export VOLC_ACCESSKEY=xxx
-export VOLC_SECRETKEY=yyy
-export VOLC_REGION=cn-beijing
-
-# LLM（可选；未配置时 Planner 会直接报错，不做 rule-based 兜底）
-export VOLC_LLM_ENDPOINT=https://ark.cn-beijing.volces.com/api/v3/chat/completions
-export VOLC_LLM_API_KEY=ark-xxx
-export VOLC_LLM_MODEL=doubao-seed-character-251128
+emr-cli run "列出所有运行中的集群" --dry-run
 ```
 
-### 查看 / 重定向
+直接执行：
 
 ```bash
-# 查看已保存的本地配置（secrets 自动脱敏）
-volc-emr-agent config show
-
-# 改用自定义目录
-VOLC_EMR_CONFIG_DIR=/tmp/volc-test volc-emr-agent init
+emr-cli run "列出所有运行中的集群"
+emr-cli run "清理一周前已关停的集群" -y
+emr-cli run "帮我创建一个 3.7.0 的 Hadoop 集群"
 ```
 
----
+## 命令
 
-## 运行示例
+| 命令                               | 说明                            |
+|----------------------------------|-------------------------------|
+| `emr-cli init`                   | 交互式写入 AK/SK、Region 和可选 LLM 配置 |
+| `emr-cli run <task>`             | 执行一条自然语言任务                    |
+| `emr-cli config set-credentials` | 单独写入凭证                        |
+| `emr-cli config set-llm`         | 单独写入 LLM 配置                   |
+| `emr-cli config show`            | 查看当前本地配置                      |
 
-### 列出集群
+常用选项：
 
-```bash
-volc-emr-agent run "列出所有运行中的集群"
-volc-emr-agent run "列出 cn-beijing 最近创建的 10 个 Hadoop 集群"
-```
+- `--dry-run`：只生成计划，不执行
+- `-y, --yes`：自动确认高风险操作
+- `--region <region>`：临时覆盖区域
 
-### 清理老集群
-
-```bash
-# 看 Plan、不执行
-volc-emr-agent run "清理一周前已关停的集群" --dry-run
+## 配置
 
-# 批量执行（自动确认所有 high-risk 步骤）
-volc-emr-agent run "清理一周前已关停的集群" -y
+优先级：
 
-# 自定义天数
-volc-emr-agent run "清理 14 天前已关停的集群"
-```
+`CLI 参数 > 环境变量 > 本地配置文件`
 
-> 已被 EMR 归档（`marked archived`）的集群会被自动识别并**跳过**，不会让整个清理流程中断。
+默认配置文件：
 
-### 创建集群（交互式向导）
+- `~/.volc-emr/config.json`
+- `~/.volc-emr/create-cluster-memory.json`
 
-```bash
-volc-emr-agent run "帮我创建一个 3.7.0 的 Hadoop 集群"
-```
+可通过 `VOLC_EMR_CONFIG_DIR` 修改配置目录。
 
-LLM 会先从你的描述里预填能猜到的字段（`ClusterType=Hadoop, ReleaseVersion=3.7.0`），Tool 接着启动向导：
+环境变量示例：
 
+```bash
+export VOLC_ACCESSKEY=xxx
+export VOLC_SECRETKEY=yyy
+export VOLC_REGION=cn-beijing
+export VOLC_LLM_ENDPOINT=https://ark.cn-beijing.volces.com/api/v3/chat/completions
+export VOLC_LLM_API_KEY=ark-xxx
+export VOLC_LLM_MODEL=your-model
 ```
-=== 创建 EMR 集群：补全配置 ===
-(已加载上次记忆，路径: /Users/you/.volc-emr/create-cluster-memory.json)
-
-集群类型 (可选: Hadoop / Presto / ...) [Hadoop]: ⏎
-集群版本 (ReleaseVersion) [3.7.0]: ⏎
-集群名称 [OpenApiHadoop3.7.0-a7x2m]: ⏎
-付费类型 (可选: POST / PRE) [POST]: ⏎
-VpcId (如 vpc-xxx) [vpc-abc123]: ⏎          ← 来自上次记忆
-SecurityGroupId (如 sg-xxx) [sg-def456]: ⏎  ← 来自上次记忆
-可用区 ZoneId [cn-beijing-b]: ⏎
-
--- 节点组配置 (共 2 组) --
-[节点组 1]
-节点组类型 (可选: MASTER / CORE / TASK / GATEWAY) [MASTER]: ⏎
-  节点数 [3]: ⏎
-  SubnetIds (逗号分隔) [subnet-xyz]: ⏎
-  EcsInstanceTypes [ecs.g3i.2xlarge]: ⏎
-...
-
-=== 即将创建集群，配置如下 ===
-{ ...完整 JSON... }
-确认使用以上配置创建集群? (y/n): y
-
-(已更新常用默认值记忆: /Users/you/.volc-emr/create-cluster-memory.json)
-✓ 集群创建成功: ClusterId=emr-xxx, OperationId=op-xxx
-```
-
-**特性**：
-
-- **记忆**：用户确认后立刻写 `create-cluster-memory.json`。即使 OpenAPI 随后返回错误，下次依然能复用你填过的网络/节点偏好，不用再填一遍
-- **中文状态 / 大小写自动归一化**：LLM 写成 "已关停" / "Running" 都能被翻译成官方枚举
-- **MASTER + CORE 自动补齐**：Hadoop 类集群强制至少两个节点组
-- **ChargeType=PRE 自动展开包年包月子向导**（周期 / 自动续费）
-
----
-
-## 命令总览
-
-| 命令 | 作用 |
-|---|---|
-| `volc-emr-agent init [--force]` | 交互式写入 AK/SK、可选一起配 LLM |
-| `volc-emr-agent config set-credentials --access-key ... --secret-key ...` | 单独更新凭证 |
-| `volc-emr-agent config set-llm --endpoint ... [--api-key ...] [--model ...]` | 单独更新 LLM |
-| `volc-emr-agent config show` | 查看本地配置（脱敏） |
-| `volc-emr-agent run <task> [--dry-run] [-y] [--region ...]` | 执行一条自然语言任务 |
-
-运行选项：
-
-- `--dry-run`：只打印 Plan，不调用任何 OpenAPI
-- `-y, --yes`：对 `riskLevel: "high"` 的 Tool 自动确认
-- `--region <region>`：临时覆盖当前会话的区域（不写配置）
-
----
 
-## 目录结构
+## 当前结构
 
-```
+```text
 src/
-├── index.ts                      # CLI 入口（commander）
+├── index.ts
 ├── agent/
-│   ├── agent.ts                  # 对外 Agent.run(task, options)
-│   ├── planner.ts                # LLM-only Planner，无 LLM 时直接报错
-│   ├── llmPlanner.ts             # 把 Zod 输入翻成 JSON Schema 喂给 LLM
-│   ├── executor.ts               # 依次执行 Plan，触发高风险确认
-│   └── types.ts
+├── commands/
+├── runtime/
 ├── services/
-│   ├── volcApi.ts                # @volcengine/openapi 签名 + 错误解析
-│   └── emrApi.ts                 # listClusters / releaseCluster / createCluster ...
 ├── tools/
-│   ├── base.ts                   # Tool 定义 (name/description/input/riskLevel/execute)
-│   ├── registry.ts               # 聚合所有业务 Tool + API
-│   └── emr/
-│       ├── index.ts
-│       ├── listClusters.ts
-│       ├── findClustersToCleanup.ts
-│       ├── deleteCluster.ts      # → ReleaseCluster
-│       └── createCluster.ts      # 交互式向导 + 记忆
-├── runtime/
-│   ├── config.ts                 # AK/SK + LLM 持久化
-│   ├── createClusterMemory.ts    # 创建集群专用的偏好记忆（独立文件）
-│   ├── confirm.ts                # TTY / pipe 双模安全的 prompt
-│   ├── llm.ts                    # OpenAI-compatible Chat Completions 客户端
-│   ├── memory.ts                 # 进程内简易 KV
-│   └── logger.ts
-└── utils/prompt.ts
+│   └── ecs/
+└── utils/
 ```
 
----
-
-## 关键设计
-
-### 1. Tool-first
+目录职责：
 
-所有业务能力都是 Tool（`name / description / input (Zod) / riskLevel / execute`）。LLM 看到的只有 Tool 目录（由 `zod-to-json-schema` 自动生成），**不能直接执行副作用**。
+- `src/index.ts`：CLI 入口
+- `src/commands`：命令注册，当前包含 `run`、`init`、`config`
+- `src/agent`：规划与执行流程
+- `src/tools/ecs`：EMR 相关工具实现
+- `src/services`：OpenAPI 调用封装
+- `src/runtime`：配置、日志、交互和本地记忆
 
-### 2. Plan → Execute 分离
+## 开发
 
+```bash
+npm run build
+npm run typecheck
+node dist/index.js --help
 ```
-用户自然语言
-   ↓
-Planner（LLM, Zod 校验）→ PlanStep[]
-   ↓
-Executor（读 registry, 拦截 high-risk, 调用 Tool）
-   ↓
-真实 Volcengine OpenAPI
-```
-
-### 3. 枚举三层防御（以 `ClusterStates` 为例）
-
-- **Schema 层**：Tool input 用 `z.nativeEnum(EmrClusterState)`，LLM 收到带 `enum` 的 JSON Schema
-- **Prompt 层**：Tool description 里显式印合法枚举清单
-- **执行层**：Tool `execute()` 内部再做一次大小写 + 中文别名兜底
-
-### 4. OpenAPI 错误可读化
-
-[volcApi.ts](src/services/volcApi.ts) 对火山返回做结构化解析，错误消息会带 `Code / RequestId / body` 等排障必需的上下文，而不是一句干巴巴的 `Internal error`。
-
-### 5. 记忆分文件，互不污染
-
-- `config.json`：**身份**（AK/SK、LLM token）。敏感，少变。
-- `create-cluster-memory.json`：**偏好**（VPC/子网/ZoneId/机型）。常变，可分享模板。
-
-写入时机在 **确认后立刻写**（而不是 API 成功后），哪怕 OpenAPI 挂了，你下次也不用重填网络信息。
-
----
-
-## LLM 配置提示
-
-Planner 要求必须配置 LLM（OpenAI-compatible `/chat/completions`）。已验证可用的：
-
-- **火山方舟 Ark**：
-  ```
-  endpoint: https://ark.cn-beijing.volces.com/api/v3/chat/completions
-  model:    doubao-seed-character-251128（或其他 doubao 模型）
-  ```
-- **OpenAI 官方**：
-  ```
-  endpoint: https://api.openai.com/v1/chat/completions
-  model:    gpt-4o-mini
-  ```
-- **任何兼容 OpenAI 协议的网关**（Together / Groq / Fireworks / 本地 vLLM 等）
-
-如果模型不支持 `response_format=json_object`，Planner 会退化到 "字符串 JSON + markdown fence 清洗" 的 robust 模式，无需额外改配置。
-
----
-
-## 故障排查
-
-| 现象 | 原因 / 处理 |
-|---|---|
-| `[ListClusters] The request is missing Version parameter` | `@volcengine/openapi` 需要 `Version` 而非 `version` — 现已修好 |
-| `[ListClusters] Invalid request {0}` | LLM 传了非法字段或类型，Tool 层错误消息会附上 body 预览 |
-| `[CreateCluster] Internal error` | 5xx；抓取 `RequestId` 后去[火山工单](https://console.volcengine.com/workorder/create/)，或用相同参数在 [API Explorer](https://api.volcengine.com/api-explorer/?action=CreateCluster&serviceCode=emr&version=2023-08-15) 复现 |
-| `LLM is not configured` | Planner 没有 rule-based 兜底，请先 `volc-emr-agent config set-llm` |
-| 清理时个别集群报 `marked archived` | 会被 `deleteCluster` 内部捕获，返回 `{ Skipped: true, Reason: "ARCHIVED" }` 并作为该步 `Done` 结果打印，不影响其它集群清理 |
-
-想看更详细的请求/响应？可以临时编辑 [volcApi.ts](src/services/volcApi.ts) 在 `fetchApi(body)` 前后加 `console.error` 打印 body 和 response。
-
----
-
-## 后续规划
 
-- [ ] 支持 `CreateCluster` 的 `--config file.json` 无交互模式（CI 友好）
-- [ ] 更多 EMR Action：`GetCluster` / `ScaleOutNodeGroup` / `UpdateClusterAttribute`
-- [ ] 多 profile 记忆（`--profile prod/test`）
-- [ ] Tool catalog 热插拔、跨业务目录（非 EMR）
-- [ ] Executor 级别的 retry / rollback / 流式输出
+## 说明
 
----
+- `run` 依赖 LLM 生成执行计划；未配置 LLM 时不会回退到规则模式
+- `createCluster` 会进入交互式补全流程，并复用本地记忆
+- `deleteCluster` 会对部分已归档或已释放场景做跳过处理
 
 ## License
 

package/dist/agent/executor.js

@@ -4,18 +4,52 @@ exports.executePlan = executePlan;
 const registry_1 = require("../tools/registry");
 const confirm_1 = require("../runtime/confirm");
 const logger_1 = require("../runtime/logger");
+function renderToolNotices(notices) {
+    for (const notice of notices || []) {
+        if (notice.type === "message") {
+            if (notice.level === "warn")
+                logger_1.ui.warn(notice.text);
+            else if (notice.level === "success")
+                logger_1.ui.success(notice.text);
+            else if (notice.level === "dim")
+                logger_1.ui.dim(notice.text);
+            else
+                logger_1.ui.info(notice.text);
+            continue;
+        }
+        logger_1.ui.kv(notice.key, notice.value);
+    }
+}
 async function executePlan(plan, ctx, options = {}) {
+    ctx.memory["__lastToolName"] = undefined;
+    ctx.memory["__lastToolResult"] = undefined;
     logger_1.ui.section(`Execute (${plan.length} step${plan.length > 1 ? "s" : ""})`);
-    for (const [i, step] of plan.entries()) {
-        const tool = registry_1.toolList.find((t) => t.name === step.tool);
+    for (let i = 0; i < plan.length; i++) {
+        let step = plan[i];
+        let tool = registry_1.toolList.find((t) => t.name === step.tool);
         if (!tool) {
             (0, logger_1.logStep)(i, "fail", step.tool, { error: "Tool not found" });
             throw new Error(`Tool not found: ${step.tool}`);
         }
+        if (tool.prepareStep) {
+            const prepared = await tool.prepareStep(step, ctx);
+            if (prepared) {
+                renderToolNotices(prepared.notices);
+                if (prepared.action === "skip") {
+                    (0, logger_1.logStep)(i, "skip", tool.name, { reason: prepared.reason });
+                    continue;
+                }
+                if (prepared.steps && prepared.steps.length > 0) {
+                    plan.splice(i, 1, ...prepared.steps);
+                    i--;
+                    continue;
+                }
+            }
+        }
         if (tool.riskLevel === "high") {
             const ok = options.autoApprove
                 ? true
-                : await (0, confirm_1.confirm)(`⚠ 执行高风险 Tool: ${tool.name} ${JSON.stringify(step.input)}`);
+                : await (0, confirm_1.confirm)(tool.formatRiskConfirmMessage?.(step.input || {}) || `⚠ 执行高风险 Tool: ${tool.name} ${JSON.stringify(step.input)}`);
             if (!ok) {
                 (0, logger_1.logStep)(i, "skip", tool.name, { reason: "user cancelled" });
                 continue;
@@ -24,6 +58,8 @@ async function executePlan(plan, ctx, options = {}) {
         (0, logger_1.logStep)(i, "run", tool.name, { input: step.input });
         try {
             const result = await tool.execute(step.input, ctx);
+            ctx.memory["__lastToolName"] = tool.name;
+            ctx.memory["__lastToolResult"] = result;
             (0, logger_1.logStep)(i, "done", tool.name, { output: result });
         }
         catch (err) {

package/dist/agent/llmPlanner.js

@@ -3,7 +3,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.llmPlanTask = llmPlanTask;
 const zod_to_json_schema_1 = require("zod-to-json-schema");
 const registry_1 = require("../tools/registry");
-const emr_1 = require("../tools/emr");
 const llm_1 = require("../runtime/llm");
 function buildToolCatalog() {
     return registry_1.toolList.map((t) => ({
@@ -31,7 +30,9 @@ function buildSystemPrompt() {
         "- Only use tools listed above.",
         "- `input` MUST conform to each tool's inputSchema.",
         "- For destructive actions (riskLevel=high), only plan them if the user task clearly asks for it.",
-        "- If the task is ambiguous, return at most one safe, read-only step (e.g. listClusters)."
+        "- If the task is ambiguous, return at most one safe, read-only step (e.g. listClusters).",
+        "- For batch cleanup, first plan listClusters with filters, then plan deleteCluster with {\"FromPreviousList\":true}.",
+        "- Never generate deleteCluster tasks for clusters in `TERMINATED` state; that state means the cluster is archived and ReleaseCluster is not supported."
     ].join("\n");
 }
 function buildUserPrompt(task, context) {
@@ -113,19 +114,5 @@ async function llmPlanTask(task, llm) {
     ];
     const content = await (0, llm_1.chatCompletion)(llm, { messages });
     const steps = tryParsePlan(content);
-    const validated = validatePlanAgainstTools(steps);
-    const expanded = [];
-    for (const step of validated) {
-        expanded.push(step);
-        if (step.tool === "findClustersToCleanup") {
-            const found = await emr_1.emrApi.findClustersToCleanup(step.input || {});
-            for (const c of found) {
-                expanded.push({
-                    tool: "deleteCluster",
-                    input: { ClusterId: c.ClusterId }
-                });
-            }
-        }
-    }
-    return expanded;
+    return validatePlanAgainstTools(steps);
 }

package/dist/commands/config.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerConfigCommand = registerConfigCommand;
+const config_1 = require("../runtime/config");
+const logger_1 = require("../runtime/logger");
+function registerConfigCommand(program) {
+    const config = program.command("config").description("Manage local credentials");
+    config
+        .command("set-credentials")
+        .description("Save AK/SK/region to local config (~/.volc-emr/config.json)")
+        .requiredOption("--access-key <ak>")
+        .requiredOption("--secret-key <sk>")
+        .option("--region <region>", "default cn-beijing", "cn-beijing")
+        .action((opts) => {
+        const file = (0, config_1.writeLocalConfig)({
+            accessKey: opts.accessKey,
+            secretKey: opts.secretKey,
+            region: opts.region
+        });
+        logger_1.ui.success(`Credentials saved: ${file}`);
+    });
+    config
+        .command("set-llm")
+        .description("Save LLM endpoint config to local config")
+        .requiredOption("--endpoint <url>", "OpenAI-compatible Chat Completions URL")
+        .option("--api-key <key>")
+        .option("--model <model>")
+        .action((opts) => {
+        const file = (0, config_1.writeLocalConfig)({
+            llm: {
+                endpoint: opts.endpoint,
+                apiKey: opts.apiKey,
+                model: opts.model
+            }
+        });
+        logger_1.ui.success(`LLM config saved: ${file}`);
+    });
+    config
+        .command("show")
+        .description("Show current local config (secrets are masked)")
+        .action(() => {
+        const cfg = (0, config_1.readLocalConfig)();
+        logger_1.ui.section("Local config");
+        logger_1.ui.kv("file", (0, config_1.configFilePath)());
+        logger_1.ui.kv("accessKey", cfg.accessKey ? `${cfg.accessKey.slice(0, 4)}****` : "(missing)");
+        logger_1.ui.kv("secretKey", cfg.secretKey ? "********" : "(missing)");
+        logger_1.ui.kv("region", cfg.region || "(missing)");
+        if (cfg.llm?.endpoint) {
+            logger_1.ui.kv("llm.endpoint", cfg.llm.endpoint);
+            logger_1.ui.kv("llm.apiKey", cfg.llm.apiKey ? "********" : "(missing)");
+            logger_1.ui.kv("llm.model", cfg.llm.model || "(missing)");
+        }
+        else {
+            logger_1.ui.kv("llm", "(not configured)");
+        }
+    });
+}

package/dist/commands/init.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerInitCommand = registerInitCommand;
+const config_1 = require("../runtime/config");
+const confirm_1 = require("../runtime/confirm");
+const logger_1 = require("../runtime/logger");
+function registerInitCommand(program) {
+    program
+        .command("init")
+        .description("Interactive wizard to initialize local credentials")
+        .option("--access-key <ak>", "Non-interactive access key")
+        .option("--secret-key <sk>", "Non-interactive secret key")
+        .option("--region <region>", "Default region", "cn-beijing")
+        .option("--llm-endpoint <url>", "Optional LLM endpoint (OpenAI compatible)")
+        .option("--llm-api-key <key>", "Optional LLM API key")
+        .option("--llm-model <model>", "Optional LLM model name")
+        .option("-f, --force", "Overwrite existing config without asking")
+        .action(async (opts) => {
+        const existing = (0, config_1.readLocalConfig)();
+        const hasExisting = !!(existing.accessKey || existing.secretKey);
+        if (hasExisting && !opts.force) {
+            logger_1.ui.info(`Detected existing config: ${(0, config_1.configFilePath)()}`);
+            const ok = await (0, confirm_1.confirm)("Overwrite existing credentials?");
+            if (!ok) {
+                logger_1.ui.warn("Cancelled. No changes made.");
+                return;
+            }
+        }
+        const needInteractive = !opts.accessKey || !opts.secretKey;
+        const session = needInteractive ? (0, confirm_1.createPromptSession)() : null;
+        try {
+            const accessKey = opts.accessKey ||
+                (await session.ask("VOLC Access Key", {
+                    defaultValue: existing.accessKey
+                }));
+            if (!accessKey) {
+                logger_1.ui.error("Access key is required.");
+                process.exitCode = 1;
+                return;
+            }
+            const secretKey = opts.secretKey ||
+                (await session.ask("VOLC Secret Key", { silent: true }));
+            if (!secretKey) {
+                logger_1.ui.error("Secret key is required.");
+                process.exitCode = 1;
+                return;
+            }
+            const region = opts.region ||
+                (session
+                    ? await session.ask("Region", {
+                        defaultValue: existing.region || "cn-beijing"
+                    })
+                    : existing.region || "cn-beijing") ||
+                "cn-beijing";
+            const llmEndpoint = opts.llmEndpoint ??
+                (session
+                    ? await session.ask("LLM endpoint (empty to skip)", {
+                        defaultValue: existing.llm?.endpoint || ""
+                    })
+                    : existing.llm?.endpoint || "");
+            let llmApiKey = opts.llmApiKey;
+            let llmModel = opts.llmModel;
+            if (llmEndpoint && session) {
+                llmApiKey =
+                    llmApiKey ??
+                        (await session.ask("LLM API key", { silent: true }));
+                llmModel =
+                    llmModel ??
+                        (await session.ask("LLM model", {
+                            defaultValue: existing.llm?.model || ""
+                        }));
+            }
+            const payload = { accessKey, secretKey, region };
+            if (llmEndpoint) {
+                payload.llm = {
+                    endpoint: llmEndpoint,
+                    apiKey: llmApiKey || existing.llm?.apiKey,
+                    model: llmModel || existing.llm?.model
+                };
+            }
+            const file = (0, config_1.writeLocalConfig)(payload);
+            logger_1.ui.success(`Saved to ${file}`);
+            logger_1.ui.kv("accessKey", `${accessKey.slice(0, 4)}****`);
+            logger_1.ui.kv("secretKey", "********");
+            logger_1.ui.kv("region", region);
+            if (llmEndpoint) {
+                logger_1.ui.kv("llm.endpoint", llmEndpoint);
+                if (payload.llm.apiKey)
+                    logger_1.ui.kv("llm.apiKey", "********");
+                if (payload.llm.model)
+                    logger_1.ui.kv("llm.model", payload.llm.model);
+            }
+            else {
+                logger_1.ui.kv("llm", "(not configured)");
+            }
+            logger_1.ui.dim(`Tip: run \`emr-cli run "列出集群"\` to verify.`);
+        }
+        finally {
+            session?.close();
+        }
+    });
+}