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

package/dist/commands/run.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerRunCommand = registerRunCommand;
+const agent_1 = require("../agent/agent");
+const registry_1 = require("../tools/registry");
+const memory_1 = require("../runtime/memory");
+const config_1 = require("../runtime/config");
+const logger_1 = require("../runtime/logger");
+function registerRunCommand(program) {
+    program
+        .command("run <task>")
+        .description("Plan and execute a natural language EMR task")
+        .option("--dry-run", "Only show plan")
+        .option("-y, --yes", "Auto approve high-risk tools (skip confirm)")
+        .option("--region <region>", "Override region, default cn-beijing")
+        .action(async (task, opts) => {
+        if (opts.accessKey)
+            process.env.VOLC_ACCESSKEY = opts.accessKey;
+        if (opts.secretKey)
+            process.env.VOLC_SECRETKEY = opts.secretKey;
+        if (opts.region)
+            process.env.VOLC_REGION = opts.region;
+        try {
+            const creds = (0, config_1.resolveCredentials)();
+            const cfg = (0, config_1.readLocalConfig)();
+            logger_1.ui.dim(`region=${creds.region}  llm=${cfg.llm?.endpoint ? "configured" : "not configured"}`);
+            const agent = new agent_1.Agent({
+                api: registry_1.apiRegistry,
+                memory: memory_1.memory
+            });
+            await agent.run(task, {
+                dryRun: opts.dryRun,
+                autoApprove: opts.yes
+            });
+        }
+        catch (err) {
+            logger_1.ui.error(err?.message || String(err));
+            process.exitCode = 1;
+        }
+    });
+}

package/dist/core/agent.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = void 0;
+const planner_1 = require("./planner");
+const executor_1 = require("./executor");
+const logger_1 = require("../shared/logger");
+class Agent {
+    constructor(ctx) {
+        this.ctx = ctx;
+    }
+    async run(task, options = {}) {
+        logger_1.ui.section(`Task`);
+        logger_1.ui.info(task);
+        const plan = await (0, planner_1.planTask)(task);
+        logger_1.ui.section(`Plan (${plan.length} step${plan.length > 1 ? "s" : ""})`);
+        plan.forEach((step, i) => {
+            logger_1.ui.raw(`  ${i + 1}. ${step.tool}`);
+            if (step.input && Object.keys(step.input).length > 0) {
+                logger_1.ui.dim(`     ${JSON.stringify(step.input)}`);
+            }
+        });
+        if (options.dryRun) {
+            logger_1.ui.divider();
+            logger_1.ui.info("dry-run mode: no Tool will be executed");
+            return;
+        }
+        await (0, executor_1.executePlan)(plan, this.ctx, { autoApprove: options.autoApprove });
+    }
+}
+exports.Agent = Agent;

package/dist/core/executor.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executePlan = executePlan;
+const registry_1 = require("./registry");
+const confirm_1 = require("../shared/confirm");
+const logger_1 = require("../shared/logger");
+async function executePlan(plan, ctx, options = {}) {
+    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);
+        if (!tool) {
+            (0, logger_1.logStep)(i, "fail", step.tool, { error: "Tool not found" });
+            throw new Error(`Tool not found: ${step.tool}`);
+        }
+        if (tool.riskLevel === "high") {
+            const ok = options.autoApprove
+                ? true
+                : await (0, confirm_1.confirm)(`⚠ 执行高风险 Tool: ${tool.name} ${JSON.stringify(step.input)}`);
+            if (!ok) {
+                (0, logger_1.logStep)(i, "skip", tool.name, { reason: "user cancelled" });
+                continue;
+            }
+        }
+        (0, logger_1.logStep)(i, "run", tool.name, { input: step.input });
+        try {
+            const result = await tool.execute(step.input, ctx);
+            (0, logger_1.logStep)(i, "done", tool.name, { output: result });
+        }
+        catch (err) {
+            (0, logger_1.logStep)(i, "fail", tool.name, { error: err?.message || String(err) });
+            throw err;
+        }
+    }
+    logger_1.ui.divider();
+    logger_1.ui.success("Execute finished");
+}

package/dist/core/llm-planner.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.llmPlanTask = llmPlanTask;
+const zod_to_json_schema_1 = require("zod-to-json-schema");
+const registry_1 = require("./registry");
+const tools_1 = require("../integrations/volc/tools");
+const llm_1 = require("../shared/llm");
+function buildToolCatalog() {
+    return registry_1.toolList.map((t) => ({
+        name: t.name,
+        description: t.description,
+        riskLevel: t.riskLevel || "low",
+        inputSchema: (0, zod_to_json_schema_1.zodToJsonSchema)(t.input, t.name)
+    }));
+}
+function buildSystemPrompt() {
+    const catalog = buildToolCatalog();
+    return [
+        "You are a CLI Agent Planner for Volcengine EMR.",
+        "You MUST NOT execute anything directly.",
+        "Your only job is to output an ordered plan of tool calls.",
+        "",
+        "Available tools (JSON catalog):",
+        JSON.stringify(catalog, null, 2),
+        "",
+        "Response format:",
+        'You MUST output ONLY a JSON object with shape {"steps":[{"tool":"<name>","input":{...}}]}.',
+        "Do NOT include any prose, markdown fences, or explanations.",
+        "The very first character of your reply MUST be `{` and the last MUST be `}`.",
+        "Rules:",
+        "- 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)."
+    ].join("\n");
+}
+function buildUserPrompt(task, context) {
+    const ctx = context ? `\n\nContext:\n${JSON.stringify(context, null, 2)}` : "";
+    return `Task: ${task}${ctx}`;
+}
+function extractJsonObject(raw) {
+    const stripped = raw
+        .trim()
+        .replace(/^```(?:json)?\s*/i, "")
+        .replace(/```\s*$/i, "")
+        .trim();
+    if (stripped.startsWith("{"))
+        return stripped;
+    const start = stripped.indexOf("{");
+    if (start === -1)
+        return stripped;
+    let depth = 0;
+    let inString = false;
+    let escape = false;
+    for (let i = start; i < stripped.length; i++) {
+        const ch = stripped[i];
+        if (inString) {
+            if (escape) {
+                escape = false;
+            }
+            else if (ch === "\\") {
+                escape = true;
+            }
+            else if (ch === '"') {
+                inString = false;
+            }
+            continue;
+        }
+        if (ch === '"') {
+            inString = true;
+        }
+        else if (ch === "{") {
+            depth++;
+        }
+        else if (ch === "}") {
+            depth--;
+            if (depth === 0)
+                return stripped.slice(start, i + 1);
+        }
+    }
+    return stripped.slice(start);
+}
+function tryParsePlan(raw) {
+    const jsonText = extractJsonObject(raw);
+    const parsed = JSON.parse(jsonText);
+    const steps = Array.isArray(parsed) ? parsed : parsed?.steps;
+    if (!Array.isArray(steps)) {
+        throw new Error("LLM plan has no `steps` array");
+    }
+    return steps.map((s, i) => {
+        if (!s || typeof s.tool !== "string") {
+            throw new Error(`Step ${i} is missing "tool"`);
+        }
+        return { tool: s.tool, input: s.input ?? {} };
+    });
+}
+function validatePlanAgainstTools(steps) {
+    return steps.map((step) => {
+        const tool = registry_1.toolList.find((t) => t.name === step.tool);
+        if (!tool)
+            throw new Error(`LLM chose unknown tool: ${step.tool}`);
+        const result = tool.input.safeParse(step.input ?? {});
+        if (!result.success) {
+            throw new Error(`LLM produced invalid input for ${step.tool}: ${result.error.message}`);
+        }
+        return { tool: step.tool, input: result.data };
+    });
+}
+async function llmPlanTask(task, llm) {
+    const messages = [
+        { role: "system", content: buildSystemPrompt() },
+        { role: "user", content: buildUserPrompt(task) }
+    ];
+    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 tools_1.emrApi.findClustersToCleanup(step.input || {});
+            for (const c of found) {
+                expanded.push({
+                    tool: "deleteCluster",
+                    input: { ClusterId: c.ClusterId }
+                });
+            }
+        }
+    }
+    return expanded;
+}

package/dist/core/planner.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.planTask = planTask;
+const config_1 = require("../shared/config");
+const llm_planner_1 = require("./llm-planner");
+async function planTask(task, _options = {}) {
+    const llm = (0, config_1.resolveLlmConfig)();
+    if (!llm) {
+        throw new Error("LLM is not configured. Run `volc-emr-agent config set-llm` or set VOLC_LLM_ENDPOINT first.");
+    }
+    return (0, llm_planner_1.llmPlanTask)(task, llm);
+}

package/dist/core/registry.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.apiRegistry = exports.toolList = exports.tools = void 0;
+const tools_1 = require("../integrations/volc/tools");
+exports.tools = {
+    ...tools_1.emrTools
+};
+exports.toolList = Object.values(exports.tools);
+exports.apiRegistry = {
+    emr: tools_1.emrApi
+};

package/dist/core/tool.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/core/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/index.js

@@ -2,190 +2,15 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
-const agent_1 = require("./agent/agent");
-const registry_1 = require("./tools/registry");
-const memory_1 = require("./runtime/memory");
-const config_1 = require("./runtime/config");
-const confirm_1 = require("./runtime/confirm");
-const logger_1 = require("./runtime/logger");
+const config_1 = require("./commands/config");
+const init_1 = require("./commands/init");
+const run_1 = require("./commands/run");
 const program = new commander_1.Command();
 program
-    .name("volc-emr-agent")
-    .description("Volcengine EMR CLI Agent (real OpenAPI)")
+    .name("emr-cli")
+    .description("Volcengine EMR CLI Agent (Tool-first, Plan/Execute, LLM-driven)")
     .version("0.1.0");
-program
-    .command("run <task>")
-    .description("Plan and execute a natural language EMR task")
-    .option("--dry-run", "Only show plan")
-    .option("-y, --yes", "Auto approve high-risk tools (skip confirm)")
-    .option("--region <region>", "Override region, default cn-beijing")
-    .action(async (task, opts) => {
-    if (opts.accessKey)
-        process.env.VOLC_ACCESSKEY = opts.accessKey;
-    if (opts.secretKey)
-        process.env.VOLC_SECRETKEY = opts.secretKey;
-    if (opts.region)
-        process.env.VOLC_REGION = opts.region;
-    try {
-        const creds = (0, config_1.resolveCredentials)();
-        const cfg = (0, config_1.readLocalConfig)();
-        logger_1.ui.dim(`region=${creds.region}  llm=${cfg.llm?.endpoint ? "configured" : "not configured"}`);
-        const agent = new agent_1.Agent({
-            api: registry_1.apiRegistry,
-            memory: memory_1.memory
-        });
-        await agent.run(task, {
-            dryRun: opts.dryRun,
-            autoApprove: opts.yes
-        });
-    }
-    catch (err) {
-        logger_1.ui.error(err?.message || String(err));
-        process.exitCode = 1;
-    }
-});
-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 \`volc-emr-agent run "列出集群"\` to verify.`);
-    }
-    finally {
-        session?.close();
-    }
-});
-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)");
-    }
-});
+(0, run_1.registerRunCommand)(program);
+(0, init_1.registerInitCommand)(program);
+(0, config_1.registerConfigCommand)(program);
 program.parse();

package/dist/integrations/volc/client.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getEmrService = getEmrService;
+exports.callEmr = callEmr;
+const openapi_1 = require("@volcengine/openapi");
+const config_1 = require("../../shared/config");
+const EMR_API_VERSION = "2023-08-15";
+let cachedService = null;
+let cachedKey = null;
+function buildService(creds) {
+    const service = new openapi_1.Service({
+        host: `emr.${creds.region}.volcengineapi.com`,
+        serviceName: "emr",
+        region: creds.region,
+        accessKeyId: creds.accessKey,
+        secretKey: creds.secretKey,
+        defaultVersion: EMR_API_VERSION
+    });
+    return service;
+}
+function getEmrService(cli = {}) {
+    const creds = (0, config_1.resolveCredentials)(cli);
+    const key = `${creds.region}:${creds.accessKey}`;
+    if (cachedService && cachedKey === key)
+        return cachedService;
+    cachedService = buildService(creds);
+    cachedKey = key;
+    return cachedService;
+}
+async function callEmr(action, body = {}, options = {}) {
+    const service = getEmrService();
+    const fetchApi = service.createJSONAPI(action, {
+        method: "POST",
+        Version: options.version || EMR_API_VERSION,
+        contentType: "json"
+    });
+    const response = await fetchApi(body);
+    if (response?.ResponseMetadata?.Error) {
+        const err = response.ResponseMetadata.Error;
+        let message = err?.Message || err?.CodeN || err?.Code || "Volcengine EMR error";
+        if (typeof message === "string" && /\{\d+\}/.test(message)) {
+            try {
+                const bodyPreview = JSON.stringify(body);
+                message = `${message} (body=${bodyPreview})`;
+            }
+            catch {
+                /* ignore */
+            }
+        }
+        throw new Error(`[${action}] ${message}`);
+    }
+    return response?.Result;
+}

package/dist/integrations/volc/createClusterMemory.js

@@ -0,0 +1,56 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCreateClusterMemory = readCreateClusterMemory;
+exports.writeCreateClusterMemory = writeCreateClusterMemory;
+exports.clearCreateClusterMemory = clearCreateClusterMemory;
+exports.createClusterMemoryPath = createClusterMemoryPath;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const MEMORY_DIR = process.env.VOLC_EMR_CONFIG_DIR || path_1.default.join(os_1.default.homedir(), ".volc-emr");
+const MEMORY_FILE = path_1.default.join(MEMORY_DIR, "create-cluster-memory.json");
+function readCreateClusterMemory() {
+    try {
+        if (!fs_1.default.existsSync(MEMORY_FILE))
+            return {};
+        const parsed = JSON.parse(fs_1.default.readFileSync(MEMORY_FILE, "utf-8"));
+        return parsed && typeof parsed === "object" ? parsed : {};
+    }
+    catch {
+        return {};
+    }
+}
+function writeCreateClusterMemory(patch) {
+    fs_1.default.mkdirSync(MEMORY_DIR, { recursive: true, mode: 0o700 });
+    const prev = readCreateClusterMemory();
+    const merged = { ...prev };
+    for (const [k, v] of Object.entries(patch)) {
+        if (v === undefined || v === null)
+            continue;
+        if (typeof v === "string" && !v.trim())
+            continue;
+        if (Array.isArray(v) && v.length === 0)
+            continue;
+        merged[k] = v;
+    }
+    merged.updatedAt = Date.now();
+    fs_1.default.writeFileSync(MEMORY_FILE, JSON.stringify(merged, null, 2), {
+        mode: 0o600
+    });
+    return merged;
+}
+function clearCreateClusterMemory() {
+    try {
+        if (fs_1.default.existsSync(MEMORY_FILE))
+            fs_1.default.unlinkSync(MEMORY_FILE);
+    }
+    catch {
+        /* ignore */
+    }
+}
+function createClusterMemoryPath() {
+    return MEMORY_FILE;
+}