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

package/dist/services/ecsApi.js

@@ -0,0 +1,159 @@
+"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;
+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
+    });
+    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 });
+    const resp = await (0, volcApi_1.callEmr)("CreateCluster", body);
+    return {
+        ClusterId: resp?.ClusterId || "",
+        OperationId: resp?.OperationId
+    };
+}
+exports.emrApi = {
+    listClusters,
+    listAllClusters,
+    releaseCluster,
+    createCluster
+};

package/dist/services/emrApi.js

@@ -5,7 +5,6 @@ exports.listClusters = listClusters;
 exports.listAllClusters = listAllClusters;
 exports.releaseCluster = releaseCluster;
 exports.createCluster = createCluster;
-exports.findClustersToCleanup = findClustersToCleanup;
 const volcApi_1 = require("./volcApi");
 var EmrClusterState;
 (function (EmrClusterState) {
@@ -152,26 +151,9 @@ async function createCluster(params) {
         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/shared/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/shared/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/shared/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/shared/logger.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ui = void 0;
+exports.logStep = logStep;
+const useColor = process.stdout.isTTY && process.env.NO_COLOR === undefined && process.env.TERM !== "dumb";
+const c = (code) => (s) => (useColor ? `\x1b[${code}m${s}\x1b[0m` : s);
+const color = {
+    gray: c("90"),
+    red: c("31"),
+    green: c("32"),
+    yellow: c("33"),
+    blue: c("34"),
+    magenta: c("35"),
+    cyan: c("36"),
+    bold: c("1"),
+    dim: c("2")
+};
+const SYM = {
+    info: "ℹ",
+    success: "✔",
+    warn: "⚠",
+    error: "✘",
+    skip: "⊘",
+    arrow: "→",
+    bullet: "•"
+};
+function write(line) {
+    process.stdout.write(line.endsWith("\n") ? line : line + "\n");
+}
+function formatInline(val) {
+    if (val === undefined)
+        return "";
+    if (typeof val === "string")
+        return val;
+    try {
+        return JSON.stringify(val);
+    }
+    catch {
+        return String(val);
+    }
+}
+function formatFull(val) {
+    if (val === undefined)
+        return "";
+    if (typeof val === "string")
+        return val;
+    try {
+        return JSON.stringify(val, null, 2);
+    }
+    catch {
+        return String(val);
+    }
+}
+exports.ui = {
+    info(msg) {
+        write(`${color.cyan(SYM.info)} ${msg}`);
+    },
+    success(msg) {
+        write(`${color.green(SYM.success)} ${msg}`);
+    },
+    warn(msg) {
+        write(`${color.yellow(SYM.warn)} ${msg}`);
+    },
+    error(msg) {
+        write(`${color.red(SYM.error)} ${msg}`);
+    },
+    skip(msg) {
+        write(`${color.yellow(SYM.skip)} ${msg}`);
+    },
+    dim(msg) {
+        write(color.dim(msg));
+    },
+    kv(key, value) {
+        write(`  ${color.gray(key + ":")} ${formatInline(value)}`);
+    },
+    section(title) {
+        write("");
+        write(color.bold(title));
+    },
+    divider() {
+        write(color.dim("─".repeat(48)));
+    },
+    raw(msg) {
+        write(msg);
+    },
+    json(value) {
+        write(typeof value === "string" ? value : JSON.stringify(value, null, 2));
+    }
+};
+function logStep(i, status, toolName, extra) {
+    const idx = color.gray(`[${i + 1}]`);
+    if (status === "run") {
+        const suffix = extra?.input ? color.dim(` ${formatInline(extra.input)}`) : "";
+        write(`${idx} ${color.blue(SYM.arrow)} ${color.bold(toolName)}${suffix}`);
+        return;
+    }
+    if (status === "done") {
+        write(`${idx} ${color.green(SYM.success)} ${toolName}`);
+        if (extra?.output !== undefined) {
+            const out = extra.output;
+            if (out && typeof out === "object" && out.Skipped) {
+                exports.ui.kv("skipped", out.Reason || "true");
+                if (out.Message)
+                    exports.ui.kv("message", out.Message);
+            }
+            else {
+                write(color.dim(formatFull(extra.output)));
+            }
+        }
+        return;
+    }
+    if (status === "skip") {
+        const reason = extra?.reason ? ` (${extra.reason})` : "";
+        write(`${idx} ${color.yellow(SYM.skip)} ${toolName}${color.dim(reason)}`);
+        return;
+    }
+    if (status === "fail") {
+        write(`${idx} ${color.red(SYM.error)} ${toolName}`);
+        if (extra?.error)
+            exports.ui.kv("error", extra.error);
+    }
+}

package/dist/shared/memory.js

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

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();