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

package/dist/integrations/volc/emr.js

@@ -0,0 +1,177 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.emrApi = exports.CLUSTER_STATES = exports.EmrClusterState = void 0;
+exports.listClusters = listClusters;
+exports.listAllClusters = listAllClusters;
+exports.releaseCluster = releaseCluster;
+exports.createCluster = createCluster;
+exports.findClustersToCleanup = findClustersToCleanup;
+const client_1 = require("./client");
+var EmrClusterState;
+(function (EmrClusterState) {
+    EmrClusterState["PENDING_FOR_PAYMENT"] = "PENDING_FOR_PAYMENT";
+    EmrClusterState["CREATING"] = "CREATING";
+    EmrClusterState["RUNNING"] = "RUNNING";
+    EmrClusterState["WARNING"] = "WARNING";
+    EmrClusterState["EXCEPTION"] = "EXCEPTION";
+    EmrClusterState["RESTORING"] = "RESTORING";
+    EmrClusterState["PAUSING"] = "PAUSING";
+    EmrClusterState["PAUSED"] = "PAUSED";
+    EmrClusterState["TERMINATING"] = "TERMINATING";
+    EmrClusterState["TERMINATED"] = "TERMINATED";
+    EmrClusterState["TERMINATED_WITH_ERROR"] = "TERMINATED_WITH_ERROR";
+    EmrClusterState["FAILED"] = "FAILED";
+    EmrClusterState["SHUTDOWN"] = "SHUTDOWN";
+})(EmrClusterState || (exports.EmrClusterState = EmrClusterState = {}));
+exports.CLUSTER_STATES = Object.values(EmrClusterState);
+function compactBody(input) {
+    const out = {};
+    for (const [k, v] of Object.entries(input)) {
+        if (v === undefined || v === null || v === "")
+            continue;
+        if (Array.isArray(v) && v.length === 0)
+            continue;
+        out[k] = v;
+    }
+    return out;
+}
+function toMs(v) {
+    if (v === undefined || v === null || v === "")
+        return undefined;
+    const n = typeof v === "number" ? v : Number(v);
+    if (!Number.isFinite(n))
+        return undefined;
+    // 10 位 = 秒级，13 位 = 毫秒级，统一转毫秒
+    return n < 1e12 ? Math.trunc(n) * 1000 : Math.trunc(n);
+}
+function toMsString(v) {
+    const ms = toMs(v);
+    return ms === undefined ? undefined : String(ms);
+}
+async function listClusters(params = {}) {
+    const body = compactBody({
+        ClusterName: params.ClusterName,
+        ClusterId: params.ClusterId,
+        ReleaseVersion: params.ReleaseVersion,
+        ProjectName: params.ProjectName,
+        CreateTimeBefore: toMsString(params.CreateTimeBefore),
+        CreateTimeAfter: toMsString(params.CreateTimeAfter),
+        ClusterIds: params.ClusterIds,
+        ClusterTypes: params.ClusterTypes,
+        ClusterStates: params.ClusterStates,
+        ChargeTypes: params.ChargeTypes,
+        Tags: params.Tags,
+        MaxResults: params.MaxResults,
+        NextToken: params.NextToken
+    });
+    const result = await (0, client_1.callEmr)("ListClusters", body);
+    return {
+        Items: Array.isArray(result?.Items) ? result.Items : [],
+        TotalCount: typeof result?.TotalCount === "number" ? result.TotalCount : 0,
+        MaxResults: typeof result?.MaxResults === "number" ? result.MaxResults : 0,
+        NextToken: result?.NextToken || undefined
+    };
+}
+async function listAllClusters(params = {}) {
+    const { hardLimit, NextToken: initialToken, MaxResults, ...rest } = params;
+    const pageSize = Math.min(Math.max(MaxResults ?? 50, 1), 100);
+    const all = [];
+    let token = initialToken;
+    let safety = 0;
+    do {
+        const page = await listClusters({
+            ...rest,
+            MaxResults: pageSize,
+            NextToken: token
+        });
+        all.push(...page.Items);
+        if (hardLimit && all.length >= hardLimit) {
+            return all.slice(0, hardLimit);
+        }
+        token = page.NextToken;
+        safety++;
+        if (safety > 1000) {
+            throw new Error("[listAllClusters] safety break: more than 1000 pages, check NextToken loop");
+        }
+    } while (token);
+    return all;
+}
+function matchArchived(msg) {
+    return /marked\s+archived|could not operate before fixed/i.test(msg);
+}
+function matchNotFound(msg) {
+    return /not\s*found|does\s*not\s*exist|不存在/i.test(msg);
+}
+function matchAlreadyReleased(msg) {
+    return /already\s+released|已释放|已删除/i.test(msg);
+}
+async function releaseCluster(params) {
+    try {
+        const resp = await (0, client_1.callEmr)("ReleaseCluster", params);
+        return {
+            ClusterId: params.ClusterId,
+            OperationId: resp?.OperationId,
+            OperateId: resp?.OperateId,
+            Skipped: false
+        };
+    }
+    catch (e) {
+        const msg = String(e?.message || e);
+        if (matchArchived(msg)) {
+            return {
+                ClusterId: params.ClusterId,
+                Skipped: true,
+                Reason: "ARCHIVED",
+                Message: "集群已被归档（archived），无法再操作；需要联系火山侧解除归档后再释放。"
+            };
+        }
+        if (matchNotFound(msg)) {
+            return {
+                ClusterId: params.ClusterId,
+                Skipped: true,
+                Reason: "NOT_FOUND",
+                Message: "集群不存在（可能已被清理）。"
+            };
+        }
+        if (matchAlreadyReleased(msg)) {
+            return {
+                ClusterId: params.ClusterId,
+                Skipped: true,
+                Reason: "ALREADY_RELEASED",
+                Message: "集群已释放，无需重复操作。"
+            };
+        }
+        throw e;
+    }
+}
+async function createCluster(params) {
+    const body = compactBody({ ...params });
+    const resp = await (0, client_1.callEmr)("CreateCluster", body);
+    return {
+        ClusterId: resp?.ClusterId || "",
+        OperationId: resp?.OperationId
+    };
+}
+const DAY = 86400000;
+const SHUTDOWN_STATES = [
+    EmrClusterState.TERMINATED,
+    EmrClusterState.TERMINATED_WITH_ERROR,
+    EmrClusterState.FAILED,
+    EmrClusterState.SHUTDOWN
+];
+async function findClustersToCleanup({ olderThanDays = 7, states } = {}) {
+    const threshold = Date.now() - olderThanDays * DAY;
+    const targetStates = states && states.length ? states : SHUTDOWN_STATES;
+    const items = await listAllClusters({
+        ClusterStates: targetStates,
+        CreateTimeBefore: threshold
+    });
+    return items;
+}
+exports.emrApi = {
+    listClusters,
+    listAllClusters,
+    releaseCluster,
+    findClustersToCleanup,
+    createCluster
+};

package/dist/integrations/volc/tools/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("../../../shared/confirm");
+const createClusterMemory_1 = require("../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/integrations/volc/tools/deleteCluster.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deleteCluster = void 0;
+const zod_1 = require("zod");
+exports.deleteCluster = {
+    name: "deleteCluster",
+    description: "Release (delete) an EMR cluster via Volcengine OpenAPI (ReleaseCluster)",
+    riskLevel: "high",
+    input: zod_1.z.object({
+        ClusterId: zod_1.z.string().min(1)
+    }),
+    async execute(input, ctx) {
+        return ctx.api.emr.releaseCluster({ ClusterId: input.ClusterId });
+    }
+};

package/dist/integrations/volc/tools/findClustersToCleanup.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findClustersToCleanup = void 0;
+const zod_1 = require("zod");
+const emr_1 = require("../emr");
+exports.findClustersToCleanup = {
+    name: "findClustersToCleanup",
+    description: "Find EMR clusters that are in shutdown-like states and older than N days (default 7). " +
+        "`states` MUST use the official uppercase enum: " +
+        emr_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(emr_1.EmrClusterState)).optional()
+    }),
+    async execute(input, ctx) {
+        return ctx.api.emr.findClustersToCleanup(input || {});
+    }
+};

package/dist/integrations/volc/tools/index.js

@@ -0,0 +1,15 @@
+"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 findClustersToCleanup_1 = require("./findClustersToCleanup");
+const createCluster_1 = require("./createCluster");
+const emr_1 = require("../emr");
+Object.defineProperty(exports, "emrApi", { enumerable: true, get: function () { return emr_1.emrApi; } });
+exports.emrTools = {
+    listClusters: listClusters_1.listClusters,
+    deleteCluster: deleteCluster_1.deleteCluster,
+    findClustersToCleanup: findClustersToCleanup_1.findClustersToCleanup,
+    createCluster: createCluster_1.createCluster
+};

package/dist/integrations/volc/tools/listClusters.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.listClusters = void 0;
+const zod_1 = require("zod");
+const emr_1 = require("../emr");
+const STATE_ALIASES = {
+    "已关停": emr_1.EmrClusterState.SHUTDOWN,
+    "关停": emr_1.EmrClusterState.SHUTDOWN,
+    "运行中": emr_1.EmrClusterState.RUNNING,
+    "已终止": emr_1.EmrClusterState.TERMINATED,
+    "已创建": emr_1.EmrClusterState.RUNNING,
+    "创建中": emr_1.EmrClusterState.CREATING,
+    "失败": emr_1.EmrClusterState.FAILED,
+    "异常": emr_1.EmrClusterState.EXCEPTION,
+    "已停止": emr_1.EmrClusterState.PAUSED,
+    "停止中": emr_1.EmrClusterState.PAUSING
+};
+function normalizeOneState(raw) {
+    if (!raw)
+        return undefined;
+    const upper = raw.toUpperCase();
+    if (emr_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: ${emr_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(emr_1.EmrClusterState);
+exports.listClusters = {
+    name: "listClusters",
+    description: "List EMR clusters via Volcengine OpenAPI (ListClusters). ClusterStates MUST use the official uppercase enum: " +
+        emr_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);
+    }
+};