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

package/dist/shared/prompt.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.systemPrompt = void 0;
+exports.systemPrompt = `
+You are a CLI Agent planner.
+Given a natural language task and a list of tools,
+output a JSON array of { tool, input } steps.
+Never call tools yourself. Only produce plans.
+`.trim();

package/dist/tools/ecs/createCluster.js

@@ -0,0 +1,335 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCluster = void 0;
+const zod_1 = require("zod");
+const confirm_1 = require("../../runtime/confirm");
+const createClusterMemory_1 = require("../../runtime/createClusterMemory");
+const CLUSTER_TYPES = [
+    "Hadoop",
+    "Presto",
+    "Trino",
+    "Stream-Kafka",
+    "Stream-Flink",
+    "HBase",
+    "OpenSearch",
+    "StarRocks",
+    "TensorFlow",
+    "Doris",
+    "Pulsar",
+    "ClickHouse",
+    "ZooKeeper"
+];
+const CHARGE_TYPES = ["POST", "PRE"];
+const DEPLOY_MODES = ["SIMPLE", "HIGH_AVAILABLE"];
+const SECURITY_MODES = ["SIMPLE", "KERBEROS"];
+const HISTORY_SERVER_MODES = ["LOCAL", "PHS"];
+const NODE_GROUP_TYPES = ["MASTER", "CORE", "TASK", "GATEWAY"];
+const SystemDiskSchema = zod_1.z.object({
+    VolumeType: zod_1.z.string().default("ESSD_FlexPL"),
+    Size: zod_1.z.number().int().positive().default(80)
+});
+const DataDiskSchema = zod_1.z.object({
+    VolumeType: zod_1.z.string(),
+    Size: zod_1.z.number().int().positive(),
+    Count: zod_1.z.number().int().positive()
+});
+const NodeGroupSchema = zod_1.z.object({
+    NodeGroupType: zod_1.z.enum(NODE_GROUP_TYPES),
+    NodeGroupName: zod_1.z.string().optional(),
+    NodeCount: zod_1.z.number().int().positive(),
+    ZoneId: zod_1.z.string().optional(),
+    SubnetIds: zod_1.z.array(zod_1.z.string()).optional(),
+    EcsInstanceTypes: zod_1.z.array(zod_1.z.string()).optional(),
+    SystemDisk: SystemDiskSchema.optional(),
+    DataDisks: zod_1.z.array(DataDiskSchema).optional(),
+    EcsKeyPairName: zod_1.z.string().optional(),
+    EcsPassword: zod_1.z.string().optional(),
+    Bandwidth: zod_1.z.number().int().nonnegative().optional(),
+    ChargeType: zod_1.z.enum(CHARGE_TYPES).optional(),
+    WithPublicIp: zod_1.z.boolean().optional()
+});
+const ChargePreConfigSchema = zod_1.z.object({
+    ChargePeriodUnit: zod_1.z.enum(["Month", "Year"]).default("Month"),
+    ChargePeriod: zod_1.z.number().int().positive().default(1),
+    AutoRenew: zod_1.z.boolean().default(false),
+    AutoRenewPeriodUnit: zod_1.z.enum(["Month", "Year"]).optional(),
+    AutoRenewPeriod: zod_1.z.number().int().positive().optional()
+});
+function randomSuffix() {
+    return Math.random().toString(36).slice(2, 7);
+}
+function isMissing(v) {
+    if (v === undefined || v === null)
+        return true;
+    if (typeof v === "string" && !v.trim())
+        return true;
+    if (Array.isArray(v) && v.length === 0)
+        return true;
+    return false;
+}
+function parseList(input) {
+    return input
+        .split(/[,，\s]+/)
+        .map((s) => s.trim())
+        .filter(Boolean);
+}
+function parseBool(input, defaultValue = false) {
+    const v = input.trim().toLowerCase();
+    if (!v)
+        return defaultValue;
+    return ["y", "yes", "true", "1", "是"].includes(v);
+}
+function parseInt10(input, defaultValue) {
+    const n = parseInt(input, 10);
+    if (Number.isFinite(n))
+        return n;
+    return defaultValue;
+}
+async function askEnum(prompt, question, enumValues, current, defaultValue) {
+    if (current && enumValues.includes(current))
+        return current;
+    const def = defaultValue && enumValues.includes(defaultValue) ? defaultValue : undefined;
+    const label = `${question} (可选: ${enumValues.join(" / ")})`;
+    while (true) {
+        const answer = (await prompt.ask(label, { defaultValue: def }));
+        if (enumValues.includes(answer))
+            return answer;
+        process.stdout.write(`  非法取值，请从 ${enumValues.join(" / ")} 中选择\n`);
+    }
+}
+async function askRequired(prompt, question, current, defaultValue) {
+    if (current && current.trim())
+        return current;
+    while (true) {
+        const v = await prompt.ask(question, { defaultValue });
+        if (v && v.trim())
+            return v.trim();
+        process.stdout.write("  该字段必填，请输入\n");
+    }
+}
+async function completeNodeGroup(prompt, ng, defaults) {
+    const mem = defaults.memory || {};
+    const type = await askEnum(prompt, `节点组类型 (当前: ${ng.NodeGroupType || "未设置"})`, NODE_GROUP_TYPES, ng.NodeGroupType);
+    const name = ng.NodeGroupName ||
+        `OpenApi-${type[0] + type.slice(1).toLowerCase()}Group-${randomSuffix()}`;
+    const count = ng.NodeCount ??
+        parseInt10(await prompt.ask(`  节点数`, {
+            defaultValue: type === "MASTER" ? "3" : type === "CORE" ? "3" : "1"
+        }), type === "MASTER" ? 3 : type === "CORE" ? 3 : 1);
+    let subnets = ng.SubnetIds;
+    if (isMissing(subnets)) {
+        const memDefault = mem.SubnetIds && mem.SubnetIds.length ? mem.SubnetIds.join(",") : undefined;
+        const raw = memDefault
+            ? await prompt.ask(`  SubnetIds (逗号分隔, 至少 1 个)`, {
+                defaultValue: memDefault
+            })
+            : await askRequired(prompt, `  SubnetIds (逗号分隔, 至少 1 个)`);
+        subnets = parseList(raw);
+        if (!subnets.length) {
+            subnets = await askRequired(prompt, `  SubnetIds 不能为空，请重新输入`).then(parseList);
+        }
+    }
+    let instanceTypes = ng.EcsInstanceTypes;
+    if (isMissing(instanceTypes)) {
+        const memDefault = mem.EcsInstanceTypes && mem.EcsInstanceTypes.length
+            ? mem.EcsInstanceTypes.join(",")
+            : "ecs.g3i.2xlarge";
+        const raw = await prompt.ask(`  EcsInstanceTypes (逗号分隔)`, {
+            defaultValue: memDefault
+        });
+        instanceTypes = parseList(raw);
+        if (!instanceTypes.length)
+            instanceTypes = ["ecs.g3i.2xlarge"];
+    }
+    const system = ng.SystemDisk || { VolumeType: "ESSD_FlexPL", Size: 80 };
+    const keyPair = ng.EcsKeyPairName ||
+        (await prompt.ask(`  EcsKeyPairName (可选, 回车跳过)`, {
+            defaultValue: mem.EcsKeyPairName
+        })) ||
+        undefined;
+    return {
+        NodeGroupType: type,
+        NodeGroupName: name,
+        NodeCount: count,
+        ZoneId: ng.ZoneId || defaults.ZoneId,
+        SubnetIds: subnets,
+        EcsInstanceTypes: instanceTypes,
+        SystemDisk: system,
+        DataDisks: ng.DataDisks,
+        EcsKeyPairName: keyPair,
+        EcsPassword: ng.EcsPassword,
+        Bandwidth: ng.Bandwidth,
+        ChargeType: ng.ChargeType || defaults.ChargeType,
+        WithPublicIp: ng.WithPublicIp ?? false
+    };
+}
+exports.createCluster = {
+    name: "createCluster",
+    description: "Create a Volcengine EMR cluster (CreateCluster). The tool will interactively ask the user for any missing required fields, " +
+        "then show a summary and ask for final confirmation before calling the OpenAPI. " +
+        "LLM should pre-fill as many fields as it can infer from the user's natural language description (e.g. cluster type, version, node count, charge type), " +
+        "and leave unknown fields as undefined — the tool itself will prompt the user.",
+    riskLevel: "high",
+    input: zod_1.z.object({
+        ProjectName: zod_1.z.string().optional(),
+        ClusterName: zod_1.z.string().optional(),
+        ClusterType: zod_1.z.enum(CLUSTER_TYPES).optional(),
+        ReleaseVersion: zod_1.z.string().optional(),
+        DeployMode: zod_1.z.enum(DEPLOY_MODES).optional(),
+        SecurityMode: zod_1.z.enum(SECURITY_MODES).optional(),
+        HistoryServerMode: zod_1.z.enum(HISTORY_SERVER_MODES).optional(),
+        ChargeType: zod_1.z.enum(CHARGE_TYPES).optional(),
+        ChargePreConfig: ChargePreConfigSchema.partial().optional(),
+        VpcId: zod_1.z.string().optional(),
+        SecurityGroupId: zod_1.z.string().optional(),
+        ZoneId: zod_1.z.string().optional(),
+        EcsIamRole: zod_1.z.string().optional(),
+        NodeGroupAttributes: zod_1.z.array(NodeGroupSchema.partial()).optional(),
+        ApplicationNames: zod_1.z.array(zod_1.z.string()).optional()
+    }),
+    async execute(input, ctx) {
+        const prompt = (0, confirm_1.createPromptSession)();
+        const memory = (0, createClusterMemory_1.readCreateClusterMemory)();
+        const pick = (inputVal, memVal, fallback) => {
+            if (inputVal !== undefined && inputVal !== null && inputVal !== "")
+                return inputVal;
+            if (memVal !== undefined && memVal !== null && memVal !== "")
+                return memVal;
+            return fallback;
+        };
+        try {
+            process.stdout.write("\n=== 创建 EMR 集群：补全配置 ===\n");
+            if (memory.updatedAt) {
+                process.stdout.write(`(已加载上次记忆，路径: ${(0, createClusterMemory_1.createClusterMemoryPath)()})\n`);
+            }
+            const ClusterType = await askEnum(prompt, "集群类型", CLUSTER_TYPES, input.ClusterType, memory.ClusterType || "Hadoop");
+            const ReleaseVersion = await askRequired(prompt, "集群版本 (ReleaseVersion, 如 3.7.0)", input.ReleaseVersion, memory.ReleaseVersion || "3.7.0");
+            const ClusterName = await askRequired(prompt, "集群名称", input.ClusterName, `OpenApi${ClusterType}${ReleaseVersion}-${randomSuffix()}`);
+            const ChargeType = await askEnum(prompt, "付费类型", CHARGE_TYPES, input.ChargeType, memory.ChargeType || "POST");
+            let ChargePreConfig;
+            if (ChargeType === "PRE") {
+                const pre = input.ChargePreConfig || {};
+                const unit = await askEnum(prompt, "  包年包月计费单位", ["Month", "Year"], pre.ChargePeriodUnit, "Month");
+                const period = parseInt10(await prompt.ask("  包年包月周期数", {
+                    defaultValue: String(pre.ChargePeriod ?? 1)
+                }), pre.ChargePeriod ?? 1);
+                const autoRenew = parseBool(await prompt.ask("  是否自动续费 (y/n)", {
+                    defaultValue: pre.AutoRenew ? "y" : "n"
+                }), !!pre.AutoRenew);
+                ChargePreConfig = {
+                    ChargeType: "PRE",
+                    ChargePeriodUnit: unit,
+                    ChargePeriod: period,
+                    AutoRenew: autoRenew,
+                    AutoRenewPeriodUnit: autoRenew ? unit : undefined,
+                    AutoRenewPeriod: autoRenew ? period : undefined
+                };
+            }
+            const DeployMode = await askEnum(prompt, "部署模式", DEPLOY_MODES, input.DeployMode, memory.DeployMode || "HIGH_AVAILABLE");
+            const SecurityMode = await askEnum(prompt, "安全模式", SECURITY_MODES, input.SecurityMode, memory.SecurityMode || "SIMPLE");
+            const VpcId = await askRequired(prompt, "VpcId (如 vpc-xxx)", input.VpcId, memory.VpcId);
+            const SecurityGroupId = await askRequired(prompt, "SecurityGroupId (如 sg-xxx)", input.SecurityGroupId, memory.SecurityGroupId);
+            const ZoneId = await askRequired(prompt, "可用区 ZoneId (如 cn-beijing-b)", input.ZoneId, memory.ZoneId || "cn-beijing-b");
+            const EcsIamRole = input.EcsIamRole ||
+                (await prompt.ask("EcsIamRole (可选, 回车跳过)", {
+                    defaultValue: memory.EcsIamRole
+                })) ||
+                undefined;
+            let nodeGroupsInput = input.NodeGroupAttributes || [];
+            const hasMaster = nodeGroupsInput.some((g) => g?.NodeGroupType === "MASTER");
+            const hasCore = nodeGroupsInput.some((g) => g?.NodeGroupType === "CORE");
+            if (!hasMaster)
+                nodeGroupsInput = [...nodeGroupsInput, { NodeGroupType: "MASTER" }];
+            if (!hasCore)
+                nodeGroupsInput = [...nodeGroupsInput, { NodeGroupType: "CORE" }];
+            process.stdout.write(`\n-- 节点组配置 (共 ${nodeGroupsInput.length} 组) --\n`);
+            const NodeGroupAttributes = [];
+            for (const [i, ng] of nodeGroupsInput.entries()) {
+                process.stdout.write(`\n[节点组 ${i + 1}]\n`);
+                NodeGroupAttributes.push(await completeNodeGroup(prompt, ng, {
+                    ZoneId,
+                    ChargeType,
+                    memory
+                }));
+            }
+            let ApplicationNames = input.ApplicationNames;
+            if (isMissing(ApplicationNames)) {
+                const raw = await prompt.ask("\nApplicationNames (逗号分隔, 回车跳过用默认组件)", {
+                    defaultValue: memory.ApplicationNames && memory.ApplicationNames.length
+                        ? memory.ApplicationNames.join(",")
+                        : undefined
+                });
+                ApplicationNames = parseList(raw);
+                if (!ApplicationNames.length)
+                    ApplicationNames = undefined;
+            }
+            const ProjectName = pick(input.ProjectName, memory.ProjectName, "default") || "default";
+            const params = {
+                ProjectName,
+                ClusterName,
+                ClusterType,
+                ReleaseVersion,
+                DeployMode,
+                SecurityMode,
+                HistoryServerMode: input.HistoryServerMode || "LOCAL",
+                ChargeType,
+                ChargePreConfig,
+                VpcId,
+                SecurityGroupId,
+                NodeAttribute: {
+                    ZoneId,
+                    EcsIamRole
+                },
+                NodeGroupAttributes,
+                ApplicationNames
+            };
+            process.stdout.write("\n=== 即将创建集群，配置如下 ===\n");
+            process.stdout.write(JSON.stringify(params, null, 2) + "\n\n");
+            const ok = await (0, confirm_1.confirm)("确认使用以上配置创建集群?");
+            if (!ok) {
+                return { Skipped: true, Reason: "USER_CANCELLED", Params: params };
+            }
+            const persistMemory = () => {
+                try {
+                    const firstNg = NodeGroupAttributes[0];
+                    (0, createClusterMemory_1.writeCreateClusterMemory)({
+                        ProjectName,
+                        ClusterType,
+                        ReleaseVersion,
+                        ChargeType,
+                        DeployMode,
+                        SecurityMode,
+                        VpcId,
+                        SecurityGroupId,
+                        ZoneId,
+                        EcsIamRole,
+                        SubnetIds: firstNg?.SubnetIds,
+                        EcsInstanceTypes: firstNg?.EcsInstanceTypes,
+                        EcsKeyPairName: firstNg?.EcsKeyPairName,
+                        ApplicationNames
+                    });
+                    process.stdout.write(`(已更新常用默认值记忆: ${(0, createClusterMemory_1.createClusterMemoryPath)()})\n`);
+                }
+                catch (e) {
+                    process.stdout.write(`(警告: 写入记忆失败: ${e?.message || e})\n`);
+                }
+            };
+            persistMemory();
+            try {
+                const result = await ctx.api.emr.createCluster(params);
+                process.stdout.write(`\n✓ 集群创建成功: ClusterId=${result.ClusterId}` +
+                    (result.OperationId ? `, OperationId=${result.OperationId}` : "") +
+                    "\n");
+                return result;
+            }
+            catch (err) {
+                process.stdout.write(`\n✗ 集群创建失败: ${err?.message || err}\n` +
+                    `(已保存本次填写的默认值到记忆，下次可直接复用)\n`);
+                throw err;
+            }
+        }
+        finally {
+            prompt.close();
+        }
+    }
+};

package/dist/tools/ecs/deleteCluster.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteCluster = void 0;
+const zod_1 = require("zod");
+const ecsApi_1 = require("../../services/ecsApi");
+function formatClusters(clusters, max = 10) {
+    const formatted = clusters.map((cluster) => {
+        const name = cluster.ClusterName ? `, ${cluster.ClusterName}` : "";
+        return `${cluster.ClusterId}${name} (${cluster.ClusterState || "UNKNOWN"})`;
+    });
+    if (formatted.length <= max)
+        return formatted.join(", ");
+    return `${formatted.slice(0, max).join(", ")} ... (+${formatted.length - max} more)`;
+}
+function collectClustersFromPreviousList(lastResult) {
+    const items = Array.isArray(lastResult?.Items)
+        ? lastResult.Items
+        : [];
+    const deletableClusters = [];
+    const skippedTerminatedClusters = [];
+    for (const item of items) {
+        const clusterId = item?.ClusterId;
+        if (typeof clusterId !== "string" || clusterId.length === 0)
+            continue;
+        const clusterName = typeof item?.ClusterName === "string" && item.ClusterName.length > 0
+            ? item.ClusterName
+            : undefined;
+        const clusterState = String(item?.ClusterState || "").toUpperCase();
+        const cluster = {
+            ClusterId: clusterId,
+            ClusterName: clusterName,
+            ClusterState: clusterState || undefined
+        };
+        if (clusterState === ecsApi_1.EmrClusterState.TERMINATED) {
+            skippedTerminatedClusters.push(cluster);
+            continue;
+        }
+        deletableClusters.push(cluster);
+    }
+    return { deletableClusters, skippedTerminatedClusters };
+}
+function buildSkippedArchivedNotices(clusters) {
+    if (clusters.length === 0)
+        return [];
+    return [
+        {
+            type: "message",
+            level: "warn",
+            text: "以下集群处于 TERMINATED（已归档）状态，无需再释放，已自动跳过。"
+        },
+        {
+            type: "kv",
+            key: "clusters",
+            value: formatClusters(clusters)
+        }
+    ];
+}
+function buildDeleteClusterConfirmMessage(input) {
+    const clusterName = typeof input.ClusterName === "string" && input.ClusterName.length > 0
+        ? ` ClusterName=${input.ClusterName}`
+        : "";
+    const clusterState = typeof input.ClusterState === "string" && input.ClusterState.length > 0
+        ? ` ClusterState=${input.ClusterState}`
+        : "";
+    return `⚠ 执行高风险 Tool: deleteCluster${clusterName}${clusterState} ${JSON.stringify(input)}`;
+}
+exports.deleteCluster = {
+    name: "deleteCluster",
+    description: "Release (delete) one EMR cluster via Volcengine OpenAPI (ReleaseCluster). " +
+        "For cleanup flows, the agent may first call listClusters and then expand deleteCluster {FromPreviousList:true} into multiple one-by-one deletions. " +
+        "Do not generate delete tasks for clusters in TERMINATED state because archived clusters in that state do not support ReleaseCluster.",
+    riskLevel: "high",
+    input: zod_1.z
+        .object({
+        ClusterId: zod_1.z.string().min(1).optional(),
+        ClusterName: zod_1.z.string().min(1).optional(),
+        ClusterState: zod_1.z.string().min(1).optional(),
+        FromPreviousList: zod_1.z.boolean().optional()
+    })
+        .refine((input) => !!input.ClusterId || !!input.FromPreviousList, {
+        message: "One of ClusterId or FromPreviousList=true is required"
+    }),
+    prepareStep(step, ctx) {
+        if (!step.input?.FromPreviousList)
+            return;
+        if (ctx.memory["__lastToolName"] !== "listClusters") {
+            throw new Error("deleteCluster with FromPreviousList requires previous step to be listClusters");
+        }
+        const { deletableClusters, skippedTerminatedClusters } = collectClustersFromPreviousList(ctx.memory["__lastToolResult"]);
+        if (deletableClusters.length === 0) {
+            return {
+                action: "skip",
+                reason: skippedTerminatedClusters.length > 0
+                    ? "no deletable clusters found from previous list"
+                    : "no clusters found from previous list",
+                notices: buildSkippedArchivedNotices(skippedTerminatedClusters)
+            };
+        }
+        return {
+            action: "continue",
+            steps: deletableClusters.map(({ ClusterId, ClusterName, ClusterState }) => ({
+                tool: "deleteCluster",
+                input: { ClusterId, ClusterName, ClusterState }
+            })),
+            notices: [
+                {
+                    type: "message",
+                    level: "info",
+                    text: `Expanded deleteCluster into ${deletableClusters.length} per-cluster step(s).` +
+                        (skippedTerminatedClusters.length
+                            ? ` Skipped ${skippedTerminatedClusters.length} TERMINATED cluster(s).`
+                            : "")
+                },
+                ...buildSkippedArchivedNotices(skippedTerminatedClusters)
+            ]
+        };
+    },
+    formatRiskConfirmMessage(input) {
+        return buildDeleteClusterConfirmMessage(input);
+    },
+    async execute(input, ctx) {
+        if (!input.ClusterId) {
+            throw new Error("deleteCluster requires a concrete ClusterId. For FromPreviousList flows, the agent must expand it into per-cluster deleteCluster steps first.");
+        }
+        return ctx.api.emr.releaseCluster({ ClusterId: input.ClusterId });
+    }
+};

package/dist/tools/ecs/findClustersToCleanup.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findClustersToCleanup = void 0;
+const zod_1 = require("zod");
+const ecsApi_1 = require("../../services/ecsApi");
+const DAY = 86400000;
+const DEFAULT_STATES = [
+    ecsApi_1.EmrClusterState.TERMINATED,
+    ecsApi_1.EmrClusterState.TERMINATED_WITH_ERROR,
+    ecsApi_1.EmrClusterState.FAILED,
+    ecsApi_1.EmrClusterState.SHUTDOWN
+];
+exports.findClustersToCleanup = {
+    name: "findClustersToCleanup",
+    description: "[Deprecated] Find cleanup candidates by wrapping listClusters. " +
+        "Prefer planning `listClusters` first and then `deleteCluster` with {FromPreviousList:true}. " +
+        "`states` MUST use the official uppercase enum: " +
+        ecsApi_1.CLUSTER_STATES.join(", "),
+    input: zod_1.z.object({
+        olderThanDays: zod_1.z.number().int().positive().optional(),
+        states: zod_1.z.array(zod_1.z.nativeEnum(ecsApi_1.EmrClusterState)).optional()
+    }),
+    async execute(input, ctx) {
+        const olderThanDays = input?.olderThanDays ?? 7;
+        const threshold = Date.now() - olderThanDays * DAY;
+        const result = await ctx.api.emr.listClusters({
+            ClusterStates: input?.states && input.states.length ? input.states : DEFAULT_STATES,
+            CreateTimeBefore: threshold
+        });
+        return result.Items;
+    }
+};

package/dist/tools/ecs/index.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emrApi = exports.emrTools = void 0;
+const listClusters_1 = require("./listClusters");
+const deleteCluster_1 = require("./deleteCluster");
+const createCluster_1 = require("./createCluster");
+const ecsApi_1 = require("../../services/ecsApi");
+Object.defineProperty(exports, "emrApi", { enumerable: true, get: function () { return ecsApi_1.emrApi; } });
+exports.emrTools = {
+    listClusters: listClusters_1.listClusters,
+    deleteCluster: deleteCluster_1.deleteCluster,
+    createCluster: createCluster_1.createCluster
+};

package/dist/tools/ecs/listClusters.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listClusters = void 0;
+const zod_1 = require("zod");
+const ecsApi_1 = require("../../services/ecsApi");
+const STATE_ALIASES = {
+    "已关停": ecsApi_1.EmrClusterState.SHUTDOWN,
+    "关停": ecsApi_1.EmrClusterState.SHUTDOWN,
+    "运行中": ecsApi_1.EmrClusterState.RUNNING,
+    "已终止": ecsApi_1.EmrClusterState.TERMINATED,
+    "已创建": ecsApi_1.EmrClusterState.RUNNING,
+    "创建中": ecsApi_1.EmrClusterState.CREATING,
+    "失败": ecsApi_1.EmrClusterState.FAILED,
+    "异常": ecsApi_1.EmrClusterState.EXCEPTION,
+    "已停止": ecsApi_1.EmrClusterState.PAUSED,
+    "停止中": ecsApi_1.EmrClusterState.PAUSING
+};
+function normalizeOneState(raw) {
+    if (!raw)
+        return undefined;
+    const upper = raw.toUpperCase();
+    if (ecsApi_1.CLUSTER_STATES.includes(upper)) {
+        return upper;
+    }
+    return STATE_ALIASES[raw];
+}
+function normalizeStates(states) {
+    if (!states || !states.length)
+        return undefined;
+    const out = [];
+    for (const s of states) {
+        const v = normalizeOneState(String(s));
+        if (v)
+            out.push(v);
+        else
+            throw new Error(`Invalid ClusterState \`${s}\`. Allowed: ${ecsApi_1.CLUSTER_STATES.join(", ")}`);
+    }
+    return out;
+}
+const TagSchema = zod_1.z.object({ Key: zod_1.z.string(), Value: zod_1.z.string() });
+const ClusterStateEnum = zod_1.z.nativeEnum(ecsApi_1.EmrClusterState);
+exports.listClusters = {
+    name: "listClusters",
+    description: "List EMR clusters via Volcengine OpenAPI (ListClusters). ClusterStates MUST use the official uppercase enum: " +
+        ecsApi_1.CLUSTER_STATES.join(", "),
+    input: zod_1.z.object({
+        ClusterName: zod_1.z.string().optional(),
+        ClusterId: zod_1.z.string().optional(),
+        ReleaseVersion: zod_1.z.string().optional(),
+        ProjectName: zod_1.z.string().optional(),
+        CreateTimeBefore: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]).optional(),
+        CreateTimeAfter: zod_1.z.union([zod_1.z.number(), zod_1.z.string()]).optional(),
+        ClusterIds: zod_1.z.array(zod_1.z.string()).optional(),
+        ClusterTypes: zod_1.z.array(zod_1.z.string()).optional(),
+        ClusterStates: zod_1.z.array(ClusterStateEnum).optional(),
+        ChargeTypes: zod_1.z.array(zod_1.z.enum(["PRE", "POST"])).optional(),
+        Tags: zod_1.z.array(TagSchema).optional(),
+        MaxResults: zod_1.z.number().int().positive().max(100).optional(),
+        NextToken: zod_1.z.string().optional()
+    }),
+    async execute(input, ctx) {
+        const safeInput = { ...(input || {}) };
+        if (safeInput.ClusterStates) {
+            safeInput.ClusterStates = normalizeStates(safeInput.ClusterStates);
+        }
+        return ctx.api.emr.listClusters(safeInput);
+    }
+};

package/dist/tools/emr/deleteCluster.js

@@ -4,12 +4,21 @@ exports.deleteCluster = void 0;
 const zod_1 = require("zod");
 exports.deleteCluster = {
     name: "deleteCluster",
-    description: "Release (delete) an EMR cluster via Volcengine OpenAPI (ReleaseCluster)",
+    description: "Release (delete) one EMR cluster via Volcengine OpenAPI (ReleaseCluster). " +
+        "For cleanup flows, the agent may first call listClusters and then expand deleteCluster {FromPreviousList:true} into multiple one-by-one deletions.",
     riskLevel: "high",
-    input: zod_1.z.object({
-        ClusterId: zod_1.z.string().min(1)
+    input: zod_1.z
+        .object({
+        ClusterId: zod_1.z.string().min(1).optional(),
+        FromPreviousList: zod_1.z.boolean().optional()
+    })
+        .refine((input) => !!input.ClusterId || !!input.FromPreviousList, {
+        message: "One of ClusterId or FromPreviousList=true is required"
     }),
     async execute(input, ctx) {
+        if (!input.ClusterId) {
+            throw new Error("deleteCluster requires a concrete ClusterId. For FromPreviousList flows, the agent must expand it into per-cluster deleteCluster steps first.");
+        }
         return ctx.api.emr.releaseCluster({ ClusterId: input.ClusterId });
     }
 };

package/dist/tools/emr/findClustersToCleanup.js

@@ -3,9 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.findClustersToCleanup = void 0;
 const zod_1 = require("zod");
 const emrApi_1 = require("../../services/emrApi");
+const DAY = 86400000;
+const DEFAULT_STATES = [
+    emrApi_1.EmrClusterState.TERMINATED,
+    emrApi_1.EmrClusterState.TERMINATED_WITH_ERROR,
+    emrApi_1.EmrClusterState.FAILED,
+    emrApi_1.EmrClusterState.SHUTDOWN
+];
 exports.findClustersToCleanup = {
     name: "findClustersToCleanup",
-    description: "Find EMR clusters that are in shutdown-like states and older than N days (default 7). " +
+    description: "[Deprecated] Find cleanup candidates by wrapping listClusters. " +
+        "Prefer planning `listClusters` first and then `deleteCluster` with {FromPreviousList:true}. " +
         "`states` MUST use the official uppercase enum: " +
         emrApi_1.CLUSTER_STATES.join(", "),
     input: zod_1.z.object({
@@ -13,6 +21,12 @@ exports.findClustersToCleanup = {
         states: zod_1.z.array(zod_1.z.nativeEnum(emrApi_1.EmrClusterState)).optional()
     }),
     async execute(input, ctx) {
-        return ctx.api.emr.findClustersToCleanup(input || {});
+        const olderThanDays = input?.olderThanDays ?? 7;
+        const threshold = Date.now() - olderThanDays * DAY;
+        const result = await ctx.api.emr.listClusters({
+            ClusterStates: input?.states && input.states.length ? input.states : DEFAULT_STATES,
+            CreateTimeBefore: threshold
+        });
+        return result.Items;
     }
 };

package/dist/tools/emr/index.js

@@ -3,13 +3,11 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.emrApi = exports.emrTools = void 0;
 const listClusters_1 = require("./listClusters");
 const deleteCluster_1 = require("./deleteCluster");
-const findClustersToCleanup_1 = require("./findClustersToCleanup");
 const createCluster_1 = require("./createCluster");
 const emrApi_1 = require("../../services/emrApi");
 Object.defineProperty(exports, "emrApi", { enumerable: true, get: function () { return emrApi_1.emrApi; } });
 exports.emrTools = {
     listClusters: listClusters_1.listClusters,
     deleteCluster: deleteCluster_1.deleteCluster,
-    findClustersToCleanup: findClustersToCleanup_1.findClustersToCleanup,
     createCluster: createCluster_1.createCluster
 };