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

package/dist/index.js

@@ -0,0 +1,182 @@
+#!/usr/bin/env node
+"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 program = new commander_1.Command();
+program
+    .name("volc-emr-agent")
+    .description("Volcengine EMR CLI Agent (real OpenAPI)")
+    .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;
+    (0, config_1.resolveCredentials)();
+    const agent = new agent_1.Agent({
+        api: registry_1.apiRegistry,
+        memory: memory_1.memory
+    });
+    await agent.run(task, {
+        dryRun: opts.dryRun,
+        autoApprove: opts.yes
+    });
+});
+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) {
+        console.log(`Detected existing config: ${(0, config_1.configFilePath)()}`);
+        const ok = await (0, confirm_1.confirm)("Overwrite existing credentials?");
+        if (!ok) {
+            console.log("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) {
+            console.error("Access key is required.");
+            process.exitCode = 1;
+            return;
+        }
+        const secretKey = opts.secretKey ||
+            (await session.ask("VOLC Secret Key", { silent: true }));
+        if (!secretKey) {
+            console.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);
+        console.log(`\n✓ Saved to ${file}`);
+        console.log({
+            accessKey: `${accessKey.slice(0, 4)}****`,
+            secretKey: "********",
+            region,
+            llm: llmEndpoint
+                ? {
+                    endpoint: llmEndpoint,
+                    apiKey: payload.llm.apiKey ? "********" : undefined,
+                    model: payload.llm.model || undefined
+                }
+                : "(not configured)"
+        });
+        console.log("\nTip: 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
+    });
+    console.log(`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
+        }
+    });
+    console.log(`Saved LLM config: ${file}`);
+});
+config
+    .command("show")
+    .description("Show current local config (secrets are masked)")
+    .action(() => {
+    const cfg = (0, config_1.readLocalConfig)();
+    const masked = {
+        ...cfg,
+        accessKey: cfg.accessKey ? `${cfg.accessKey.slice(0, 4)}****` : undefined,
+        secretKey: cfg.secretKey ? "********" : undefined,
+        llm: cfg.llm
+            ? {
+                endpoint: cfg.llm.endpoint,
+                apiKey: cfg.llm.apiKey ? "********" : undefined,
+                model: cfg.llm.model
+            }
+            : undefined
+    };
+    console.log("file:", (0, config_1.configFilePath)());
+    console.log(masked);
+});
+program.parse();

package/dist/runtime/config.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readLocalConfig = readLocalConfig;
+exports.writeLocalConfig = writeLocalConfig;
+exports.clearLlmConfig = clearLlmConfig;
+exports.resolveCredentials = resolveCredentials;
+exports.resolveLlmConfig = resolveLlmConfig;
+exports.configFilePath = configFilePath;
+const fs_1 = __importDefault(require("fs"));
+const os_1 = __importDefault(require("os"));
+const path_1 = __importDefault(require("path"));
+const CONFIG_DIR = process.env.VOLC_EMR_CONFIG_DIR || path_1.default.join(os_1.default.homedir(), ".volc-emr");
+const CONFIG_FILE = path_1.default.join(CONFIG_DIR, "config.json");
+function readLocalConfig() {
+    try {
+        if (!fs_1.default.existsSync(CONFIG_FILE))
+            return {};
+        return JSON.parse(fs_1.default.readFileSync(CONFIG_FILE, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function writeLocalConfig(cfg) {
+    fs_1.default.mkdirSync(CONFIG_DIR, { recursive: true, mode: 0o700 });
+    const prev = readLocalConfig();
+    let mergedLlm;
+    if (cfg.llm === null) {
+        mergedLlm = undefined;
+    }
+    else if (cfg.llm || prev.llm) {
+        mergedLlm = { ...(prev.llm || {}), ...(cfg.llm || {}) };
+    }
+    const merged = { ...prev, ...cfg };
+    if (mergedLlm && Object.keys(mergedLlm).length > 0) {
+        merged.llm = mergedLlm;
+    }
+    else {
+        delete merged.llm;
+    }
+    fs_1.default.writeFileSync(CONFIG_FILE, JSON.stringify(merged, null, 2), {
+        mode: 0o600
+    });
+    return CONFIG_FILE;
+}
+function clearLlmConfig() {
+    return writeLocalConfig({ llm: null });
+}
+function resolveCredentials(cli = {}) {
+    const local = readLocalConfig();
+    const accessKey = cli.accessKey || process.env.VOLC_ACCESSKEY || local.accessKey;
+    const secretKey = cli.secretKey || process.env.VOLC_SECRETKEY || local.secretKey;
+    const region = cli.region || process.env.VOLC_REGION || local.region || "cn-beijing";
+    if (!accessKey || !secretKey) {
+        throw new Error("未找到 Volcengine 凭证。请通过 CLI 参数、环境变量（VOLC_ACCESSKEY/VOLC_SECRETKEY）或本地配置（~/.volc-emr/config.json）提供。");
+    }
+    return { accessKey, secretKey, region };
+}
+function resolveLlmConfig(cli = {}) {
+    const local = readLocalConfig().llm || {};
+    const endpoint = cli.endpoint || process.env.VOLC_LLM_ENDPOINT || local.endpoint;
+    const apiKey = cli.apiKey || process.env.VOLC_LLM_API_KEY || local.apiKey;
+    const model = cli.model || process.env.VOLC_LLM_MODEL || local.model;
+    if (!endpoint)
+        return null;
+    return { endpoint, apiKey, model };
+}
+function configFilePath() {
+    return CONFIG_FILE;
+}

package/dist/runtime/confirm.js

@@ -0,0 +1,92 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.confirm = confirm;
+exports.createPromptSession = createPromptSession;
+const readline_1 = __importDefault(require("readline"));
+function createLineSource() {
+    const stdin = process.stdin;
+    stdin.setEncoding("utf8");
+    let buffer = "";
+    const queue = [];
+    const waiters = [];
+    let ended = false;
+    const flush = () => {
+        let idx;
+        while ((idx = buffer.indexOf("\n")) !== -1) {
+            const line = buffer.slice(0, idx).replace(/\r$/, "");
+            buffer = buffer.slice(idx + 1);
+            const w = waiters.shift();
+            if (w)
+                w(line);
+            else
+                queue.push(line);
+        }
+    };
+    stdin.on("data", (chunk) => {
+        buffer += chunk;
+        flush();
+    });
+    stdin.on("end", () => {
+        ended = true;
+        if (buffer.length) {
+            const w = waiters.shift();
+            if (w)
+                w(buffer);
+            else
+                queue.push(buffer);
+            buffer = "";
+        }
+        while (waiters.length) {
+            const w = waiters.shift();
+            w && w("");
+        }
+    });
+    return {
+        nextLine() {
+            if (queue.length)
+                return Promise.resolve(queue.shift());
+            if (ended)
+                return Promise.resolve("");
+            return new Promise((resolve) => waiters.push(resolve));
+        },
+        stop() {
+            stdin.pause();
+        }
+    };
+}
+function confirm(question) {
+    const rl = readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout
+    });
+    return new Promise((resolve) => {
+        rl.question(`${question} (y/n): `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === "y");
+        });
+    });
+}
+function createPromptSession() {
+    const source = createLineSource();
+    process.stdin.resume();
+    return {
+        async ask(question, options = {}) {
+            const { defaultValue, silent } = options;
+            const label = defaultValue
+                ? `${question} [${defaultValue}]: `
+                : `${question}: `;
+            process.stdout.write(label);
+            const line = await source.nextLine();
+            const value = (line || "").trim();
+            if (silent)
+                process.stdout.write("\n");
+            return value || defaultValue || "";
+        },
+        close() {
+            source.stop();
+        }
+    };
+}

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

package/dist/runtime/llm.js

@@ -0,0 +1,64 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chatCompletion = chatCompletion;
+const https_1 = __importDefault(require("https"));
+const http_1 = __importDefault(require("http"));
+const url_1 = require("url");
+async function chatCompletion(llm, options) {
+    if (!llm.endpoint)
+        throw new Error("LLM endpoint is not configured");
+    const body = {
+        model: llm.model || "default",
+        messages: options.messages,
+        temperature: options.temperature ?? 0
+    };
+    if (options.jsonMode) {
+        body.response_format = { type: "json_object" };
+    }
+    const payload = JSON.stringify(body);
+    const url = new url_1.URL(llm.endpoint);
+    const headers = {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(payload).toString()
+    };
+    if (llm.apiKey)
+        headers["Authorization"] = `Bearer ${llm.apiKey}`;
+    const client = url.protocol === "https:" ? https_1.default : http_1.default;
+    return new Promise((resolve, reject) => {
+        const req = client.request({
+            method: "POST",
+            hostname: url.hostname,
+            port: url.port || (url.protocol === "https:" ? 443 : 80),
+            path: `${url.pathname}${url.search}`,
+            headers
+        }, (res) => {
+            const chunks = [];
+            res.on("data", (c) => chunks.push(c));
+            res.on("end", () => {
+                const raw = Buffer.concat(chunks).toString("utf-8");
+                if ((res.statusCode || 500) >= 400) {
+                    reject(new Error(`LLM HTTP ${res.statusCode}: ${raw}`));
+                    return;
+                }
+                try {
+                    const json = JSON.parse(raw);
+                    const content = json?.choices?.[0]?.message?.content;
+                    if (typeof content !== "string") {
+                        reject(new Error(`Unexpected LLM response shape: ${raw.slice(0, 200)}`));
+                        return;
+                    }
+                    resolve(content);
+                }
+                catch (e) {
+                    reject(new Error(`Parse LLM response failed: ${e.message}`));
+                }
+            });
+        });
+        req.on("error", reject);
+        req.write(payload);
+        req.end();
+    });
+}

package/dist/runtime/logger.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logStep = logStep;
+function logStep(i, msg, data) {
+    console.log(`Step ${i + 1}: ${msg}`);
+    if (data)
+        console.log("  ↳", data);
+}

package/dist/runtime/memory.js

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

package/dist/services/emrApi.js

@@ -0,0 +1,181 @@
+"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 volcApi_1 = require("./volcApi");
+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
+    });
+    console.log(body);
+    const result = await (0, volcApi_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, volcApi_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 });
+    console.log("createCluster params:", params);
+    console.log(body);
+    const resp = await (0, volcApi_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
+    });
+    console.log(items);
+    return items;
+}
+exports.emrApi = {
+    listClusters,
+    listAllClusters,
+    releaseCluster,
+    findClustersToCleanup,
+    createCluster
+};