pup-recorder 0.0.8

package/dist/cjs/index.cjs

@@ -0,0 +1,781 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  ConcurrencyLimiter: () => ConcurrencyLimiter,
+  Lazy: () => Lazy,
+  PUP_ARGS_ENV_KEY: () => PUP_ARGS_ENV_KEY,
+  exec: () => exec,
+  logger: () => logger,
+  noerr: () => noerr,
+  pargs: () => pargs,
+  parseNumber: () => parseNumber,
+  penv: () => penv,
+  periodical: () => periodical,
+  pup: () => pup,
+  pupAppPath: () => pupAppPath,
+  pupFFmpegPath: () => pupFFmpegPath,
+  pupLogLevel: () => pupLogLevel,
+  pupUseInnerProxy: () => pupUseInnerProxy,
+  sleep: () => sleep,
+  useRetry: () => useRetry
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/base/constants.ts
+var import_fs = require("fs");
+var import_path = require("path");
+
+// src/base/env.ts
+function penv(name, parser, defaultValue) {
+  try {
+    return parser(process.env[name]);
+  } catch {
+    return defaultValue;
+  }
+}
+
+// src/base/parser.ts
+function parseNumber(value) {
+  if (typeof value === "number") {
+    return value;
+  }
+  const num = Number(value);
+  if (Number.isNaN(num)) {
+    throw new Error(`Value ${value} is not a valid number`);
+  }
+  return num;
+}
+
+// src/base/constants.ts
+var pupAppSearchPaths = [
+  (0, import_path.resolve)(__dirname, "cjs/app.cjs"),
+  // process from dist
+  (0, import_path.resolve)(__dirname, "app.cjs"),
+  // process from dist/cjs
+  (0, import_path.resolve)(__dirname, "../../cjs/app.cjs")
+  // process from src
+];
+var pupAppPath = pupAppSearchPaths.find(import_fs.existsSync);
+var env = process.env;
+var pupLogLevel = penv("PUP_LOG_LEVEL", parseNumber, 2);
+var pupUseInnerProxy = env["PUP_USE_INNER_PROXY"] === "1";
+var pupFFmpegPath = env["FFMPEG_BIN"] ?? `ffmpeg`;
+
+// src/base/lazy.ts
+var Lazy = class {
+  constructor(makeValue) {
+    this.makeValue = makeValue;
+  }
+  get value() {
+    if (!this._initialized) {
+      this._value = this.makeValue();
+      this._initialized = true;
+    }
+    return this._value;
+  }
+  get initialized() {
+    return this._initialized;
+  }
+  _initialized = false;
+  _value;
+};
+
+// src/base/limiter.ts
+var ConcurrencyLimiter = class {
+  constructor(maxConcurrency) {
+    this.maxConcurrency = maxConcurrency;
+  }
+  _active = 0;
+  _queue = [];
+  _pending = 0;
+  _ended = false;
+  get active() {
+    return this._active;
+  }
+  get pending() {
+    return this._pending;
+  }
+  async schedule(fn) {
+    if (this._ended) {
+      throw new Error("ended");
+    }
+    return new Promise((resolve3, reject) => {
+      const run = () => {
+        this._active++;
+        this._pending--;
+        fn().then(resolve3).catch(reject).finally(() => {
+          this._active--;
+          this.next();
+        });
+      };
+      this._pending++;
+      if (this._active < this.maxConcurrency) {
+        run();
+      } else {
+        this._queue.push(run);
+      }
+    });
+  }
+  async end() {
+    if (!this._ended) {
+      this._ended = true;
+      while (this._active > 0 || this._pending > 0) {
+        await new Promise((resolve3) => setTimeout(resolve3, 50));
+      }
+    }
+  }
+  next() {
+    if (this._active < this.maxConcurrency && this._queue.length > 0) {
+      this._queue.shift()?.();
+    }
+  }
+};
+
+// src/base/logging.ts
+var DEBUG = "<pup@debug>";
+var INFO = "<pup@info>";
+var WARN = "<pup@warn>";
+var ERROR = "<pup@error>";
+var FATAL = "<pup@fatal>";
+var Logger = class {
+  _impl;
+  get impl() {
+    return this._impl;
+  }
+  set impl(value) {
+    const debug = value.debug ?? console.debug;
+    const info = value.info ?? console.info;
+    const warn = value.warn ?? console.warn;
+    const error = value.error ?? console.error;
+    this._impl = {
+      debug: pupLogLevel >= 3 ? debug : void 0,
+      info: pupLogLevel >= 2 ? info : void 0,
+      warn: pupLogLevel >= 1 ? warn : void 0,
+      error: pupLogLevel >= 0 ? error : void 0
+    };
+  }
+  constructor() {
+    this.impl = console;
+  }
+  debug(...messages) {
+    this.impl?.debug?.(DEBUG, ...messages);
+  }
+  info(...messages) {
+    this.impl?.info?.(INFO, ...messages);
+  }
+  warn(...messages) {
+    this.impl?.warn?.(WARN, ...messages);
+  }
+  error(...messages) {
+    this.impl?.error?.(ERROR, ...messages);
+  }
+  fatal(...messages) {
+    this.impl?.error?.(FATAL, ...messages);
+    process.exit(1);
+  }
+  dispatch(message) {
+    if (message.startsWith(DEBUG)) {
+      this.debug(message.slice(DEBUG.length + 1));
+    } else if (message.startsWith(INFO)) {
+      this.info(message.slice(INFO.length + 1));
+    } else if (message.startsWith(WARN)) {
+      this.warn(message.slice(WARN.length + 1));
+    } else if (message.startsWith(ERROR)) {
+      this.error(message.slice(ERROR.length + 1));
+    } else {
+      this.info(message);
+    }
+  }
+  attach(proc, name) {
+    return new Promise((resolve3, reject) => {
+      this.debug(`${name}.attach`);
+      let fatal = "";
+      const dispatch = (data) => {
+        const message = data.toString();
+        if (message.startsWith(FATAL)) {
+          fatal += message.slice(FATAL.length + 1);
+        } else {
+          this.dispatch(message);
+        }
+      };
+      proc.stderr?.on("data", dispatch);
+      proc.stdout?.on("data", dispatch);
+      proc.on("message", dispatch).on("error", (err) => {
+        fatal += err.message;
+        proc.kill();
+      }).once("close", (code, signal) => {
+        if (code || signal || fatal) {
+          fatal ||= `command failed: ${proc.spawnargs.join(" ")}`;
+          this.error(`${name}.close`, { code, signal, fatal });
+          reject(new Error(fatal));
+        } else {
+          this.debug(`${name}.close`);
+          resolve3();
+        }
+      }).on("unhandledRejection", (reason) => {
+        this.error(`${name}.unhandled`, reason);
+      }).on("uncaughtExceptionMonitor", (err) => {
+        this.error(`${name}.unhandled`, err);
+      });
+    });
+  }
+};
+var logger = new Logger();
+
+// src/base/noerr.ts
+function noerr(fn, defaultValue) {
+  return (...args) => {
+    try {
+      const ret = fn(...args);
+      if (ret instanceof Promise) {
+        return ret.catch(() => defaultValue);
+      }
+      return ret;
+    } catch {
+      return defaultValue;
+    }
+  };
+}
+
+// src/base/process.ts
+var import_child_process = require("child_process");
+var PUP_ARGS_ENV_KEY = "__PUP_ARGS__";
+function pargs() {
+  const pupArgs = process.env[PUP_ARGS_ENV_KEY];
+  if (pupArgs) {
+    const args = ["exec", ...process.argv.slice(-1)];
+    args.push(...JSON.parse(pupArgs));
+    logger.debug("pupargs", args);
+    return args;
+  }
+  logger.debug("procargv", process.argv);
+  return process.argv;
+}
+function exec(cmd, options) {
+  const parts = cmd.split(" ").filter((s) => s.length);
+  const [command, ...args] = parts;
+  if (!command) throw new Error("empty command");
+  const proc = (0, import_child_process.spawn)(command, args, {
+    stdio: "inherit",
+    ...options
+  });
+  return { process: proc, wait: logger.attach(proc, command) };
+}
+
+// src/base/retry.ts
+var import_promises = require("timers/promises");
+
+// src/base/timing.ts
+function sleep(ms) {
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
+}
+function periodical(callback, ms) {
+  let token;
+  let closed = false;
+  async function tick(count) {
+    await callback(count);
+    if (closed) return;
+    token = setTimeout(() => tick(count + 1), ms);
+  }
+  token = setTimeout(() => tick(0), ms);
+  return () => {
+    closed = true;
+    clearTimeout(token);
+  };
+}
+
+// src/base/retry.ts
+function useRetry({
+  fn,
+  maxAttempts = 3,
+  timeout
+}) {
+  const timeoutError = new Error(`timeout over ${timeout}ms`);
+  return async function(...args) {
+    let attempt = 0;
+    while (true) {
+      try {
+        const promises = [fn(...args)];
+        if (timeout) {
+          promises.push(
+            (0, import_promises.setTimeout)(timeout).then(() => {
+              throw timeoutError;
+            })
+          );
+        }
+        return await Promise.race(promises);
+      } catch (e) {
+        attempt++;
+        if (attempt >= maxAttempts) {
+          throw e;
+        }
+        await sleep(Math.pow(2, attempt) * 100 + Math.random() * 100);
+      }
+    }
+  };
+}
+
+// src/pup.ts
+var import_child_process2 = require("child_process");
+var import_promises2 = require("fs/promises");
+var import_path3 = require("path");
+
+// src/base/abort.ts
+var AbortLink = class _AbortLink {
+  constructor(query, interval = 1e3) {
+    this.query = query;
+    this.interval = interval;
+    if (query) {
+      this.tick();
+    }
+  }
+  _callback;
+  _aborted;
+  _stopped = false;
+  static start(query, interval) {
+    return new _AbortLink(query, interval);
+  }
+  get aborted() {
+    return !this._stopped && this._aborted;
+  }
+  get stopped() {
+    return this._stopped;
+  }
+  async onAbort(callback) {
+    if (this._aborted) {
+      await callback();
+    } else {
+      this._callback = callback;
+    }
+  }
+  wait(...handles) {
+    const abort = new Promise((_, reject) => {
+      this.onAbort(async () => {
+        handles.forEach((h) => h.process.kill());
+        reject(new Error("aborted"));
+      });
+    });
+    return Promise.race([
+      abort,
+      Promise.all(handles.map((h) => h.wait))
+      //
+    ]);
+  }
+  stop() {
+    this._stopped = true;
+  }
+  tick() {
+    setTimeout(async () => {
+      if (this._stopped) {
+        return;
+      }
+      this._aborted = await this.query?.();
+      if (this._stopped) {
+        return;
+      }
+      if (this._aborted) {
+        await this._callback?.();
+      } else {
+        this.tick();
+      }
+    }, this.interval);
+  }
+};
+
+// src/base/electron.ts
+var import_electron = __toESM(require("electron"), 1);
+var ELECTRON_OPTS = [
+  "no-sandbox",
+  "disable-setuid-sandbox",
+  "disable-gpu",
+  "disable-dev-shm-usage",
+  "disable-software-rasterizer",
+  "disable-web-security",
+  "disable-site-isolation-trials",
+  "disable-features=IsolateOrigins,site-per-process",
+  "allow-insecure-localhost",
+  "ignore-certificate-errors",
+  "disable-blink-features=AutomationControlled",
+  "mute-audio",
+  "disable-extensions",
+  "disable-background-networking",
+  "address-family=ipv4",
+  "disable-async-dns",
+  "force-device-scale-factor=1",
+  "trace-warnings",
+  "force-color-profile=srgb",
+  "disable-color-correct-rendering",
+  "log-level=3"
+];
+function runElectronApp(size, app, args) {
+  const electronArgs = ELECTRON_OPTS.map((a) => `--${a}`);
+  const cmdParts = [];
+  if (process.platform === "linux") {
+    cmdParts.push(
+      "xvfb-run",
+      "--auto-servernum",
+      `--server-args='-screen 0 ${size.width}x${size.height}x24'`
+    );
+  }
+  cmdParts.push(import_electron.default, ...electronArgs, app);
+  return exec(cmdParts.join(" "), {
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: true,
+    env: {
+      ...process.env,
+      ELECTRON_DISABLE_DBUS: "1",
+      RUST_BACKTRACE: "full",
+      __PUP_ARGS__: JSON.stringify(args)
+    }
+  });
+}
+
+// src/base/ffmpeg.ts
+var import_fs2 = require("fs");
+var import_path2 = require("path");
+var import_process2 = require("process");
+var quiet = ["-hide_banner", "-loglevel", "error", "-nostats"];
+function resolveX265() {
+  const path = `x265/${import_process2.platform}-${import_process2.arch}`;
+  const dirs = [
+    (0, import_path2.resolve)(__dirname, `../../${path}`),
+    // process from src
+    (0, import_path2.resolve)(__dirname, `../${path}`)
+    // process from dist
+  ];
+  const found = dirs.find(import_fs2.existsSync);
+  if (!found) {
+    throw new Error("x265 not found");
+  }
+  return found;
+}
+function createBgraFileCommand(bgraPath, spec, files) {
+  const { fps, frames } = spec;
+  const args = [
+    "-y",
+    ...quiet,
+    "-f",
+    "rawvideo",
+    "-pix_fmt",
+    "bgra",
+    "-s",
+    `${spec.size.width}x${spec.size.height}`,
+    "-r",
+    `${fps}`,
+    "-i",
+    bgraPath,
+    "-frames:v",
+    `${Math.floor(frames)}`
+  ];
+  if (files.mp4) {
+    args.push(
+      "-colorspace",
+      "bt709",
+      "-color_primaries",
+      "bt709",
+      "-color_trc",
+      "bt709",
+      "-c:v",
+      "libx264",
+      "-preset",
+      "fast",
+      "-threads",
+      "0",
+      "-pix_fmt",
+      "yuv420p",
+      "-movflags",
+      "+faststart",
+      files.mp4
+    );
+  }
+  if (files.webm) {
+    args.push(
+      "-c:v",
+      "libvpx-vp9",
+      "-row-mt",
+      "1",
+      "-cpu-used",
+      "1",
+      "-threads",
+      "0",
+      "-pix_fmt",
+      "yuva420p",
+      "-auto-alt-ref",
+      "0",
+      files.webm
+    );
+  }
+  return { command: pupFFmpegPath, args };
+}
+function createBgraToMovPipeline(bgraPath, spec, mov) {
+  const { fps, size } = spec;
+  return {
+    raw: {
+      command: pupFFmpegPath,
+      args: [
+        "-y",
+        ...quiet,
+        "-f",
+        "rawvideo",
+        "-pix_fmt",
+        "bgra",
+        "-s",
+        `${size.width}x${size.height}`,
+        "-r",
+        `${fps}`,
+        "-i",
+        bgraPath,
+        "-f",
+        "rawvideo",
+        "-pix_fmt",
+        "yuva420p10le",
+        "pipe:1"
+      ]
+    },
+    x265: {
+      command: resolveX265(),
+      args: [
+        "--no-progress",
+        "--log-level",
+        "error",
+        "--input",
+        "-",
+        "--input-res",
+        `${size.width}x${size.height}`,
+        "--input-csp",
+        "i420",
+        "--input-depth",
+        "10",
+        "--output-depth",
+        "10",
+        "--fps",
+        `${fps}`,
+        "--alpha",
+        "--bframes",
+        "0",
+        "--colorprim",
+        "bt709",
+        "--transfer",
+        "bt709",
+        "--colormatrix",
+        "bt709",
+        "--crf",
+        "18",
+        "--output",
+        "-"
+      ]
+    },
+    mux: {
+      command: pupFFmpegPath,
+      args: [
+        "-y",
+        ...quiet,
+        "-f",
+        "hevc",
+        "-r",
+        `${fps}`,
+        "-i",
+        "pipe:0",
+        "-c:v",
+        "copy",
+        "-tag:v",
+        "hvc1",
+        "-movflags",
+        "+faststart",
+        mov
+      ]
+    }
+  };
+}
+function createCoverCommand(src, dst) {
+  return {
+    command: pupFFmpegPath,
+    args: ["-y", ...quiet, "-i", src, "-frames:v", "1", "-q:v", "2", dst]
+  };
+}
+
+// src/base/encoder.ts
+function encodeBgraFile(bgraPath, outputPath, spec, format) {
+  const files = format === "mp4" ? { mp4: outputPath } : { webm: outputPath };
+  const cmd = createBgraFileCommand(bgraPath, spec, files);
+  return exec(`${cmd.command} ${cmd.args.join(" ")}`, {
+    stdio: ["ignore", "inherit", "inherit"]
+  });
+}
+function encodeBgraToMov(bgraPath, movPath, spec) {
+  const x265 = createBgraToMovPipeline(bgraPath, spec, movPath);
+  const shellCmd = [
+    `${x265.raw.command} ${x265.raw.args.join(" ")}`,
+    `${x265.x265.command} ${x265.x265.args.join(" ")}`,
+    `${x265.mux.command} ${x265.mux.args.join(" ")}`
+  ].join(" | ");
+  return exec(shellCmd, {
+    stdio: ["ignore", "inherit", "inherit"],
+    shell: true
+  });
+}
+
+// src/base/stream.ts
+function waitAll(...procs) {
+  return Promise.all(
+    procs.map(
+      (proc) => new Promise((resolve3, reject) => {
+        proc.on("error", reject);
+        proc.on(
+          "close",
+          (code) => code === 0 ? resolve3() : reject(new Error(`exit ${code ?? "null"}`))
+        );
+      })
+    )
+  );
+}
+
+// src/common.ts
+var import_commander = require("commander");
+var DEFAULT_WIDTH = 1920;
+var DEFAULT_HEIGHT = 1080;
+
+// src/pup.ts
+var TAG = "[pup]";
+var PROGRESS_TAG = " progress: ";
+function runPupApp(source, options) {
+  logger.debug(TAG, `runPupApp`, source, options);
+  const args = [source];
+  if (options.width) args.push("--width", `${options.width}`);
+  if (options.height) args.push("--height", `${options.height}`);
+  if (options.fps) args.push("--fps", `${options.fps}`);
+  if (options.duration) args.push("--duration", `${options.duration}`);
+  if (options.outDir) args.push("--out-dir", options.outDir);
+  if (options.withAlphaChannel) args.push("--with-alpha-channel");
+  const w = options.width ?? DEFAULT_WIDTH;
+  const h = options.height ?? DEFAULT_HEIGHT;
+  const handle = runElectronApp({ width: w, height: h }, pupAppPath, args);
+  const counter = new ConcurrencyLimiter(1);
+  handle.process.stdout?.on("data", (data) => {
+    let message = data.toString().trim();
+    let start = message.indexOf(PROGRESS_TAG);
+    if (start < 0) {
+      return;
+    }
+    message = message.slice(start + PROGRESS_TAG.length);
+    const end = message.indexOf("%");
+    if (end < 0) {
+      return;
+    }
+    const progressStr = message.slice(0, end);
+    const progress = parseNumber(progressStr);
+    counter.schedule(async () => {
+      await options.onProgress?.(progress);
+    });
+  });
+  return { handle, counter };
+}
+async function pup(source, options) {
+  logger.debug(TAG, `pup`, source, options);
+  const link = AbortLink.start(options.cancelQuery);
+  const outDir = options.outDir ?? "out";
+  const t0 = performance.now();
+  const { handle, counter } = runPupApp(source, { ...options, outDir });
+  await link.wait(handle);
+  await counter.end();
+  logger.info(TAG, `capture cost ${Math.round(performance.now() - t0)}ms`);
+  const metaPath = (0, import_path3.join)(outDir, "record.json");
+  const meta = JSON.parse(await (0, import_promises2.readFile)(metaPath, "utf-8"));
+  const { bgraPath, written, options: recordOptions } = meta;
+  const { fps, width, height, withAlphaChannel } = recordOptions;
+  const size = { width, height };
+  const outputs = {
+    mp4: withAlphaChannel ? void 0 : (0, import_path3.join)(outDir, "output.mp4"),
+    webm: withAlphaChannel ? (0, import_path3.join)(outDir, "output.webm") : void 0,
+    mov: withAlphaChannel ? (0, import_path3.join)(outDir, "output.mov") : void 0,
+    cover: (0, import_path3.join)(outDir, "cover.png")
+  };
+  try {
+    const t1 = performance.now();
+    const spec = { fps, frames: written, size };
+    const handles = [];
+    if (outputs.mp4) {
+      handles.push(encodeBgraFile(bgraPath, outputs.mp4, spec, "mp4"));
+    }
+    if (outputs.webm) {
+      handles.push(encodeBgraFile(bgraPath, outputs.webm, spec, "webm"));
+    }
+    if (outputs.mov) {
+      handles.push(encodeBgraToMov(bgraPath, outputs.mov, spec));
+    }
+    await link.wait(...handles);
+    const coverSrc = outputs.mov ?? outputs.webm ?? outputs.mp4;
+    if (coverSrc) {
+      const coverCmd = createCoverCommand(coverSrc, outputs.cover);
+      await waitAll(
+        (0, import_child_process2.spawn)(coverCmd.command, coverCmd.args, { stdio: "inherit" })
+      );
+    }
+    link.stop();
+    logger.info(TAG, `encoding cost ${Math.round(performance.now() - t1)}ms`);
+    await Promise.all([
+      (0, import_promises2.rm)(bgraPath, { force: true }),
+      (0, import_promises2.rm)(metaPath, { force: true })
+    ]);
+    return {
+      ...outputs,
+      width,
+      height,
+      fps,
+      duration: Math.ceil(written / fps)
+    };
+  } catch (error) {
+    await (0, import_promises2.rm)(outDir, { recursive: true, force: true });
+    throw error;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConcurrencyLimiter,
+  Lazy,
+  PUP_ARGS_ENV_KEY,
+  exec,
+  logger,
+  noerr,
+  pargs,
+  parseNumber,
+  penv,
+  periodical,
+  pup,
+  pupAppPath,
+  pupFFmpegPath,
+  pupLogLevel,
+  pupUseInnerProxy,
+  sleep,
+  useRetry
+});
+//# sourceMappingURL=index.cjs.map