pup-recorder 0.0.8

package/src/base/retry.ts

@@ -0,0 +1,40 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/05.
+
+import { setTimeout } from "timers/promises";
+import { sleep } from "./timing";
+
+export interface RetryOptions<Args extends any[], Ret> {
+  fn: (...args: Args) => Promise<Ret>;
+  maxAttempts?: number;
+  timeout?: number;
+}
+
+export function useRetry<Args extends any[], Ret>({
+  fn,
+  maxAttempts = 3,
+  timeout,
+}: RetryOptions<Args, Ret>) {
+  const timeoutError = new Error(`timeout over ${timeout}ms`);
+  return async function (...args: Args) {
+    let attempt = 0;
+    while (true) {
+      try {
+        const promises = [fn(...args)];
+        if (timeout) {
+          promises.push(
+            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);
+      }
+    }
+  };
+}

package/src/base/stream.ts

@@ -0,0 +1,74 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/09.
+
+import type { ChildProcess } from "child_process";
+
+export interface StreamWriter {
+  write(buffer: Buffer): Promise<void>;
+  end(): void;
+}
+
+export function createWriter(stdin: NodeJS.WritableStream): StreamWriter {
+  const drainPromise = new Map<NodeJS.WritableStream, Promise<void>>();
+
+  const waitDrain = (stream: NodeJS.WritableStream) => {
+    const existing = drainPromise.get(stream);
+    if (existing) return existing;
+    const promise = new Promise<void>((resolve, reject) => {
+      const cleanup = (fn: () => void) => {
+        stream.off("drain", onDrain);
+        stream.off("error", onError);
+        stream.off("close", onClose);
+        drainPromise.delete(stream);
+        fn();
+      };
+      const onDrain = () => cleanup(resolve);
+      const onError = (err: Error) => cleanup(() => reject(err));
+      const onClose = () => cleanup(() => reject(new Error("stream closed")));
+      stream.on("drain", onDrain);
+      stream.on("error", onError);
+      stream.on("close", onClose);
+    });
+    drainPromise.set(stream, promise);
+    return promise;
+  };
+
+  const destroyed = () => Reflect.get(stdin, "destroyed");
+  return {
+    async write(buffer: Buffer) {
+      if (destroyed()) {
+        throw new Error("stdin destroyed");
+      }
+      if (!stdin.write(buffer)) {
+        await waitDrain(stdin);
+      }
+    },
+    end: () => {
+      if (!destroyed()) stdin.end();
+    },
+  };
+}
+
+export function pipeline(...procs: ChildProcess[]) {
+  for (let i = 0; i < procs.length - 1; i++) {
+    const src = procs[i];
+    const dst = procs[i + 1];
+    if (!src?.stdout || !dst?.stdin) throw new Error("pipeline broken");
+    src.stdout.pipe(dst.stdin);
+  }
+}
+
+export function waitAll(...procs: ChildProcess[]) {
+  return Promise.all(
+    procs.map(
+      (proc) =>
+        new Promise<void>((resolve, reject) => {
+          proc.on("error", reject);
+          proc.on("close", (code) =>
+            code === 0
+              ? resolve()
+              : reject(new Error(`exit ${code ?? "null"}`)),
+          );
+        }),
+    ),
+  );
+}

package/src/base/timing.ts

@@ -0,0 +1,23 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/09.
+
+export function sleep(ms: number) {
+  return new Promise<void>((resolve) => setTimeout(resolve, ms));
+}
+
+export function periodical(
+  callback: (count: number) => Promise<void> | void,
+  ms: number,
+) {
+  let token: NodeJS.Timeout;
+  let closed = false;
+  async function tick(count: number) {
+    await callback(count);
+    if (closed) return;
+    token = setTimeout(() => tick(count + 1), ms);
+  }
+  token = setTimeout(() => tick(0), ms);
+  return () => {
+    closed = true;
+    clearTimeout(token);
+  };
+}

package/src/base/types.ts

@@ -0,0 +1,19 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/06.
+
+import type { Size } from "electron";
+
+export interface VideoSpec {
+  fps: number;
+  frames: number;
+  size: Size;
+}
+
+export interface VideoFiles {
+  mp4?: string;
+  webm?: string;
+  mov?: string;
+}
+
+export interface VideoFilesWithCover extends VideoFiles {
+  cover: string;
+}

package/src/cli.ts

@@ -0,0 +1,6 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/01/30.
+
+import { makeCLI } from "./common";
+import { pup } from "./pup";
+
+makeCLI("pup", pup);

package/src/common.ts

@@ -0,0 +1,53 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/09.
+
+import { program } from "commander";
+import { pupUseInnerProxy } from "./base/constants";
+import { logger } from "./base/logging";
+import { noerr } from "./base/noerr";
+import { parseNumber } from "./base/parser";
+import { pargs } from "./base/process";
+import type { RecordOptions } from "./base/record";
+
+export const DEFAULT_WIDTH = 1920;
+export const DEFAULT_HEIGHT = 1080;
+export const DEFAULT_FPS = 30;
+export const DEFAULT_DURATION = 5;
+export const DEFAULT_OUT_DIR = "out";
+
+export type CLICallback = (
+  source: string,
+  options: RecordOptions & Record<string, unknown>,
+) => Promise<unknown>;
+
+export function makeCLI(name: string, callback: CLICallback) {
+  program
+    .name(name)
+    .argument("<source>", "URL 或 HTML data")
+    .option("-w, --width <number>", "视频宽度", `${DEFAULT_WIDTH}`)
+    .option("-h, --height <number>", "视频高度", `${DEFAULT_HEIGHT}`)
+    .option("-f, --fps <number>", "帧率", `${DEFAULT_FPS}`)
+    .option("-t, --duration <number>", "录制时长（秒）", `${DEFAULT_DURATION}`)
+    .option("-o, --out-dir <path>", "输出目录", `${DEFAULT_OUT_DIR}`)
+    .option("-a, --with-alpha-channel", "输出包含 alpha 通道的视频", false)
+    .option(
+      "--use-inner-proxy",
+      "使用 B 站内网代理加速资源访问",
+      pupUseInnerProxy,
+    )
+    .action(async (source: string, opts) => {
+      try {
+        await callback(source, {
+          width: noerr(parseNumber, DEFAULT_WIDTH)(opts.width),
+          height: noerr(parseNumber, DEFAULT_HEIGHT)(opts.height),
+          fps: noerr(parseNumber, DEFAULT_FPS)(opts.fps),
+          duration: noerr(parseNumber, DEFAULT_DURATION)(opts.duration),
+          outDir: opts.outDir ?? DEFAULT_OUT_DIR,
+          withAlphaChannel: opts.withAlphaChannel ?? false,
+          useInnerProxy: opts.useInnerProxy ?? pupUseInnerProxy,
+        });
+      } catch (e) {
+        logger.fatal(e);
+      }
+    });
+  program.parse(pargs());
+}

package/src/index.ts

@@ -0,0 +1,14 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/01/30.
+
+export * from "./base/constants";
+export * from "./base/env";
+export * from "./base/lazy";
+export * from "./base/limiter";
+export * from "./base/logging";
+export * from "./base/noerr";
+export * from "./base/parser";
+export * from "./base/process";
+export * from "./base/retry";
+export * from "./base/timing";
+
+export { pup, type PupOptions } from "./pup";

package/src/pup.ts

@@ -0,0 +1,142 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/09.
+
+import { spawn } from "child_process";
+import type { Size } from "electron";
+import { readFile, rm } from "fs/promises";
+import { join } from "path";
+import { AbortLink, type AbortQuery } from "./base/abort";
+import { pupAppPath } from "./base/constants";
+import { runElectronApp } from "./base/electron";
+import { encodeBgraFile, encodeBgraToMov } from "./base/encoder";
+import { createCoverCommand } from "./base/ffmpeg";
+import { ConcurrencyLimiter } from "./base/limiter";
+import { logger } from "./base/logging";
+import { parseNumber } from "./base/parser";
+import { type ProcessHandle } from "./base/process";
+import type { RecordResult } from "./base/record";
+import { waitAll } from "./base/stream";
+import type { VideoFilesWithCover, VideoSpec } from "./base/types";
+import { DEFAULT_HEIGHT, DEFAULT_WIDTH } from "./common";
+
+const TAG = "[pup]";
+
+export type PupProgressCallback = (progress: number) => Promise<void> | void;
+
+export interface PupOptions {
+  withAlphaChannel?: boolean;
+  width?: number;
+  height?: number;
+  fps?: number;
+  duration?: number;
+  outDir?: string;
+  cancelQuery?: AbortQuery;
+  onProgress?: PupProgressCallback;
+}
+
+const PROGRESS_TAG = " progress: ";
+
+function runPupApp(source: string, options: PupOptions) {
+  logger.debug(TAG, `runPupApp`, source, options);
+
+  const args: string[] = [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: Buffer) => {
+    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 };
+}
+
+export async function pup(source: string, options: PupOptions) {
+  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 = join(outDir, "record.json");
+  const meta = JSON.parse(await readFile(metaPath, "utf-8")) as RecordResult;
+
+  const { bgraPath, written, options: recordOptions } = meta;
+  const { fps, width, height, withAlphaChannel } = recordOptions;
+  const size: Size = { width, height };
+
+  const outputs: VideoFilesWithCover = {
+    mp4: withAlphaChannel ? undefined : join(outDir, "output.mp4"),
+    webm: withAlphaChannel ? join(outDir, "output.webm") : undefined,
+    mov: withAlphaChannel ? join(outDir, "output.mov") : undefined,
+    cover: join(outDir, "cover.png"),
+  };
+
+  try {
+    const t1 = performance.now();
+
+    const spec: VideoSpec = { fps, frames: written, size };
+    const handles: ProcessHandle[] = [];
+    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(
+        spawn(coverCmd.command, coverCmd.args, { stdio: "inherit" }),
+      );
+    }
+
+    link.stop();
+    logger.info(TAG, `encoding cost ${Math.round(performance.now() - t1)}ms`);
+
+    await Promise.all([
+      rm(bgraPath, { force: true }),
+      rm(metaPath, { force: true }),
+    ]);
+    return {
+      ...outputs,
+      width,
+      height,
+      fps,
+      duration: Math.ceil(written / fps),
+    };
+  } catch (error) {
+    await rm(outDir, { recursive: true, force: true });
+    throw error;
+  }
+}

package/src/rust/lib.rs

@@ -0,0 +1,105 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/10.
+
+use napi::bindgen_prelude::*;
+use napi_derive::napi;
+use std::fs::File;
+use std::io::Write;
+use std::sync::mpsc::{sync_channel, Receiver, SyncSender};
+use std::sync::Mutex;
+use std::thread;
+use tokio::task;
+
+#[napi]
+pub struct FixedBufferWriter {
+    state: Mutex<Option<WriterState>>,
+    recycle_rx: Mutex<Receiver<Vec<u8>>>,
+    buffer_capacity: usize,
+}
+
+struct WriterState {
+    sender: SyncSender<Vec<u8>>,
+    thread_handle: thread::JoinHandle<std::io::Result<()>>,
+}
+
+#[napi]
+impl FixedBufferWriter {
+    #[napi(constructor)]
+    pub fn new(path: String, buffer_capacity: u32, queue_depth: Option<u32>) -> Result<Self> {
+        let depth = queue_depth.unwrap_or(2) as usize;
+        let capacity = buffer_capacity as usize;
+
+        let (data_tx, data_rx) = sync_channel::<Vec<u8>>(depth);
+        let (recycle_tx, recycle_rx) = sync_channel::<Vec<u8>>(depth + 1);
+
+        let handle = thread::spawn(move || {
+            let mut file = File::create(path)?;
+
+            while let Ok(mut buffer) = data_rx.recv() {
+                file.write_all(&buffer)?;
+                buffer.clear();
+                let _ = recycle_tx.try_send(buffer);
+            }
+
+            file.sync_data()?;
+            Ok(())
+        });
+
+        Ok(FixedBufferWriter {
+            state: Mutex::new(Some(WriterState {
+                sender: data_tx,
+                thread_handle: handle,
+            })),
+            recycle_rx: Mutex::new(recycle_rx),
+            buffer_capacity: capacity,
+        })
+    }
+
+    #[napi]
+    pub fn write(&self, buffer: Buffer) -> Result<()> {
+        let sender = {
+            let guard = self.state.lock().unwrap();
+            if let Some(state) = guard.as_ref() {
+                state.sender.clone()
+            } else {
+                return Ok(());
+            }
+        };
+
+        let mut vec = {
+            let recycle = self.recycle_rx.lock().unwrap();
+            recycle
+                .try_recv()
+                .unwrap_or_else(|_| Vec::with_capacity(self.buffer_capacity))
+        };
+
+        vec.extend_from_slice(buffer.as_ref());
+
+        sender
+            .send(vec)
+            .map_err(|e| Error::from_reason(e.to_string()))?;
+
+        Ok(())
+    }
+
+    #[napi]
+    pub async fn close(&self) -> Result<()> {
+        let state_opt = {
+            let mut guard = self.state.lock().unwrap();
+            guard.take()
+        };
+
+        if let Some(state) = state_opt {
+            drop(state.sender);
+
+            let handle = state.thread_handle;
+            task::spawn_blocking(move || {
+                handle.join().map_err(|_| {
+                    std::io::Error::new(std::io::ErrorKind::Other, "Thread panicked")
+                })?
+            })
+            .await
+            .map_err(|e| Error::from_reason(e.to_string()))??;
+        }
+        Ok(())
+    }
+}

package/src/rust/lib.ts

@@ -0,0 +1,28 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/10.
+
+import { existsSync } from "fs";
+import { join } from "path";
+
+const { platform, arch } = process;
+
+const rustPath = `rust/${platform}-${arch}.node`;
+
+const nativeSearchPaths = [
+  join(__dirname, `../../${rustPath}`), // process start from src
+  join(__dirname, `../${rustPath}`), // process start from dist
+];
+const mod = require(nativeSearchPaths.find(existsSync)!);
+
+export interface FixedBufferWriter {
+  new (
+    path: string,
+    bufferSize: number,
+    queueDepth?: number,
+  ): FixedBufferWriter;
+
+  write(buffer: Buffer): void;
+
+  close(): Promise<void>;
+}
+
+export const FixedBufferWriter = mod.FixedBufferWriter as FixedBufferWriter;

package/tsconfig.json

@@ -0,0 +1,25 @@
+{
+  "compilerOptions": {
+    "lib": ["ESNext", "DOM"],
+    "target": "ESNext",
+    "module": "Preserve",
+    "moduleDetection": "force",
+    "types": ["node"],
+
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "verbatimModuleSyntax": true,
+    "noEmit": true,
+
+    "strict": true,
+    "skipLibCheck": true,
+    "noFallthroughCasesInSwitch": true,
+    "noUncheckedIndexedAccess": true,
+    "noImplicitOverride": true,
+
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noPropertyAccessFromIndexSignature": true
+  },
+  "include": ["src", "./*.ts"]
+}