zerocut-cli 0.1.0

package/dist/services/cerevox.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SESSION_SYMBOL = void 0;
+exports.attachSessionToCommand = attachSessionToCommand;
+exports.getSessionFromCommand = getSessionFromCommand;
+exports.getApiKey = getApiKey;
+exports.getRegion = getRegion;
+exports.openSession = openSession;
+exports.closeSession = closeSession;
+exports.getMaterialUri = getMaterialUri;
+exports.syncToTOS = syncToTOS;
+exports.runFFMpegCommand = runFFMpegCommand;
+exports.runPandocCommand = runPandocCommand;
+const cerevox_1 = require("cerevox");
+const node_crypto_1 = require("node:crypto");
+const config_1 = require("./config");
+const node_fs_1 = require("node:fs");
+const node_path_1 = require("node:path");
+const promises_1 = require("node:fs/promises");
+exports.SESSION_SYMBOL = Symbol("zerocut.session");
+function attachSessionToCommand(cmd, session) {
+    cmd[exports.SESSION_SYMBOL] = session;
+}
+function getSessionFromCommand(cmd) {
+    return cmd[exports.SESSION_SYMBOL];
+}
+function getApiKey() {
+    const v = (0, config_1.getConfigValueSync)("apiKey");
+    return typeof v === "string" ? v : "";
+}
+function getRegion() {
+    const v = (0, config_1.getConfigValueSync)("region");
+    return v;
+}
+async function openSession() {
+    let apiKey = getApiKey();
+    if (!apiKey) {
+        throw new Error("apiKey is not set");
+    }
+    const region = getRegion();
+    apiKey = region + apiKey.slice(2);
+    const cerevox = new cerevox_1.Cerevox({
+        apiKey,
+    });
+    let sandboxId = (0, config_1.getConfigValueSync)("sandboxId");
+    if (sandboxId) {
+        try {
+            return await cerevox.connect(sandboxId, 300000);
+        }
+        catch {
+            sandboxId = undefined;
+        }
+    }
+    const session = await cerevox.launch({ timeout: 60, region });
+    sandboxId = session.sandbox.sandboxId;
+    (0, config_1.setConfigValueSync)("sandboxId", sandboxId);
+    return session;
+}
+async function closeSession(session) {
+    await session.close();
+}
+async function computeSha256(filePath) {
+    return new Promise((resolve, reject) => {
+        const hash = (0, node_crypto_1.createHash)("sha256");
+        const stream = (0, node_fs_1.createReadStream)(filePath);
+        stream.on("data", (chunk) => hash.update(chunk));
+        stream.on("error", reject);
+        stream.on("end", () => resolve(hash.digest("hex")));
+    });
+}
+async function getMaterialUri(session, fileName, options = {}) {
+    const resolvedOptions = {
+        fileSizeLimit: options.fileSizeLimit ?? -1,
+    };
+    const localPath = (0, node_path_1.resolve)(fileName);
+    const hash = await computeSha256(localPath);
+    const url = session.sandbox.getUrl(`/zerocut/${session.terminal.id}/materials/${(0, node_path_1.basename)(fileName)}`);
+    // check url avaliable，用 HEAD 请求检查是否存在
+    const res = await fetch(url, {
+        method: "HEAD",
+    });
+    if (res.status === 404 || hash !== res.headers.get("X-Content-Hash")) {
+        if (resolvedOptions.fileSizeLimit > 0) {
+            const stats = await (0, promises_1.stat)(localPath);
+            const fileSizeMb = stats.size / (1024 * 1024);
+            if (fileSizeMb > resolvedOptions.fileSizeLimit) {
+                throw new Error(`文件太大：${fileName} (${fileSizeMb.toFixed(2)}MB)，限制为 ${resolvedOptions.fileSizeLimit}MB`);
+            }
+        }
+        const saveToPath = `/home/user/cerevox-zerocut/projects/${session.terminal.id}/materials/${fileName}`;
+        const files = session.files;
+        await files.upload(localPath, saveToPath);
+    }
+    else if (res.status > 299) {
+        throw new Error(`Failed to get material from ${url}. Details: ${res.statusText}`);
+    }
+    return url;
+}
+const node_fs_2 = require("node:fs");
+const node_os_1 = require("node:os");
+const node_path_2 = require("node:path");
+const promises_2 = require("node:stream/promises");
+const node_fs_3 = require("node:fs");
+async function syncToTOS(url) {
+    const api = "https://api.zerocut.cn/api/v1/upload/material";
+    const apiKey = getApiKey();
+    const fileRes = await fetch(url);
+    if (!fileRes.ok || !fileRes.body) {
+        throw new Error("Failed to fetch source file");
+    }
+    const contentType = fileRes.headers.get("content-type") || "application/octet-stream";
+    const map = {
+        "audio/mpeg": "mp3",
+        "audio/mpga": "mp3",
+        "audio/wav": "wav",
+        "audio/x-wav": "wav",
+        "audio/flac": "flac",
+        "audio/ogg": "ogg",
+        "audio/webm": "webm",
+        "video/mp4": "mp4",
+        "video/mpeg": "mp4",
+        "video/quicktime": "mov",
+        "video/webm": "webm",
+        "image/png": "png",
+        "image/jpeg": "jpg",
+        "image/jpg": "jpg",
+        "image/webp": "webp",
+        "image/gif": "gif",
+        "application/pdf": "pdf",
+    };
+    let ext = map[contentType] || "";
+    if (!ext) {
+        try {
+            const u = new URL(url);
+            const p = u.pathname;
+            const i = p.lastIndexOf(".");
+            if (i !== -1 && i < p.length - 1) {
+                const e = p.substring(i + 1).toLowerCase();
+                if (/^[a-z0-9]{2,5}$/.test(e))
+                    ext = e;
+            }
+        }
+        catch { }
+    }
+    if (!ext)
+        ext = "bin";
+    const tempPath = (0, node_path_2.join)((0, node_os_1.tmpdir)(), `upload-${Date.now()}.${ext}`);
+    try {
+        await (0, promises_2.pipeline)(fileRes.body, (0, node_fs_3.createWriteStream)(tempPath));
+        const fileBuffer = await node_fs_2.promises.readFile(tempPath);
+        const fileName = `file.${ext}`;
+        const file = new File([fileBuffer], fileName, { type: contentType });
+        const formData = new FormData();
+        formData.append("file", file);
+        const res = await fetch(api, {
+            method: "POST",
+            headers: {
+                Authorization: `Bearer ${apiKey}`,
+            },
+            body: formData,
+        });
+        if (!res.ok) {
+            throw new Error(`Failed to upload to TOS: ${res.statusText}`);
+        }
+        const result = await res.json();
+        return result?.data?.url;
+    }
+    finally {
+        await node_fs_2.promises.unlink(tempPath).catch(() => { });
+    }
+}
+async function runFFMpegCommand(session, command, resources = []) {
+    // 验证命令只能是 ffmpeg 或 ffprobe
+    const trimmedCommand = command.trim();
+    if (!trimmedCommand.startsWith("ffmpeg") && !trimmedCommand.startsWith("ffprobe")) {
+        throw new Error("Only ffmpeg and ffprobe commands are allowed");
+    }
+    const terminal = session.terminal;
+    // 自动添加 -y 参数以避免交互式确认导致命令卡住
+    let finalCommand = trimmedCommand;
+    if (trimmedCommand.startsWith("ffmpeg") && !trimmedCommand.includes(" -y")) {
+        // 在 ffmpeg 后面插入 -y 参数
+        finalCommand = trimmedCommand.replace(/^ffmpeg/, "ffmpeg -y");
+    }
+    // 将 resources 中的文件同步到沙箱 materials 目录
+    await Promise.all(resources.map((resource) => {
+        return getMaterialUri(session, resource);
+    }));
+    // 构建工作目录路径 - materials 目录
+    const workDir = `/home/user/cerevox-zerocut/projects/${terminal.id}/materials`;
+    // 执行命令，用一个独立的命令行以免影响当前会话的cwd
+    const response = await terminal.create().run(finalCommand, {
+        cwd: workDir,
+    });
+    const outputFilePath = trimmedCommand.startsWith("ffmpeg")
+        ? finalCommand.split(" ").pop() || ""
+        : "";
+    const sandboxFilePath = (0, node_path_2.join)(workDir, outputFilePath);
+    // 等待命令完成
+    const result = await response.json();
+    if (result.exitCode === 0 && outputFilePath) {
+        const savePath = (0, node_path_2.join)(process.cwd(), (0, node_path_1.basename)(outputFilePath));
+        console.log(sandboxFilePath, savePath);
+        const files = session.files;
+        await files.download(sandboxFilePath, savePath);
+    }
+    return {
+        exitCode: result.exitCode,
+        outputFilePath,
+        data: {
+            stdout: result.stdout || (!result.exitCode && result.stderr) || "",
+            stderr: result.exitCode ? result.stderr : undefined,
+        },
+    };
+}
+function getPandocOutputFilePath(command) {
+    const inlineMatch = command.match(/(?:^|\s)--output=("[^"]+"|'[^']+'|[^\s]+)/);
+    if (inlineMatch?.[1]) {
+        return inlineMatch[1].replace(/^["']|["']$/g, "");
+    }
+    const outputMatch = command.match(/(?:^|\s)(?:-o|--output)\s+("[^"]+"|'[^']+'|[^\s]+)/);
+    if (outputMatch?.[1]) {
+        return outputMatch[1].replace(/^["']|["']$/g, "");
+    }
+    return "";
+}
+async function runPandocCommand(session, command, resources = []) {
+    const trimmedCommand = command.trim();
+    if (!trimmedCommand.startsWith("pandoc")) {
+        throw new Error("Only pandoc command is allowed");
+    }
+    const terminal = session.terminal;
+    await Promise.all(resources.map((resource) => {
+        return getMaterialUri(session, resource);
+    }));
+    const workDir = `/home/user/cerevox-zerocut/projects/${terminal.id}/materials`;
+    const response = await terminal.create().run(trimmedCommand, {
+        cwd: workDir,
+    });
+    const outputFilePath = getPandocOutputFilePath(trimmedCommand);
+    const sandboxFilePath = outputFilePath ? (0, node_path_2.join)(workDir, outputFilePath) : "";
+    const result = await response.json();
+    if (result.exitCode === 0 && outputFilePath) {
+        const savePath = (0, node_path_2.join)(process.cwd(), (0, node_path_1.basename)(outputFilePath));
+        const files = session.files;
+        await files.download(sandboxFilePath, savePath);
+    }
+    return {
+        exitCode: result.exitCode,
+        outputFilePath,
+        data: {
+            stdout: result.stdout || (!result.exitCode && result.stderr) || "",
+            stderr: result.exitCode ? result.stderr : undefined,
+        },
+    };
+}

package/dist/services/commandLoader.d.ts

@@ -0,0 +1,3 @@
+import { Command } from "commander";
+export declare function loadBuiltInCommands(program: Command): void;
+export declare function loadExternalCommandsAsync(program: Command, dir?: string): Promise<void>;

package/dist/services/commandLoader.js

@@ -0,0 +1,80 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadBuiltInCommands = loadBuiltInCommands;
+exports.loadExternalCommandsAsync = loadExternalCommandsAsync;
+const help_1 = require("../commands/help");
+const image_1 = require("../commands/image");
+const config_1 = require("../commands/config");
+const video_1 = require("../commands/video");
+const music_1 = require("../commands/music");
+const tts_1 = require("../commands/tts");
+const ffmpeg_1 = require("../commands/ffmpeg");
+const pandoc_1 = require("../commands/pandoc");
+const skill_1 = require("../commands/skill");
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+function loadBuiltInCommands(program) {
+    (0, help_1.register)(program);
+    (0, config_1.register)(program);
+    (0, image_1.register)(program);
+    (0, video_1.register)(program);
+    (0, music_1.register)(program);
+    (0, tts_1.register)(program);
+    (0, ffmpeg_1.register)(program);
+    (0, pandoc_1.register)(program);
+    (0, skill_1.register)(program);
+}
+async function loadExternalCommandsAsync(program, dir) {
+    const d = dir ?? process.env.ZEROCUT_COMMANDS_DIR;
+    if (!d)
+        return;
+    if (!node_fs_1.default.existsSync(d))
+        return;
+    const files = node_fs_1.default.readdirSync(d).filter((f) => f.endsWith(".js") || f.endsWith(".cjs"));
+    for (const f of files) {
+        const full = node_path_1.default.join(d, f);
+        try {
+            const mod = (await Promise.resolve(`${full}`).then(s => __importStar(require(s))));
+            const fn = mod.register ?? mod.default;
+            if (typeof fn === "function")
+                fn(program);
+        }
+        catch { }
+    }
+}

package/dist/services/config.d.ts

@@ -0,0 +1,15 @@
+import type { Command } from "commander";
+export interface ZerocutConfig {
+    apiKey: string;
+    region?: "us" | "cn";
+}
+export declare function configPath(): string;
+export declare function readConfig(): Promise<Partial<ZerocutConfig>>;
+export declare function readConfigSync(): Partial<ZerocutConfig>;
+export declare function writeConfig(update: Partial<ZerocutConfig>): Promise<Partial<ZerocutConfig>>;
+export declare function getConfigValueSync(key: string): unknown;
+export declare function getConfigValue(key: string): Promise<unknown>;
+export declare function setConfigValueSync(key: string, value: unknown): void;
+export declare function setConfigValue(key: string, value: unknown): Promise<void>;
+export declare function ensureConfig(): Promise<boolean>;
+export declare function applyConfigInterceptor(program: Command): void;

package/dist/services/config.js

@@ -0,0 +1,235 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.configPath = configPath;
+exports.readConfig = readConfig;
+exports.readConfigSync = readConfigSync;
+exports.writeConfig = writeConfig;
+exports.getConfigValueSync = getConfigValueSync;
+exports.getConfigValue = getConfigValue;
+exports.setConfigValueSync = setConfigValueSync;
+exports.setConfigValue = setConfigValue;
+exports.ensureConfig = ensureConfig;
+exports.applyConfigInterceptor = applyConfigInterceptor;
+const node_os_1 = __importDefault(require("node:os"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+const promises_1 = __importDefault(require("node:fs/promises"));
+const cerevox_1 = require("./cerevox");
+function configPath() {
+    return node_path_1.default.join(node_os_1.default.homedir(), ".zerocut", "config.json");
+}
+function configFallbackPath() {
+    return node_path_1.default.join(process.cwd(), ".zerocut", "config.json");
+}
+async function readJson(file) {
+    try {
+        const buf = await promises_1.default.readFile(file, "utf8");
+        return JSON.parse(buf);
+    }
+    catch {
+        return {};
+    }
+}
+function readJsonSync(file) {
+    try {
+        const buf = node_fs_1.default.readFileSync(file, "utf8");
+        return JSON.parse(buf);
+    }
+    catch {
+        return {};
+    }
+}
+async function writeJson(file, data) {
+    const dir = node_path_1.default.dirname(file);
+    try {
+        await promises_1.default.mkdir(dir, { recursive: true });
+        await promises_1.default.writeFile(file, JSON.stringify(data, null, 2), "utf8");
+        return;
+    }
+    catch (e) {
+        const code = e.code;
+        if (code !== "EPERM" && code !== "EACCES")
+            throw e;
+    }
+    const fb = configFallbackPath();
+    const fdir = node_path_1.default.dirname(fb);
+    await promises_1.default.mkdir(fdir, { recursive: true });
+    await promises_1.default.writeFile(fb, JSON.stringify(data, null, 2), "utf8");
+}
+async function readConfig() {
+    const primary = configPath();
+    try {
+        await promises_1.default.access(primary);
+        return (await readJson(primary));
+    }
+    catch {
+        const fb = configFallbackPath();
+        try {
+            await promises_1.default.access(fb);
+            return (await readJson(fb));
+        }
+        catch {
+            return {};
+        }
+    }
+}
+function readConfigSync() {
+    const primary = configPath();
+    if (node_fs_1.default.existsSync(primary))
+        return readJsonSync(primary);
+    const fb = configFallbackPath();
+    if (node_fs_1.default.existsSync(fb))
+        return readJsonSync(fb);
+    return {};
+}
+async function writeConfig(update) {
+    const file = configPath();
+    const current = (await readJson(file));
+    const next = { ...current, ...update };
+    await writeJson(file, next);
+    return next;
+}
+function splitKeyPath(key) {
+    return key
+        .split(".")
+        .map((s) => s.trim())
+        .filter((s) => s.length > 0);
+}
+function deepGet(obj, segments) {
+    let cur = obj;
+    for (const seg of segments) {
+        if (typeof cur !== "object" || cur === null)
+            return undefined;
+        const rec = cur;
+        cur = rec[seg];
+    }
+    return cur;
+}
+function deepSet(obj, segments, value) {
+    let cur = obj;
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        const isLast = i === segments.length - 1;
+        if (isLast) {
+            cur[seg] = value;
+        }
+        else {
+            const next = cur[seg];
+            if (typeof next !== "object" || next === null) {
+                const created = {};
+                cur[seg] = created;
+                cur = created;
+            }
+            else {
+                cur = next;
+            }
+        }
+    }
+}
+function getConfigValueSync(key) {
+    const primary = configPath();
+    const fb = configFallbackPath();
+    const data = node_fs_1.default.existsSync(primary)
+        ? readJsonSync(primary)
+        : node_fs_1.default.existsSync(fb)
+            ? readJsonSync(fb)
+            : {};
+    return deepGet(data, splitKeyPath(key));
+}
+async function getConfigValue(key) {
+    const primary = configPath();
+    try {
+        await promises_1.default.access(primary);
+        const data = (await readJson(primary));
+        return deepGet(data, splitKeyPath(key));
+    }
+    catch {
+        const fb = configFallbackPath();
+        try {
+            await promises_1.default.access(fb);
+            const data = (await readJson(fb));
+            return deepGet(data, splitKeyPath(key));
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+function writeJsonSync(file, data) {
+    const dir = node_path_1.default.dirname(file);
+    try {
+        node_fs_1.default.mkdirSync(dir, { recursive: true });
+        node_fs_1.default.writeFileSync(file, JSON.stringify(data, null, 2), "utf8");
+        return;
+    }
+    catch (e) {
+        const code = e.code;
+        if (code !== "EPERM" && code !== "EACCES")
+            throw e;
+    }
+    const fb = configFallbackPath();
+    const fdir = node_path_1.default.dirname(fb);
+    node_fs_1.default.mkdirSync(fdir, { recursive: true });
+    node_fs_1.default.writeFileSync(fb, JSON.stringify(data, null, 2), "utf8");
+}
+function setConfigValueSync(key, value) {
+    const file = configPath();
+    const data = readJsonSync(file);
+    deepSet(data, splitKeyPath(key), value);
+    writeJsonSync(file, data);
+}
+async function setConfigValue(key, value) {
+    const file = configPath();
+    const data = (await readJson(file));
+    deepSet(data, splitKeyPath(key), value);
+    await writeJson(file, data);
+}
+async function ensureConfig() {
+    const apiKey = getConfigValueSync("apiKey");
+    const region = getConfigValueSync("region");
+    const missing = [];
+    if (typeof apiKey !== "string" || apiKey.trim().length === 0)
+        missing.push("apiKey");
+    if (missing.length > 0) {
+        process.stderr.write(`Missing required configuration: ${missing.join(", ")}\nConfigure using:\n  zerocut config key <key>\n  or:\n  zerocut config --ott <token> --region <cn|us>\n`);
+        return false;
+    }
+    if (region !== "us" && region !== "cn") {
+        setConfigValueSync("region", "us");
+    }
+    return true;
+}
+function applyConfigInterceptor(program) {
+    program.hook("preAction", async (thisCommand, actionCommand) => {
+        const current = (actionCommand ?? thisCommand);
+        const name = current?.name?.();
+        const parentName = current?.parent?.name?.();
+        if (name === "help" || name === "skill" || name === "config" || parentName === "config")
+            return;
+        const ok = await ensureConfig();
+        if (!ok) {
+            process.exit(1);
+            return;
+        }
+        const session = await (0, cerevox_1.openSession)();
+        if (actionCommand) {
+            (0, cerevox_1.attachSessionToCommand)(actionCommand, session);
+        }
+    });
+    program.hook("postAction", async (thisCommand, actionCommand) => {
+        const name = actionCommand?.name?.() ?? thisCommand?.name?.();
+        if (name === "help" || name === "skill")
+            return;
+        try {
+            const cmd = (actionCommand ?? thisCommand);
+            const session = cmd?.[cerevox_1.SESSION_SYMBOL];
+            if (session)
+                await (0, cerevox_1.closeSession)(session);
+            process.exit(0);
+        }
+        catch { }
+    });
+}