@zqagent/core 0.1.30 → 0.2.4

package/dist/tools/media.js

@@ -0,0 +1,1159 @@
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/tools/media.ts
+import * as fs3 from "fs";
+import * as path4 from "path";
+
+// src/tools/execAsync.ts
+import { spawn } from "child_process";
+
+// src/tools/killTree.ts
+import { spawnSync } from "child_process";
+function killTree(pid) {
+  if (!pid) return;
+  if (process.platform === "win32") {
+    try {
+      spawnSync("taskkill", ["/pid", String(pid), "/T", "/F"], { windowsHide: true });
+    } catch {
+    }
+    return;
+  }
+  try {
+    process.kill(-pid, "SIGKILL");
+  } catch {
+    try {
+      process.kill(pid, "SIGKILL");
+    } catch {
+    }
+  }
+}
+
+// src/tools/execAsync.ts
+var liveChildren = /* @__PURE__ */ new Set();
+var exitCleanupInstalled = false;
+function trackChild(pid) {
+  if (!pid) return;
+  liveChildren.add(pid);
+  if (exitCleanupInstalled) return;
+  exitCleanupInstalled = true;
+  process.once("exit", () => {
+    for (const p of liveChildren) killTree(p);
+  });
+}
+var DEFAULT_MAX_BUFFER = 1024 * 1024 * 5;
+var KILL_GRACE_MS = 1e3;
+function makeSink(maxBuffer) {
+  const chunks = [];
+  let len = 0;
+  let over = false;
+  return {
+    push(chunk) {
+      if (len >= maxBuffer) {
+        over = true;
+        return;
+      }
+      const room = maxBuffer - len;
+      if (chunk.length > room) {
+        chunks.push(chunk.subarray(0, room));
+        len = maxBuffer;
+        over = true;
+        return;
+      }
+      chunks.push(chunk);
+      len += chunk.length;
+    },
+    done: () => Buffer.concat(chunks),
+    over: () => over
+  };
+}
+function execAsync(file, argv, opts = {}) {
+  return new Promise((resolve4) => {
+    const maxBuffer = opts.maxBuffer ?? DEFAULT_MAX_BUFFER;
+    const out = makeSink(maxBuffer);
+    const err = makeSink(maxBuffer);
+    if (opts.signal?.aborted) {
+      resolve4({
+        status: null,
+        stdout: Buffer.alloc(0),
+        stderr: Buffer.alloc(0),
+        timedOut: false,
+        truncated: false,
+        aborted: true
+      });
+      return;
+    }
+    let child;
+    try {
+      child = spawn(file, argv, {
+        ...opts.cwd !== void 0 ? { cwd: opts.cwd } : {},
+        ...opts.env !== void 0 ? { env: opts.env } : {},
+        // 自成进程组（POSIX）：超时/中断时用 killTree 一次收掉整棵进程树
+        detached: process.platform !== "win32",
+        stdio: [opts.input === void 0 ? "ignore" : "pipe", "pipe", "pipe"],
+        windowsHide: true
+      });
+    } catch (e) {
+      resolve4({
+        status: null,
+        stdout: Buffer.alloc(0),
+        stderr: Buffer.alloc(0),
+        error: e,
+        timedOut: false,
+        truncated: false
+      });
+      return;
+    }
+    trackChild(child.pid);
+    let settled = false;
+    let timedOut = false;
+    let aborted = false;
+    let spawnError;
+    let timer = null;
+    let graceTimer = null;
+    const onAbort = () => {
+      aborted = true;
+      killAndSettle();
+    };
+    const finish = (status) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      if (graceTimer) clearTimeout(graceTimer);
+      if (child.pid !== void 0) liveChildren.delete(child.pid);
+      opts.signal?.removeEventListener("abort", onAbort);
+      const result = {
+        status,
+        stdout: out.done(),
+        stderr: err.done(),
+        timedOut,
+        truncated: out.over() || err.over()
+      };
+      if (aborted) result.aborted = true;
+      if (spawnError) result.error = spawnError;
+      resolve4(result);
+    };
+    const killAndSettle = () => {
+      killTree(child.pid);
+      if (settled || graceTimer) return;
+      graceTimer = setTimeout(() => {
+        child.stdout?.destroy();
+        child.stderr?.destroy();
+        finish(null);
+      }, KILL_GRACE_MS);
+    };
+    if (opts.timeoutMs !== void 0 && opts.timeoutMs > 0) {
+      timer = setTimeout(() => {
+        timedOut = true;
+        killAndSettle();
+      }, opts.timeoutMs);
+    }
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    child.stdout?.on("data", (c) => out.push(c));
+    child.stderr?.on("data", (c) => err.push(c));
+    child.on("error", (e) => {
+      spawnError = e;
+      if (child.pid === void 0) finish(null);
+    });
+    if (opts.input !== void 0 && child.stdin) {
+      child.stdin.on("error", () => {
+      });
+      child.stdin.end(opts.input);
+    }
+    child.on("close", (code) => finish(code));
+  });
+}
+
+// src/tools/shellRuntime.ts
+import * as path from "path";
+var WINDOWS_SUFFIXES = [".exe", ".cmd", ".bat", ".com", ""];
+function pathApi(platform) {
+  return platform === "win32" ? path.win32 : path.posix;
+}
+function joinPath(platform, ...parts) {
+  return pathApi(platform).join(...parts);
+}
+function findExecutable(name, ctx) {
+  if (name.includes("/") || name.includes("\\")) {
+    return ctx.fileExists(name) ? name : null;
+  }
+  const suffixes = ctx.platform === "win32" ? WINDOWS_SUFFIXES : [""];
+  const delimiter = ctx.platform === "win32" ? ";" : ":";
+  const dirs = (ctx.env.PATH ?? "").split(delimiter).filter((d) => d.length > 0);
+  for (const dir of dirs) {
+    for (const suffix of suffixes) {
+      const candidate = joinPath(ctx.platform, dir, name + suffix);
+      if (ctx.fileExists(candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+// src/tools/shellBackground.ts
+import { spawn as spawn2 } from "child_process";
+var DEFAULT_BUFFER_LIMIT = 64 * 1024;
+var RingBuffer = class {
+  constructor(limit = DEFAULT_BUFFER_LIMIT) {
+    this.limit = limit;
+  }
+  limit;
+  chunks = [];
+  size = 0;
+  add(chunk) {
+    if (!chunk) return;
+    this.chunks.push(chunk);
+    this.size += chunk.length;
+    while (this.size > this.limit && this.chunks.length > 1) {
+      this.size -= this.chunks.shift().length;
+    }
+    if (this.size > this.limit) {
+      const joined = this.chunks.join("");
+      this.chunks = [joined.slice(-this.limit)];
+      this.size = this.chunks[0].length;
+    }
+  }
+  get() {
+    const joined = this.chunks.join("");
+    return joined.length > this.limit ? joined.slice(-this.limit) : joined;
+  }
+};
+var ShellTaskManager = class {
+  tasks = /* @__PURE__ */ new Map();
+  seq = 0;
+  cleanupInstalled = false;
+  /** 启动一个后台任务，立即返回快照（不等退出） */
+  start(opts) {
+    this.installCleanup();
+    const id = `shell-${++this.seq}-${Date.now().toString(36)}`;
+    const child = spawn2(opts.file, opts.argv, {
+      cwd: opts.cwd,
+      env: opts.env,
+      detached: process.platform !== "win32",
+      windowsHide: true,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const task = {
+      id,
+      command: opts.command,
+      scope: opts.scope ?? null,
+      child,
+      stdout: new RingBuffer(),
+      stderr: new RingBuffer(),
+      status: "running",
+      exitCode: null,
+      signal: null,
+      startedAt: Date.now(),
+      endedAt: null
+    };
+    this.tasks.set(id, task);
+    child.stdout?.on("data", (d) => task.stdout.add(d.toString("utf-8")));
+    child.stderr?.on("data", (d) => task.stderr.add(d.toString("utf-8")));
+    child.on("error", (err) => task.stderr.add(`[spawn error] ${err.message}
+`));
+    child.on("exit", (code, signal) => {
+      task.exitCode = code;
+      task.signal = signal;
+      task.endedAt = Date.now();
+      if (task.status !== "killed") task.status = "exited";
+    });
+    child.unref();
+    return this.snapshot(task);
+  }
+  /** 读取任务输出与状态 */
+  output(taskId) {
+    const task = this.tasks.get(taskId);
+    if (!task) return { error: `\u672A\u77E5\u7684\u540E\u53F0\u4EFB\u52A1: ${taskId}` };
+    return this.snapshot(task);
+  }
+  /** 终止任务（进程树）并返回快照；传 scope 时只允许终止该归属下的任务 */
+  kill(taskId, scope) {
+    const task = this.tasks.get(taskId);
+    if (!task) return { error: `\u672A\u77E5\u7684\u540E\u53F0\u4EFB\u52A1: ${taskId}` };
+    if (scope !== void 0 && task.scope !== scope) {
+      return { error: `\u672A\u77E5\u7684\u540E\u53F0\u4EFB\u52A1: ${taskId}` };
+    }
+    if (task.status === "running") {
+      task.status = "killed";
+      task.endedAt = Date.now();
+      killTree(task.child.pid);
+    }
+    return this.snapshot(task);
+  }
+  /** 列出任务快照（调试/展示用）；传 scope 时只返回该归属下的任务 */
+  list(scope) {
+    const all = [...this.tasks.values()];
+    return (scope === void 0 ? all : all.filter((t) => t.scope === scope)).map(
+      (t) => this.snapshot(t)
+    );
+  }
+  /** 终止全部任务（进程退出时调用） */
+  disposeAll() {
+    for (const task of this.tasks.values()) {
+      if (task.status === "running") {
+        task.status = "killed";
+        killTree(task.child.pid);
+      }
+    }
+  }
+  snapshot(task) {
+    return {
+      task_id: task.id,
+      command: task.command,
+      status: task.status,
+      running: task.status === "running",
+      exit_code: task.exitCode,
+      signal: task.signal,
+      stdout: task.stdout.get(),
+      stderr: task.stderr.get(),
+      duration_ms: (task.endedAt ?? Date.now()) - task.startedAt
+    };
+  }
+  installCleanup() {
+    if (this.cleanupInstalled) return;
+    this.cleanupInstalled = true;
+    process.once("exit", () => this.disposeAll());
+  }
+};
+
+// src/tools/shell.ts
+var MAX_BUFFER = 1024 * 1024 * 5;
+function decodeOutput(buf) {
+  if (!buf || buf.length === 0) return "";
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(buf);
+  } catch {
+    for (const enc of ["gbk", "big5", "shift_jis", "latin1"]) {
+      try {
+        return new TextDecoder(enc).decode(buf);
+      } catch {
+      }
+    }
+    return buf.toString("latin1");
+  }
+}
+var shellTasks = new ShellTaskManager();
+
+// src/tools/pathSafety.ts
+import * as fs from "fs";
+import * as path2 from "path";
+function isInsideRelative(rel) {
+  return !path2.isAbsolute(rel) && rel !== ".." && !rel.startsWith(`..${path2.sep}`);
+}
+function isFilesystemRoot(p) {
+  return path2.parse(p).root === p;
+}
+function resolveWithinRoot(workspace, target) {
+  const abs = path2.resolve(workspace, target);
+  let rootReal;
+  try {
+    rootReal = fs.realpathSync(workspace);
+  } catch {
+    const rootAbs = path2.resolve(workspace);
+    if (!isInsideRelative(path2.relative(rootAbs, abs))) return null;
+    return { root: rootAbs, real: abs };
+  }
+  if (isFilesystemRoot(rootReal)) return null;
+  let real;
+  try {
+    real = fs.realpathSync(abs);
+  } catch {
+    let probe = abs;
+    const tail = [];
+    for (; ; ) {
+      const exists = fs.existsSync(probe) || fs.lstatSync(probe, { throwIfNoEntry: false }) !== void 0;
+      if (exists) {
+        try {
+          real = path2.join(fs.realpathSync(probe), ...tail);
+          break;
+        } catch {
+          return null;
+        }
+      }
+      tail.unshift(path2.basename(probe));
+      const parent = path2.dirname(probe);
+      if (parent === probe) return null;
+      probe = parent;
+    }
+  }
+  if (!isInsideRelative(path2.relative(rootReal, real))) return null;
+  return { root: rootReal, real };
+}
+
+// src/tools/ffmpegRuntime.ts
+import * as fs2 from "fs";
+import * as os from "os";
+import * as path3 from "path";
+import { createRequire } from "module";
+import { createHash } from "crypto";
+import { pipeline } from "stream/promises";
+import { SocksProxyAgent } from "socks-proxy-agent";
+import nodeFetch from "node-fetch";
+var ENV_FFMPEG = "ZQAGENT_FFMPEG";
+var ENV_FFPROBE = "ZQAGENT_FFPROBE";
+var PROXY_ENV = process.env.SOCKS5_PROXY;
+var socksAgent = null;
+if (PROXY_ENV) {
+  try {
+    socksAgent = new SocksProxyAgent(PROXY_ENV);
+  } catch {
+    try {
+      socksAgent = new SocksProxyAgent(PROXY_ENV.replace(/^socks5h:\/\//, "socks5://"));
+    } catch {
+      socksAgent = null;
+    }
+  }
+}
+var DOWNLOAD_TIMEOUT_MS = 5 * 60 * 1e3;
+function agentBinDir(workspace) {
+  return path3.join(path3.resolve(workspace), ".agent", "bin");
+}
+function exeName(name, platform) {
+  return platform === "win32" ? `${name}.exe` : name;
+}
+function defaultFileExists(p) {
+  try {
+    return fs2.statSync(p).isFile();
+  } catch {
+    return false;
+  }
+}
+function extractBundled(name, platform) {
+  try {
+    const req = typeof __require === "function" ? __require : createRequire(path3.join(process.cwd(), "__zqagent__.js"));
+    const sea = req("node:sea");
+    if (!sea?.isSea?.() || typeof sea.getAsset !== "function") return null;
+    const asset = sea.getAsset(name);
+    if (!asset) return null;
+    const dir = fs2.mkdtempSync(path3.join(os.tmpdir(), `zqagent-${name}-`));
+    const file = path3.join(dir, exeName(name, platform));
+    fs2.writeFileSync(file, Buffer.from(asset));
+    fs2.chmodSync(file, 493);
+    return file;
+  } catch {
+    return null;
+  }
+}
+function resolveOne(name, workspace, o) {
+  const envKey = name === "ffmpeg" ? ENV_FFMPEG : ENV_FFPROBE;
+  const explicit = (o.env[envKey] ?? "").trim();
+  if (explicit && o.fileExists(explicit)) return { path: explicit, source: "env" };
+  const local = path3.join(agentBinDir(workspace), exeName(name, o.platform));
+  if (o.fileExists(local)) return { path: local, source: "agent-bin" };
+  const bundled = extractBundled(name, o.platform);
+  if (bundled) return { path: bundled, source: "bundled" };
+  const onPath = findExecutable(name, {
+    platform: o.platform,
+    env: o.env,
+    fileExists: o.fileExists
+  });
+  return onPath ? { path: onPath, source: "path" } : null;
+}
+var cache = /* @__PURE__ */ new Map();
+function resolveMedia(workspace, opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const key = `${platform}:${path3.resolve(workspace)}`;
+  const hit = cache.get(key);
+  if (hit) return hit;
+  const ctx = {
+    platform,
+    env: opts.env ?? process.env,
+    fileExists: opts.fileExists ?? defaultFileExists
+  };
+  const resolved = {
+    ffmpeg: resolveOne("ffmpeg", workspace, ctx),
+    ffprobe: resolveOne("ffprobe", workspace, ctx)
+  };
+  cache.set(key, resolved);
+  return resolved;
+}
+function resetFfmpegCache() {
+  cache.clear();
+}
+function installHints(platform = process.platform) {
+  switch (platform) {
+    case "darwin":
+      return [
+        "brew install ffmpeg",
+        "\u4E0B\u8F7D\u9875: https://evermeet.cx/ffmpeg/ \u4E0E https://evermeet.cx/ffprobe/\uFF08\u89E3\u538B\u540E\u628A ffmpeg / ffprobe \u653E\u8FDB PATH\uFF09"
+      ];
+    case "win32":
+      return [
+        'winget install "FFmpeg (Essentials Build)"',
+        "choco install ffmpeg",
+        "scoop install ffmpeg-essentials",
+        "\u4E0B\u8F7D\u9875: https://www.gyan.dev/ffmpeg/builds/\uFF08\u89E3\u538B\u540E\u628A bin \u76EE\u5F55\u52A0\u5165 PATH\uFF09"
+      ];
+    default:
+      return [
+        "apt-get install -y ffmpeg        # Debian / Ubuntu",
+        "dnf install -y ffmpeg            # Fedora / RHEL\uFF08\u9700\u542F\u7528 RPM Fusion\uFF09",
+        "apk add ffmpeg                   # Alpine",
+        "pacman -S ffmpeg                 # Arch",
+        "\u4E0B\u8F7D\u9875: https://johnvansickle.com/ffmpeg/\uFF08\u9759\u6001\u6784\u5EFA\uFF0C\u89E3\u538B\u540E\u628A ffmpeg / ffprobe \u653E\u8FDB PATH \u6216 .agent/bin\uFF09"
+      ];
+  }
+}
+var JVS = "https://johnvansickle.com/ffmpeg/releases";
+var EVERMEET_INFO = "https://evermeet.cx/ffmpeg/info";
+var GYAN = "https://www.gyan.dev/ffmpeg/builds";
+var BTBN = "https://github.com/BtbN/FFmpeg-Builds/releases/download/latest";
+function distEntry(name, url, checksumUrl, algo) {
+  return { name, url, archive: url.endsWith(".zip") ? "zip" : "tar.xz", checksumUrl, checksumAlgo: algo };
+}
+function distSpecFor(platform, arch) {
+  if (platform === "linux") {
+    const suffix = arch === "x64" ? "amd64" : arch === "arm64" ? "arm64" : arch === "arm" ? "armhf" : arch === "ia32" ? "i686" : null;
+    if (!suffix) return null;
+    return {
+      components: [
+        distEntry("ffmpeg", `${JVS}/ffmpeg-release-${suffix}-static.tar.xz`, `${JVS}/ffmpeg-release-${suffix}-static.tar.xz.md5`, "md5"),
+        distEntry("ffprobe", `${JVS}/ffmpeg-release-${suffix}-static.tar.xz`)
+      ]
+    };
+  }
+  if (platform === "darwin") {
+    return {
+      components: [
+        {
+          name: "ffmpeg",
+          infoUrl: `${EVERMEET_INFO}/ffmpeg/release`,
+          archive: "zip"
+        },
+        {
+          name: "ffprobe",
+          infoUrl: `${EVERMEET_INFO}/ffprobe/release`,
+          archive: "zip"
+        }
+      ]
+    };
+  }
+  if (platform === "win32") {
+    if (arch === "x64") {
+      const url = `${GYAN}/ffmpeg-release-essentials.zip`;
+      return {
+        components: [
+          distEntry("ffmpeg", url, `${url}.sha256`, "sha256"),
+          distEntry("ffprobe", url)
+        ]
+      };
+    }
+    if (arch === "arm64") {
+      const url = `${BTBN}/ffmpeg-master-latest-winarm64-gpl.zip`;
+      return {
+        components: [
+          distEntry("ffmpeg", url, `${BTBN}/checksums.sha256`, "sha256"),
+          distEntry("ffprobe", url)
+        ]
+      };
+    }
+    return null;
+  }
+  return null;
+}
+function parseChecksumFile(text, filename) {
+  const lines = text.split(/\r?\n/).filter((l) => l.trim().length > 0);
+  for (const line of lines) {
+    const m = /^([0-9a-f]{32,128})\s+\*?(.*)$/i.exec(line.trim());
+    if (!m) continue;
+    const hash = m[1].toLowerCase();
+    const name = m[2]?.trim() ?? "";
+    if (!name || name === filename || path3.basename(name) === filename) return hash;
+  }
+  const single = lines[0]?.trim();
+  if (lines.length === 1 && single && /^[0-9a-f]{32,128}$/i.test(single)) {
+    return single.toLowerCase();
+  }
+  return null;
+}
+async function computeChecksum(file, algo) {
+  const hash = createHash(algo);
+  await pipeline(fs2.createReadStream(file), hash);
+  return hash.digest("hex");
+}
+function fetchInit() {
+  return socksAgent ? { agent: socksAgent } : {};
+}
+async function fetchText(url) {
+  const resp = await nodeFetch(url, fetchInit());
+  if (!resp.ok) throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
+  return resp.text();
+}
+async function downloadToFile(url, dest) {
+  const resp = await nodeFetch(url, fetchInit());
+  if (!resp.ok) throw new Error(`HTTP ${resp.status} ${resp.statusText}`);
+  if (!resp.body) throw new Error("\u54CD\u5E94\u6CA1\u6709\u5185\u5BB9");
+  await pipeline(resp.body, fs2.createWriteStream(dest));
+}
+async function resolveComponentUrl(c) {
+  if (c.url) return c.url;
+  if (!c.infoUrl) throw new Error(`\u4E0B\u8F7D\u6E90\u7F3A\u5C11 url / infoUrl: ${c.name}`);
+  const text = await fetchText(c.infoUrl);
+  const json = JSON.parse(text);
+  const url = json.download?.zip?.url;
+  if (!url) throw new Error(`\u5143\u6570\u636E\u63A5\u53E3\u672A\u7ED9\u51FA zip \u5730\u5740: ${c.infoUrl}`);
+  return url;
+}
+function findBinaryInTree(dir, names) {
+  const stack = [dir];
+  while (stack.length > 0) {
+    const cur = stack.pop();
+    let entries;
+    try {
+      entries = fs2.readdirSync(cur, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const e of entries) {
+      const full = path3.join(cur, e.name);
+      if (e.isDirectory()) {
+        stack.push(full);
+      } else if (names.includes(e.name)) {
+        return full;
+      }
+    }
+  }
+  return null;
+}
+async function extractArchive(archive, dest, kind, platform) {
+  fs2.mkdirSync(dest, { recursive: true });
+  let res;
+  if (kind === "tar.xz") {
+    res = await execAsync("tar", ["-xJf", archive, "-C", dest]);
+  } else if (platform === "win32") {
+    res = await execAsync(
+      "powershell",
+      [
+        "-NoProfile",
+        "-NonInteractive",
+        "-Command",
+        `Expand-Archive -LiteralPath '${archive.replace(/'/g, "''")}' -DestinationPath '${dest.replace(/'/g, "''")}' -Force`
+      ]
+    );
+  } else {
+    res = await execAsync("unzip", ["-o", "-q", archive, "-d", dest]);
+  }
+  if (res.error || res.status !== 0) {
+    const detail = res.error?.message ?? decodeOutput(res.stderr).trim();
+    return `\u89E3\u5305\u5931\u8D25 (${kind}): ${detail}`;
+  }
+  return null;
+}
+async function downloadFfmpeg(workspace, opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const arch = opts.arch ?? process.arch;
+  const log = opts.log ?? (() => {
+  });
+  const notes = [];
+  const spec = opts.spec === void 0 ? distSpecFor(platform, arch) : opts.spec;
+  if (!spec || spec.components.length === 0) {
+    return {
+      ok: false,
+      error: `\u6682\u4E0D\u652F\u6301\u81EA\u52A8\u4E0B\u8F7D\u7684\u5E73\u53F0: ${platform}/${arch}`
+    };
+  }
+  const tmp = fs2.mkdtempSync(path3.join(os.tmpdir(), "zqagent-ffmpeg-"));
+  const binDir = agentBinDir(workspace);
+  const installed = {};
+  try {
+    const fetched = /* @__PURE__ */ new Map();
+    for (const c of spec.components) {
+      let url;
+      try {
+        url = await resolveComponentUrl(c);
+      } catch (e) {
+        return { ok: false, error: `\u83B7\u53D6\u4E0B\u8F7D\u5730\u5740\u5931\u8D25: ${String(e instanceof Error ? e.message : e)}` };
+      }
+      let archive = fetched.get(url);
+      if (!archive) {
+        const archivePath = path3.join(tmp, path3.basename(new URL(url).pathname) || `${c.name}.${c.archive}`);
+        log(`\u4E0B\u8F7D ${url}`);
+        try {
+          await downloadToFile(url, archivePath);
+        } catch (e) {
+          return { ok: false, error: `\u4E0B\u8F7D\u5931\u8D25 (${url}): ${String(e instanceof Error ? e.message : e)}` };
+        }
+        if (c.checksumUrl) {
+          const algo = c.checksumAlgo ?? "sha256";
+          try {
+            const expected = parseChecksumFile(await fetchText(c.checksumUrl), path3.basename(archivePath));
+            if (!expected) {
+              notes.push(`\u672A\u80FD\u4ECE ${c.checksumUrl} \u89E3\u6790\u51FA\u6821\u9A8C\u548C\uFF0C\u5DF2\u8DF3\u8FC7\u6821\u9A8C`);
+            } else {
+              const actual = await computeChecksum(archivePath, algo);
+              if (actual !== expected) {
+                return {
+                  ok: false,
+                  error: `\u6821\u9A8C\u548C\u4E0D\u5339\u914D (${algo}): \u671F\u671B ${expected}\uFF0C\u5B9E\u9645 ${actual}\u3002\u5DF2\u4E2D\u6B62\u5B89\u88C5\u3002`
+                };
+              }
+              log(`${algo} \u6821\u9A8C\u901A\u8FC7`);
+            }
+          } catch (e) {
+            notes.push(`\u6821\u9A8C\u548C\u83B7\u53D6\u5931\u8D25 (${c.checksumUrl}): ${String(e instanceof Error ? e.message : e)}`);
+          }
+        } else {
+          notes.push(`${path3.basename(archivePath)} \u672A\u63D0\u4F9B\u6821\u9A8C\u548C\uFF08\u4EC5 HTTPS \u4F20\u8F93\u4FDD\u62A4\uFF09`);
+        }
+        archive = { file: archivePath, kind: c.archive };
+        fetched.set(url, archive);
+      }
+      const extractDir = fs2.mkdtempSync(path3.join(tmp, "x-"));
+      const err = await extractArchive(archive.file, extractDir, archive.kind, platform);
+      if (err) return { ok: false, error: err };
+      const found = findBinaryInTree(extractDir, [exeName(c.name, platform), c.name]);
+      if (!found) {
+        return { ok: false, error: `\u5F52\u6863\u5185\u672A\u627E\u5230 ${c.name}: ${path3.basename(archive.file)}` };
+      }
+      fs2.mkdirSync(binDir, { recursive: true });
+      const target = path3.join(binDir, exeName(c.name, platform));
+      const staging = `${target}.tmp-${process.pid}`;
+      fs2.copyFileSync(found, staging);
+      fs2.chmodSync(staging, 493);
+      fs2.renameSync(staging, target);
+      installed[c.name] = target;
+    }
+    resetFfmpegCache();
+    notes.push("ffmpeg \u9759\u6001\u6784\u5EFA\u591A\u4E3A GPL/LGPL \u8BB8\u53EF\uFF0C\u968F\u4EA7\u54C1\u5206\u53D1\u524D\u8BF7\u786E\u8BA4\u76F8\u5E94\u7684\u6E90\u7801\u63D0\u4F9B\u4E49\u52A1");
+    return { ok: true, installed, notes };
+  } catch (e) {
+    return { ok: false, error: `\u5B89\u88C5\u5931\u8D25: ${String(e instanceof Error ? e.message : e)}` };
+  } finally {
+    fs2.rmSync(tmp, { recursive: true, force: true });
+  }
+}
+function canAutoDownload(platform, arch) {
+  return distSpecFor(platform, arch) !== null;
+}
+
+// src/tools/media.ts
+var MAX_OUTPUT = 4e3;
+var TIMEOUT_MS = 600 * 1e3;
+var MAX_BUFFER2 = 1024 * 1024 * 8;
+var NEEDS_INPUT = /* @__PURE__ */ new Set([
+  "probe",
+  "trim",
+  "convert",
+  "extract_audio",
+  "extract_frame",
+  "thumbnail",
+  "compress"
+]);
+var NEEDS_OUTPUT = /* @__PURE__ */ new Set([
+  "trim",
+  "convert",
+  "extract_audio",
+  "extract_frame",
+  "thumbnail",
+  "compress"
+]);
+var OPS = [
+  "probe",
+  "trim",
+  "convert",
+  "extract_audio",
+  "extract_frame",
+  "thumbnail",
+  "compress",
+  "setup"
+];
+var PRESETS = /* @__PURE__ */ new Set([
+  "ultrafast",
+  "superfast",
+  "veryfast",
+  "faster",
+  "fast",
+  "medium",
+  "slow",
+  "slower",
+  "veryslow"
+]);
+function str(v) {
+  if (typeof v === "string" && v.trim().length > 0) return v.trim();
+  return void 0;
+}
+function finiteNum(v, min, max) {
+  const n = typeof v === "string" ? Number(v.trim()) : v;
+  if (typeof n !== "number" || !Number.isFinite(n) || n < min || n > max) return null;
+  return n;
+}
+function parseTimecode(v) {
+  if (typeof v === "number") return Number.isFinite(v) && v >= 0 ? v : null;
+  if (typeof v !== "string") return null;
+  const t = v.trim();
+  if (t === "") return null;
+  if (/^\d+(\.\d+)?$/.test(t)) return Number(t);
+  const parts = t.split(":");
+  if (parts.length < 2 || parts.length > 3) return null;
+  let sec = 0;
+  for (const p of parts) {
+    if (!/^\d+(\.\d+)?$/.test(p)) return null;
+    sec = sec * 60 + Number(p);
+  }
+  return sec;
+}
+function truncateTail(s, max = MAX_OUTPUT) {
+  const t = s.trim();
+  if (t.length <= max) return t;
+  return `\u2026\uFF08\u5DF2\u622A\u65AD\u524D ${t.length - max} \u5B57\u7B26\uFF09
+` + t.slice(-max);
+}
+function scaleFilter(width, height) {
+  if (width && height) return `scale=${width}:${height}`;
+  if (width) return `scale=${width}:-2`;
+  if (height) return `scale=-2:${height}`;
+  return null;
+}
+function buildFfmpegArgs(op, args, paths) {
+  const input = paths.input ?? "";
+  const argv = ["-y", "-hide_banner", "-nostdin"];
+  const ss = args["ss"] === void 0 ? null : parseTimecode(args["ss"]);
+  if (args["ss"] !== void 0 && ss === null) {
+    return { error: "\u53C2\u6570 ss \u4E0D\u662F\u5408\u6CD5\u65F6\u95F4\u7801\uFF08\u793A\u4F8B\uFF1A12.5 / 00:12.5 / 00:00:12.5\uFF09" };
+  }
+  const to = args["to"] === void 0 ? null : parseTimecode(args["to"]);
+  if (args["to"] !== void 0 && to === null) {
+    return { error: "\u53C2\u6570 to \u4E0D\u662F\u5408\u6CD5\u65F6\u95F4\u7801\uFF08\u793A\u4F8B\uFF1A30 / 00:30 / 00:00:30\uFF09" };
+  }
+  const duration = args["duration"] === void 0 ? null : finiteNum(args["duration"], 0, 24 * 3600);
+  if (args["duration"] !== void 0 && duration === null) {
+    return { error: "\u53C2\u6570 duration \u5FC5\u987B\u662F 0\uFF5E86400 \u4E4B\u95F4\u7684\u79D2\u6570" };
+  }
+  if (to !== null && ss !== null && to <= ss) {
+    return { error: `\u53C2\u6570 to (${to}s) \u5FC5\u987B\u5927\u4E8E ss (${ss}s)` };
+  }
+  const output = paths.output ?? "";
+  const format = str(args["format"]);
+  switch (op) {
+    case "trim": {
+      if (ss !== null) argv.push("-ss", String(ss));
+      argv.push("-i", input);
+      if (duration !== null) {
+        argv.push("-t", String(duration));
+      } else if (to !== null) {
+        argv.push("-t", String(to - (ss ?? 0)));
+      }
+      argv.push("-c", "copy");
+      if (format) argv.push("-f", format);
+      argv.push(output);
+      return argv;
+    }
+    case "convert": {
+      argv.push("-i", input);
+      const vf = scaleFilter(
+        args["width"] === void 0 ? null : finiteNum(args["width"], 1, 16384),
+        args["height"] === void 0 ? null : finiteNum(args["height"], 1, 16384)
+      );
+      if (vf) argv.push("-vf", vf);
+      const fps = args["fps"] === void 0 ? null : finiteNum(args["fps"], 0.01, 240);
+      if (fps !== null) argv.push("-r", String(fps));
+      const codec = str(args["codec"]);
+      if (codec) argv.push("-c:v", codec);
+      const bitrate = str(args["bitrate"]);
+      if (bitrate) argv.push("-b:v", bitrate);
+      if (format) argv.push("-f", format);
+      argv.push(output);
+      return argv;
+    }
+    case "extract_audio": {
+      argv.push("-i", input, "-vn");
+      const codec = str(args["codec"]);
+      if (codec) argv.push("-c:a", codec);
+      const bitrate = str(args["bitrate"]);
+      if (bitrate) argv.push("-b:a", bitrate);
+      if (format) argv.push("-f", format);
+      argv.push(output);
+      return argv;
+    }
+    case "extract_frame":
+    case "thumbnail": {
+      const at = ss ?? 0;
+      argv.push("-ss", String(at), "-i", input, "-frames:v", "1");
+      const width = args["width"] === void 0 ? null : finiteNum(args["width"], 1, 16384);
+      const height = args["height"] === void 0 ? null : finiteNum(args["height"], 1, 16384);
+      const vf = scaleFilter(op === "thumbnail" ? width ?? 320 : width, height);
+      if (vf) argv.push("-vf", vf);
+      if (format) argv.push("-f", format);
+      argv.push(output);
+      return argv;
+    }
+    case "compress": {
+      const quality = args["quality"] === void 0 ? 28 : finiteNum(args["quality"], 0, 51);
+      if (quality === null) return { error: "\u53C2\u6570 quality \u5FC5\u987B\u662F 0\uFF5E51 \u4E4B\u95F4\u7684\u6570\u5B57\uFF08\u8D8A\u5927\u8D8A\u7CCA\u3001\u8D8A\u5C0F\u8D8A\u6E05\u6670\uFF09" };
+      const preset = str(args["preset"]) ?? "medium";
+      if (!PRESETS.has(preset)) {
+        return { error: `\u53C2\u6570 preset \u4E0D\u5408\u6CD5\uFF0C\u53EF\u9009\uFF1A${[...PRESETS].join(" / ")}` };
+      }
+      argv.push("-i", input);
+      const vf = scaleFilter(
+        args["width"] === void 0 ? null : finiteNum(args["width"], 1, 16384),
+        args["height"] === void 0 ? null : finiteNum(args["height"], 1, 16384)
+      );
+      if (vf) argv.push("-vf", vf);
+      argv.push("-c:v", "libx264", "-crf", String(quality), "-preset", preset, "-c:a", "aac", "-b:a", "128k");
+      if (format) argv.push("-f", format);
+      argv.push(output);
+      return argv;
+    }
+    default:
+      return { error: `\u672A\u77E5\u64CD\u4F5C: ${op}` };
+  }
+}
+function buildFfprobeArgs(input) {
+  return ["-v", "error", "-print_format", "json", "-show_format", "-show_streams", input];
+}
+function summarizeProbe(raw) {
+  const o = raw ?? {};
+  const fmt = o["format"] ?? {};
+  const num = (v) => {
+    const n = Number(v);
+    return Number.isFinite(n) ? n : void 0;
+  };
+  const streams = Array.isArray(o["streams"]) ? o["streams"] : [];
+  return {
+    format: {
+      format_name: fmt["format_name"],
+      duration_sec: num(fmt["duration"]),
+      size_bytes: num(fmt["size"]),
+      bit_rate: num(fmt["bit_rate"])
+    },
+    streams: streams.map((s) => ({
+      index: s["index"],
+      type: s["codec_type"],
+      codec: s["codec_name"],
+      profile: s["profile"],
+      width: s["width"],
+      height: s["height"],
+      fps: s["avg_frame_rate"] ?? s["r_frame_rate"],
+      sample_rate: num(s["sample_rate"]),
+      channels: s["channels"]
+    }))
+  };
+}
+function missingGuidance(missing, op, platform, arch) {
+  const hints = installHints(platform);
+  const howToFix = [];
+  if (canAutoDownload(platform, arch)) {
+    howToFix.push(
+      `\u672C\u5DE5\u5177\u81EA\u52A8\u4E0B\u8F7D\uFF1A\u6539\u7528 op="setup"\uFF08\u4E0B\u8F7D\u5B98\u65B9\u9759\u6001\u6784\u5EFA\u5230 .agent/bin\uFF0C\u9700\u8981\u51FA\u7F51\uFF1B\u4E00\u6B21\u5373\u53EF\uFF0C\u4E4B\u540E\u4E00\u76F4\u53EF\u7528\uFF09\u3002`
+    );
+  } else {
+    howToFix.push(`\u5F53\u524D\u5E73\u53F0 (${platform}/${arch}) \u6CA1\u6709\u81EA\u52A8\u4E0B\u8F7D\u6E90\uFF0C\u8BF7\u7528\u4E0B\u9762\u4E24\u79CD\u65B9\u5F0F\u4E4B\u4E00\u3002`);
+  }
+  howToFix.push(
+    `\u6539\u7528 run_shell \u5B89\u88C5\uFF08\u9700\u7528\u6237\u5BA1\u6279\uFF09\uFF1A\u5148\u6267\u884C ${JSON.stringify(hints[0])}\uFF1B\u8FD9\u53EA\u5728\u672C\u673A\u4EA4\u4E92\u5F0F\u4F7F\u7528\u65F6\u53EF\u884C\uFF0C\u670D\u52A1\u7AEF/Docker \u65E0\u6CD5\u63D0\u6743\u3002`
+  );
+  howToFix.push(
+    `\u7528\u6237\u624B\u5DE5\u5B89\u88C5\u540E\uFF0C\u628A\u53EF\u6267\u884C\u6587\u4EF6\u8DEF\u5F84\u5199\u5165\u73AF\u5883\u53D8\u91CF ZQAGENT_FFMPEG / ZQAGENT_FFPROBE\uFF0C\u6216\u653E\u8FDB <workspace>/.agent/bin\u3002`
+  );
+  return {
+    error: `\u672A\u627E\u5230 ${missing}\uFF0C\u64CD\u4F5C ${op} \u65E0\u6CD5\u6267\u884C\uFF08ffmpeg \u672A\u5B89\u88C5\u6216\u4E0D\u5728\u6240\u6709\u5DF2\u77E5\u4F4D\u7F6E\uFF09\u3002`,
+    searched: [
+      `\u73AF\u5883\u53D8\u91CF ZQAGENT_${missing.toUpperCase()}`,
+      `<workspace>/.agent/bin/${missing}`,
+      "SEA \u5355\u6587\u4EF6\u5185\u5D4C\u8D44\u6E90",
+      "PATH"
+    ],
+    how_to_fix: howToFix,
+    install_commands: hints,
+    notes: [
+      "run_shell \u7684\u6BCF\u6B21\u8C03\u7528\u4E0D\u4FDD\u7559\u73AF\u5883\u53D8\u91CF\uFF08\u5BFC\u51FA PATH \u53EA\u5728\u5F53\u6B21\u6709\u6548\uFF09\uFF0C\u88C5\u5B8C\u5FC5\u987B\u8BA9\u7528\u6237\u91CD\u542F agent \u8FDB\u7A0B\u624D\u80FD\u88AB\u53D1\u73B0\u3002",
+      "ffmpeg \u9759\u6001\u6784\u5EFA\u591A\u4E3A GPL/LGPL \u8BB8\u53EF\uFF0C\u968F\u4EA7\u54C1\u5206\u53D1\u524D\u8BF7\u786E\u8BA4\u6E90\u7801\u63D0\u4F9B\u4E49\u52A1\u3002"
+    ]
+  };
+}
+async function runBinary(bin, argv, cwd) {
+  const res = await execAsync(bin, argv, {
+    cwd,
+    timeoutMs: TIMEOUT_MS,
+    maxBuffer: MAX_BUFFER2
+  });
+  return {
+    status: res.status,
+    stdout: decodeOutput(res.stdout),
+    stderr: decodeOutput(res.stderr),
+    error: res.error ?? void 0,
+    timedOut: res.timedOut
+  };
+}
+function resolveTarget(workspace, value) {
+  const resolved = resolveWithinRoot(workspace, value);
+  if (!resolved) {
+    return { error: `\u8DEF\u5F84\u4E0D\u5728\u5DE5\u4F5C\u533A\u5185\uFF08\u5DF2\u62D2\u7EDD\uFF09: ${value}` };
+  }
+  return { abs: resolved.real, root: resolved.root };
+}
+function relOut(workspace, abs) {
+  return path4.relative(workspace, abs) || abs;
+}
+function registerMediaTool(registry, workspace, opts = {}) {
+  const platform = opts.platform ?? process.platform;
+  const arch = process.arch;
+  const media = async (args) => {
+    const root = path4.resolve(workspace);
+    const op = str(args["op"]);
+    if (!op) {
+      return { error: `\u7F3A\u5C11\u53C2\u6570 op\u3002\u53EF\u9009\u503C\uFF1A${OPS.join(" / ")}` };
+    }
+    if (!OPS.includes(op)) {
+      return { error: `\u672A\u77E5\u64CD\u4F5C ${JSON.stringify(op)}\u3002\u53EF\u9009\u503C\uFF1A${OPS.join(" / ")}` };
+    }
+    const bins = resolveMedia(root, opts);
+    const needed = op === "probe" ? "ffprobe" : "ffmpeg";
+    if (op === "setup") {
+      const already = bins[needed];
+      if (already) {
+        return {
+          ok: true,
+          already_available: true,
+          path: already.path,
+          source: already.source,
+          message: "ffmpeg \u5DF2\u53EF\u7528\uFF0C\u65E0\u9700\u4E0B\u8F7D\u3002"
+        };
+      }
+      const res = await downloadFfmpeg(root, {});
+      if (!res.ok) {
+        return {
+          ...missingGuidance("ffmpeg", "setup", platform, arch),
+          error: `\u81EA\u52A8\u4E0B\u8F7D\u5931\u8D25\uFF1A${res.error ?? "\u672A\u77E5\u539F\u56E0"}`
+        };
+      }
+      return {
+        ok: true,
+        installed: res.installed,
+        notes: res.notes,
+        message: "\u5DF2\u5B89\u88C5\u5230 .agent/bin\uFF0C\u540E\u7EED media \u8C03\u7528\u4F1A\u76F4\u63A5\u4F7F\u7528\u5B83\u3002"
+      };
+    }
+    if (!bins[needed]) {
+      return missingGuidance(needed, op, platform, arch);
+    }
+    let inputAbs;
+    let relRoot = root;
+    if (NEEDS_INPUT.has(op)) {
+      const input = str(args["input"]);
+      if (!input) return { error: `\u64CD\u4F5C ${op} \u9700\u8981\u53C2\u6570 input\uFF08\u5DE5\u4F5C\u533A\u5185\u76F8\u5BF9\u8DEF\u5F84\uFF09` };
+      const r = resolveTarget(root, input);
+      if ("error" in r) return { error: r.error };
+      if (!fs3.existsSync(r.abs) || !fs3.statSync(r.abs).isFile()) {
+        return { error: `\u8F93\u5165\u6587\u4EF6\u4E0D\u5B58\u5728: ${input}` };
+      }
+      inputAbs = r.abs;
+      relRoot = r.root;
+    }
+    let outputAbs;
+    if (NEEDS_OUTPUT.has(op)) {
+      const output = str(args["output"]);
+      if (!output) return { error: `\u64CD\u4F5C ${op} \u9700\u8981\u53C2\u6570 output\uFF08\u5DE5\u4F5C\u533A\u5185\u76F8\u5BF9\u8DEF\u5F84\uFF09` };
+      const r = resolveTarget(root, output);
+      if ("error" in r) return { error: r.error };
+      fs3.mkdirSync(path4.dirname(r.abs), { recursive: true });
+      outputAbs = r.abs;
+      relRoot = r.root;
+    }
+    if (op === "probe") {
+      const out2 = await runBinary(bins.ffprobe.path, buildFfprobeArgs(inputAbs), root);
+      if (out2.error) return { error: `\u6267\u884C ffprobe \u5931\u8D25: ${out2.error.message}` };
+      if (out2.timedOut) {
+        return { error: `ffprobe \u8D85\u65F6\uFF08${TIMEOUT_MS / 1e3}s\uFF09\u540E\u5DF2\u7EC8\u6B62` };
+      }
+      if (out2.status !== 0 && !out2.stdout.trim()) {
+        return { error: `ffprobe \u9000\u51FA\u7801 ${out2.status}`, stderr: truncateTail(out2.stderr) };
+      }
+      try {
+        return {
+          ok: true,
+          input: relOut(relRoot, inputAbs),
+          ...summarizeProbe(JSON.parse(out2.stdout))
+        };
+      } catch {
+        return { error: "ffprobe \u8F93\u51FA\u4E0D\u662F\u5408\u6CD5 JSON", stdout: truncateTail(out2.stdout) };
+      }
+    }
+    const built = buildFfmpegArgs(op, args, { input: inputAbs, output: outputAbs });
+    if (!Array.isArray(built)) return built;
+    const out = await runBinary(bins.ffmpeg.path, built, root);
+    if (out.error) {
+      return {
+        error: `\u6267\u884C ffmpeg \u5931\u8D25: ${out.error.message}`
+      };
+    }
+    if (out.timedOut) {
+      return {
+        error: `ffmpeg \u8D85\u8FC7 ${TIMEOUT_MS / 1e3} \u79D2\u672A\u5B8C\u6210\uFF0C\u5DF2\u7EC8\u6B62`,
+        hint: "\u53EF\u8003\u8651\u7528\u66F4\u77ED\u7684\u7247\u6BB5\u6216 gpu \u7F16\u7801"
+      };
+    }
+    if (out.status !== 0) {
+      return {
+        error: `ffmpeg \u9000\u51FA\u7801 ${out.status}`,
+        stderr: truncateTail(out.stderr)
+      };
+    }
+    const result = {
+      ok: true,
+      op,
+      output: outputAbs ? relOut(relRoot, outputAbs) : void 0
+    };
+    if (outputAbs) {
+      try {
+        result["size_bytes"] = fs3.statSync(outputAbs).size;
+      } catch {
+      }
+    }
+    if (out.stderr.trim()) result["ffmpeg_log"] = truncateTail(out.stderr);
+    return result;
+  };
+  registry.register(
+    media,
+    {
+      category: "media",
+      riskLevel: "medium",
+      capabilities: ["ffmpeg \u97F3\u89C6\u9891\u5904\u7406\uFF1A\u63A2\u5143\u6570\u636E\u3001\u88C1\u526A\u3001\u8F6C\u7801\u3001\u62BD\u97F3\u8F68\u3001\u62BD\u5E27\u3001\u7F29\u7565\u56FE\u3001\u538B\u7F29"],
+      // 会调用外部二进制并写文件，且 op="setup" 还会下载安装；一律弹审批
+      requiresApproval: true
+    },
+    {
+      type: "function",
+      function: {
+        name: "media",
+        description: "\u97F3\u89C6\u9891\u5904\u7406\uFF08\u57FA\u4E8E ffmpeg\uFF09\u3002op \u53D6\u503C\uFF1Aprobe \u63A2\u5143\u6570\u636E\uFF1Btrim \u88C1\u526A\uFF08\u6D41\u62F7\u8D1D\uFF0C\u65E0\u635F\u4F46\u5207\u70B9\u5BF9\u9F50\u5173\u952E\u5E27\uFF09\uFF1Bconvert \u8F6C\u7801\uFF1Bextract_audio \u62BD\u97F3\u8F68\uFF1Bextract_frame \u5728\u6307\u5B9A\u65F6\u95F4\u62BD\u4E00\u5E27\uFF1Bthumbnail \u751F\u6210\u7F29\u7565\u56FE\uFF1Bcompress \u538B\u7F29\uFF08\u9ED8\u8BA4 H.264 CRF 28\uFF09\u3002setup \u7528\u4E8E\u5728\u7F3A\u5C11 ffmpeg \u65F6\u81EA\u52A8\u4E0B\u8F7D\u5B98\u65B9\u9759\u6001\u6784\u5EFA\u5230 .agent/bin\u3002\u65F6\u95F4\u53C2\u6570 ss/to/duration \u63A5\u53D7\u79D2\u6570\u6216 HH:MM:SS\u3002\u8F93\u5165\u8F93\u51FA\u5747\u4E3A\u5DE5\u4F5C\u533A\u5185\u76F8\u5BF9\u8DEF\u5F84\u3002",
+        parameters: {
+          type: "object",
+          properties: {
+            op: {
+              type: "string",
+              enum: [...OPS],
+              description: "\u8981\u6267\u884C\u7684\u64CD\u4F5C"
+            },
+            input: { type: "string", description: "\u8F93\u5165\u6587\u4EF6\u8DEF\u5F84\uFF08\u5DE5\u4F5C\u533A\u5185\u76F8\u5BF9\u8DEF\u5F84\uFF09" },
+            output: { type: "string", description: "\u8F93\u51FA\u6587\u4EF6\u8DEF\u5F84\uFF08\u5DE5\u4F5C\u533A\u5185\u76F8\u5BF9\u8DEF\u5F84\uFF09" },
+            ss: { type: "string", description: "\u8D77\u59CB\u65F6\u95F4\uFF0C\u5982 12.5 / 00:12.5 / 00:00:12.5" },
+            to: { type: "string", description: "\u7ED3\u675F\u65F6\u95F4\uFF08\u4E0E ss \u914D\u5408\uFF0Ctrim \u7528\uFF09" },
+            duration: { type: "string", description: "\u65F6\u957F\uFF08\u79D2\uFF0Ctrim \u7528\uFF1B\u4E0E to \u4E8C\u9009\u4E00\uFF09" },
+            format: { type: "string", description: "\u8F93\u51FA\u5BB9\u5668\u683C\u5F0F\uFF0C\u5982 mp4 / webm / mp3 / png" },
+            fps: { type: "number", description: "\u8F93\u51FA\u5E27\u7387\uFF08convert\uFF09" },
+            width: { type: "number", description: "\u8F93\u51FA\u5BBD\u5EA6\uFF08\u50CF\u7D20\uFF09" },
+            height: { type: "number", description: "\u8F93\u51FA\u9AD8\u5EA6\uFF08\u50CF\u7D20\uFF09" },
+            bitrate: { type: "string", description: "\u89C6\u9891\u7801\u7387\uFF0C\u5982 2M / 1500k" },
+            codec: { type: "string", description: "\u89C6\u9891\u7F16\u7801\u5668\uFF0C\u5982 libx264 / libvpx-vp9" },
+            quality: { type: "number", description: "compress \u7684 CRF \u503C 0\uFF5E51\uFF0C\u9ED8\u8BA4 28" },
+            preset: { type: "string", description: "compress \u7684 x264 preset\uFF0C\u9ED8\u8BA4 medium" }
+          },
+          required: ["op"]
+        }
+      }
+    }
+  );
+}
+export {
+  buildFfmpegArgs,
+  buildFfprobeArgs,
+  parseTimecode,
+  registerMediaTool,
+  summarizeProbe
+};
+//# sourceMappingURL=media.js.map