zerocut-cli 0.1.0

package/src/services/cerevox.ts

@@ -0,0 +1,296 @@
+import { Cerevox, type Session } from "cerevox";
+import { createHash } from "node:crypto";
+import { getConfigValueSync, setConfigValueSync } from "./config";
+import { createReadStream } from "node:fs";
+import { resolve, basename } from "node:path";
+import { stat } from "node:fs/promises";
+
+export const SESSION_SYMBOL = Symbol("zerocut.session");
+
+export function attachSessionToCommand(cmd: { [k: symbol]: unknown }, session: Session): void {
+  cmd[SESSION_SYMBOL] = session as unknown;
+}
+
+export function getSessionFromCommand(cmd: { [k: symbol]: unknown }): Session | undefined {
+  return cmd[SESSION_SYMBOL] as Session | undefined;
+}
+
+export function getApiKey(): string {
+  const v = getConfigValueSync("apiKey");
+  return typeof v === "string" ? v : "";
+}
+
+export function getRegion(): "cn" | "us" {
+  const v = getConfigValueSync("region") as "cn" | "us";
+  return v;
+}
+
+export async function openSession(): Promise<Session> {
+  let apiKey = getApiKey();
+  if (!apiKey) {
+    throw new Error("apiKey is not set");
+  }
+  const region = getRegion();
+  apiKey = region + apiKey.slice(2);
+  const cerevox = new Cerevox({
+    apiKey,
+  });
+  let sandboxId = getConfigValueSync("sandboxId") as string | undefined;
+  if (sandboxId) {
+    try {
+      return await cerevox.connect(sandboxId, 300_000);
+    } catch {
+      sandboxId = undefined;
+    }
+  }
+  const session = await cerevox.launch({ timeout: 60, region });
+  sandboxId = session.sandbox.sandboxId!;
+  setConfigValueSync("sandboxId", sandboxId);
+  return session;
+}
+
+export async function closeSession(session: Session) {
+  await session.close();
+}
+
+async function computeSha256(filePath: string): Promise<string> {
+  return new Promise((resolve, reject) => {
+    const hash = createHash("sha256");
+    const stream = createReadStream(filePath);
+    stream.on("data", (chunk) => hash.update(chunk));
+    stream.on("error", reject);
+    stream.on("end", () => resolve(hash.digest("hex")));
+  });
+}
+
+interface GetMaterialUriOptions {
+  fileSizeLimit?: number;
+}
+
+export async function getMaterialUri(
+  session: Session,
+  fileName: string,
+  options: GetMaterialUriOptions = {}
+): Promise<string> {
+  const resolvedOptions: Required<GetMaterialUriOptions> = {
+    fileSizeLimit: options.fileSizeLimit ?? -1,
+  };
+  const localPath = resolve(fileName);
+  const hash = await computeSha256(localPath);
+  const url = session.sandbox.getUrl(
+    `/zerocut/${session.terminal.id}/materials/${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 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;
+}
+
+import { promises as fs } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { pipeline } from "node:stream/promises";
+import { createWriteStream } from "node:fs";
+
+export async function syncToTOS(url: string): Promise<string> {
+  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: Record<string, string> = {
+    "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 = join(tmpdir(), `upload-${Date.now()}.${ext}`);
+
+  try {
+    await pipeline(fileRes.body as any, createWriteStream(tempPath));
+
+    const fileBuffer = await fs.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 fs.unlink(tempPath).catch(() => {});
+  }
+}
+
+export async function runFFMpegCommand(
+  session: Session,
+  command: string,
+  resources: string[] = []
+) {
+  // 验证命令只能是 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 = join(workDir, outputFilePath);
+
+  // 等待命令完成
+  const result = await response.json();
+  if (result.exitCode === 0 && outputFilePath) {
+    const savePath = join(process.cwd(), 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: string): string {
+  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 "";
+}
+
+export async function runPandocCommand(
+  session: Session,
+  command: string,
+  resources: string[] = []
+) {
+  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 ? join(workDir, outputFilePath) : "";
+
+  const result = await response.json();
+  if (result.exitCode === 0 && outputFilePath) {
+    const savePath = join(process.cwd(), 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/src/services/commandLoader.ts

@@ -0,0 +1,42 @@
+import { Command } from "commander";
+import { register as registerHelp } from "../commands/help";
+import { register as registerImage } from "../commands/image";
+import { register as registerConfig } from "../commands/config";
+import { register as registerVideo } from "../commands/video";
+import { register as registerMusic } from "../commands/music";
+import { register as registerTts } from "../commands/tts";
+import { register as registerFfmpeg } from "../commands/ffmpeg";
+import { register as registerPandoc } from "../commands/pandoc";
+import { register as registerSkill } from "../commands/skill";
+import fs from "node:fs";
+import path from "node:path";
+
+export function loadBuiltInCommands(program: Command): void {
+  registerHelp(program);
+  registerConfig(program);
+  registerImage(program);
+  registerVideo(program);
+  registerMusic(program);
+  registerTts(program);
+  registerFfmpeg(program);
+  registerPandoc(program);
+  registerSkill(program);
+}
+
+export async function loadExternalCommandsAsync(program: Command, dir?: string): Promise<void> {
+  const d = dir ?? process.env.ZEROCUT_COMMANDS_DIR;
+  if (!d) return;
+  if (!fs.existsSync(d)) return;
+  const files = fs.readdirSync(d).filter((f) => f.endsWith(".js") || f.endsWith(".cjs"));
+  for (const f of files) {
+    const full = path.join(d, f);
+    try {
+      const mod = (await import(full)) as {
+        register?: (p: Command) => void;
+        default?: (p: Command) => void;
+      };
+      const fn = mod.register ?? mod.default;
+      if (typeof fn === "function") fn(program);
+    } catch {}
+  }
+}

package/src/services/config.ts

@@ -0,0 +1,230 @@
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+import fsp from "node:fs/promises";
+import type { Command } from "commander";
+import { openSession, closeSession, attachSessionToCommand, SESSION_SYMBOL } from "./cerevox";
+
+export interface ZerocutConfig {
+  apiKey: string;
+  region?: "us" | "cn";
+}
+
+export function configPath(): string {
+  return path.join(os.homedir(), ".zerocut", "config.json");
+}
+
+function configFallbackPath(): string {
+  return path.join(process.cwd(), ".zerocut", "config.json");
+}
+
+async function readJson(file: string): Promise<Record<string, unknown>> {
+  try {
+    const buf = await fsp.readFile(file, "utf8");
+    return JSON.parse(buf);
+  } catch {
+    return {};
+  }
+}
+
+function readJsonSync(file: string): Record<string, unknown> {
+  try {
+    const buf = fs.readFileSync(file, "utf8");
+    return JSON.parse(buf);
+  } catch {
+    return {};
+  }
+}
+
+async function writeJson(file: string, data: unknown): Promise<void> {
+  const dir = path.dirname(file);
+  try {
+    await fsp.mkdir(dir, { recursive: true });
+    await fsp.writeFile(file, JSON.stringify(data, null, 2), "utf8");
+    return;
+  } catch (e: unknown) {
+    const code = (e as { code?: string }).code;
+    if (code !== "EPERM" && code !== "EACCES") throw e;
+  }
+  const fb = configFallbackPath();
+  const fdir = path.dirname(fb);
+  await fsp.mkdir(fdir, { recursive: true });
+  await fsp.writeFile(fb, JSON.stringify(data, null, 2), "utf8");
+}
+
+export async function readConfig(): Promise<Partial<ZerocutConfig>> {
+  const primary = configPath();
+  try {
+    await fsp.access(primary);
+    return (await readJson(primary)) as Partial<ZerocutConfig>;
+  } catch {
+    const fb = configFallbackPath();
+    try {
+      await fsp.access(fb);
+      return (await readJson(fb)) as Partial<ZerocutConfig>;
+    } catch {
+      return {};
+    }
+  }
+}
+
+export function readConfigSync(): Partial<ZerocutConfig> {
+  const primary = configPath();
+  if (fs.existsSync(primary)) return readJsonSync(primary) as Partial<ZerocutConfig>;
+  const fb = configFallbackPath();
+  if (fs.existsSync(fb)) return readJsonSync(fb) as Partial<ZerocutConfig>;
+  return {};
+}
+
+export async function writeConfig(update: Partial<ZerocutConfig>): Promise<Partial<ZerocutConfig>> {
+  const file = configPath();
+  const current = (await readJson(file)) as Partial<ZerocutConfig>;
+  const next = { ...current, ...update } as Partial<ZerocutConfig>;
+  await writeJson(file, next);
+  return next;
+}
+
+function splitKeyPath(key: string): string[] {
+  return key
+    .split(".")
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+}
+
+function deepGet(obj: Record<string, unknown>, segments: string[]): unknown {
+  let cur: unknown = obj;
+  for (const seg of segments) {
+    if (typeof cur !== "object" || cur === null) return undefined;
+    const rec = cur as Record<string, unknown>;
+    cur = rec[seg];
+  }
+  return cur;
+}
+
+function deepSet(obj: Record<string, unknown>, segments: string[], value: unknown): void {
+  let cur: Record<string, unknown> = obj;
+  for (let i = 0; i < segments.length; i++) {
+    const seg = segments[i];
+    const isLast = i === segments.length - 1;
+    if (isLast) {
+      cur[seg] = value as unknown;
+    } else {
+      const next = cur[seg];
+      if (typeof next !== "object" || next === null) {
+        const created: Record<string, unknown> = {};
+        cur[seg] = created;
+        cur = created;
+      } else {
+        cur = next as Record<string, unknown>;
+      }
+    }
+  }
+}
+
+export function getConfigValueSync(key: string): unknown {
+  const primary = configPath();
+  const fb = configFallbackPath();
+  const data = fs.existsSync(primary)
+    ? (readJsonSync(primary) as Record<string, unknown>)
+    : fs.existsSync(fb)
+      ? (readJsonSync(fb) as Record<string, unknown>)
+      : ({} as Record<string, unknown>);
+  return deepGet(data, splitKeyPath(key));
+}
+
+export async function getConfigValue(key: string): Promise<unknown> {
+  const primary = configPath();
+  try {
+    await fsp.access(primary);
+    const data = (await readJson(primary)) as Record<string, unknown>;
+    return deepGet(data, splitKeyPath(key));
+  } catch {
+    const fb = configFallbackPath();
+    try {
+      await fsp.access(fb);
+      const data = (await readJson(fb)) as Record<string, unknown>;
+      return deepGet(data, splitKeyPath(key));
+    } catch {
+      return undefined;
+    }
+  }
+}
+
+function writeJsonSync(file: string, data: unknown): void {
+  const dir = path.dirname(file);
+  try {
+    fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(file, JSON.stringify(data, null, 2), "utf8");
+    return;
+  } catch (e: unknown) {
+    const code = (e as { code?: string }).code;
+    if (code !== "EPERM" && code !== "EACCES") throw e;
+  }
+  const fb = configFallbackPath();
+  const fdir = path.dirname(fb);
+  fs.mkdirSync(fdir, { recursive: true });
+  fs.writeFileSync(fb, JSON.stringify(data, null, 2), "utf8");
+}
+
+export function setConfigValueSync(key: string, value: unknown): void {
+  const file = configPath();
+  const data = readJsonSync(file) as Record<string, unknown>;
+  deepSet(data, splitKeyPath(key), value);
+  writeJsonSync(file, data);
+}
+
+export async function setConfigValue(key: string, value: unknown): Promise<void> {
+  const file = configPath();
+  const data = (await readJson(file)) as Record<string, unknown>;
+  deepSet(data, splitKeyPath(key), value);
+  await writeJson(file, data);
+}
+
+export async function ensureConfig(): Promise<boolean> {
+  const apiKey = getConfigValueSync("apiKey");
+  const region = getConfigValueSync("region");
+  const missing: string[] = [];
+  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;
+}
+
+export function applyConfigInterceptor(program: Command): void {
+  program.hook("preAction", async (thisCommand, actionCommand) => {
+    const current = (actionCommand ?? thisCommand) as Command;
+    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 openSession();
+    if (actionCommand) {
+      attachSessionToCommand(actionCommand as unknown as Record<symbol, unknown>, session);
+    }
+  });
+  program.hook("postAction", async (thisCommand, actionCommand) => {
+    const name = actionCommand?.name?.() ?? thisCommand?.name?.();
+    if (name === "help" || name === "skill") return;
+    try {
+      const cmd = (actionCommand ?? thisCommand) as Command & {
+        [SESSION_SYMBOL]?: import("cerevox").Session;
+      };
+      const session = cmd?.[SESSION_SYMBOL];
+      if (session) await closeSession(session);
+      process.exit(0);
+    } catch {}
+  });
+}