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

package/dist/services/volcApi.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("../runtime/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/tools/base.js

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

package/dist/tools/emr/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/emr/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/tools/emr/findClustersToCleanup.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findClustersToCleanup = void 0;
+const zod_1 = require("zod");
+const emrApi_1 = require("../../services/emrApi");
+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: " +
+        emrApi_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(emrApi_1.EmrClusterState)).optional()
+    }),
+    async execute(input, ctx) {
+        return ctx.api.emr.findClustersToCleanup(input || {});
+    }
+};

package/dist/tools/emr/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 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
+};

package/dist/tools/emr/listClusters.js

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

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

package/dist/utils/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/package.json

@@ -0,0 +1,52 @@
+{
+  "name": "@volc-emr/emr-cli",
+  "version": "0.1.0-beta.0",
+  "description": "Minimal controllable CLI Agent for Volcengine EMR OpenAPI: Tool-first + Plan/Execute with LLM-driven planner.",
+  "keywords": [
+    "volcengine",
+    "emr",
+    "cli",
+    "agent",
+    "openapi",
+    "llm",
+    "tool-first",
+    "plan-execute"
+  ],
+  "license": "MIT",
+  "bin": {
+    "volc-emr-agent": "dist/index.js"
+  },
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "dev": "ts-node src/index.ts",
+    "build": "tsc -p tsconfig.json && chmod +x dist/index.js",
+    "start": "node dist/index.js",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "npm run typecheck && npm run build"
+  },
+  "engines": {
+    "node": ">=18"
+  },
+  "publishConfig": {
+    "access": "public",
+    "tag": "beta"
+  },
+  "dependencies": {
+    "@volcengine/openapi": "^1.26.0",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "zod": "^3.23.8",
+    "zod-to-json-schema": "^3.25.2"
+  },
+  "devDependencies": {
+    "@types/node": "^20.11.30",
+    "ts-node": "^10.9.2",
+    "typescript": "^5.4.5"
+  }
+}