npm - pup-recorder - Versions diffs - 0.0.8 - Mend

pup-recorder 0.0.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (55) hide show

package/src/base/frame_sync.ts ADDED Viewed

@@ -0,0 +1,139 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/09.
+import type { Debugger, Size } from "electron";
+export const FRAME_SYNC_MARKER_WIDTH = 32;
+export const FRAME_SYNC_MARKER_HEIGHT = 1;
+export function buildWrapperHTML(targetURL: string, size: Size): string {
+  const { width, height } = size;
+  return `<!DOCTYPE html>
+<html>
+<head>
+  <meta charset="UTF-8">
+  <style>
+    * { margin: 0; padding: 0; box-sizing: border-box; }
+    html, body { width: ${width}px; height: ${height + 1}px; overflow: hidden; }
+    #target {
+      position: absolute;
+      top: 0;
+      left: 0;
+      width: ${width}px;
+      height: ${height}px;
+      border: none;
+      display: block;
+    }
+    #stego {
+      position: absolute;
+      top: ${height}px;
+      left: 0;
+      width: ${width}px;
+      height: 1px;
+      display: block;
+      image-rendering: pixelated;
+    }
+  </style>
+</head>
+<body>
+  <iframe id="target" src="${targetURL}"></iframe>
+  <canvas id="stego" width="${width}" height="1"></canvas>
+  <script>
+    (function() {
+      const WIDTH = ${width};
+      const MARKER_WIDTH = ${FRAME_SYNC_MARKER_WIDTH};
+      const canvas = document.getElementById('stego');
+      const ctx = canvas.getContext('2d', { willReadFrequently: true });
+      let startTime = null;
+      let rafId = null;
+      function encodeTimestamp(timestampMs) {
+        const imageData = ctx.createImageData(WIDTH, 1);
+        const data = imageData.data;
+        const timestampInt = Math.floor(timestampMs) >>> 0;
+        for (let i = 0; i < MARKER_WIDTH; i++) {
+          const bit = (timestampInt >>> (MARKER_WIDTH - 1 - i)) & 1;
+          const value = bit ? 255 : 0;
+          const idx = i * 4;
+          data[idx] = value;
+          data[idx + 1] = value;
+          data[idx + 2] = value;
+          data[idx + 3] = 255;
+        }
+        for (let i = MARKER_WIDTH; i < WIDTH; i++) {
+          const idx = i * 4;
+          data[idx] = 0;
+          data[idx + 1] = 0;
+          data[idx + 2] = 0;
+          data[idx + 3] = 255;
+        }
+        ctx.putImageData(imageData, 0, 0);
+      }
+      function updateLoop() {
+        if (startTime === null) return;
+        const elapsed = performance.now() - startTime;
+        encodeTimestamp(elapsed);
+        rafId = requestAnimationFrame(updateLoop);
+      }
+      window.__pup_start_recording__ = () => {
+        startTime = performance.now();
+        encodeTimestamp(0);
+        requestAnimationFrame(updateLoop);
+      };
+      window.__pup_stop_recording__ = () => {
+        if (rafId !== null) {
+          cancelAnimationFrame(rafId);
+          rafId = null;
+        }
+      };
+    })();
+  </script>
+</body>
+</html>`;
+}
+export function decodeTimestamp(
+  bitmap: Buffer,
+  size: Size,
+): number | undefined {
+  const { width, height } = size;
+  if (width < FRAME_SYNC_MARKER_WIDTH || height < 2) {
+    return undefined;
+  }
+  const markerRow = height - 1;
+  let timestamp = 0;
+  for (let i = 0; i < FRAME_SYNC_MARKER_WIDTH; i++) {
+    const pixelIdx = (markerRow * width + i) * 4;
+    const r = bitmap[pixelIdx] ?? 0;
+    const bit = r > 127 ? 1 : 0;
+    timestamp = (timestamp << 1) | bit;
+  }
+  timestamp = timestamp >>> 0;
+  if (!Number.isFinite(timestamp) || timestamp < 0 || timestamp > 1e7) {
+    return undefined;
+  }
+  return timestamp;
+}
+export function startSync(cdp: Debugger) {
+  return cdp.sendCommand("Runtime.evaluate", {
+    expression: `window.__pup_start_recording__()`,
+  });
+}
+export function stopSync(cdp: Debugger) {
+  return cdp.sendCommand("Runtime.evaluate", {
+    expression: `window.__pup_stop_recording__()`,
+  });
+}

package/src/base/image.ts ADDED Viewed

@@ -0,0 +1,9 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/06.
+import type { NativeImage } from "electron";
+export function isEmpty(image: NativeImage) {
+  const size = image.getSize();
+  if (size.width === 0 || size.height === 0) return true;
+  return image.isEmpty();
+}

package/src/base/lazy.ts ADDED Viewed

@@ -0,0 +1,20 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/01/30.
+export class Lazy<T> {
+  constructor(readonly makeValue: () => T) {}
+  get value(): T {
+    if (!this._initialized) {
+      this._value = this.makeValue();
+      this._initialized = true;
+    }
+    return this._value!;
+  }
+  get initialized(): boolean {
+    return this._initialized;
+  }
+  private _initialized = false;
+  private _value: T | undefined;
+}

package/src/base/limiter.ts ADDED Viewed

@@ -0,0 +1,58 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/01/30.
+export class ConcurrencyLimiter {
+  private _active = 0;
+  private _queue: VoidFunction[] = [];
+  private _pending = 0;
+  private _ended = false;
+  constructor(readonly maxConcurrency: number) {}
+  get active(): number {
+    return this._active;
+  }
+  get pending(): number {
+    return this._pending;
+  }
+  async schedule<T>(fn: () => Promise<T>): Promise<T> {
+    if (this._ended) {
+      throw new Error("ended");
+    }
+    return new Promise<T>((resolve, reject) => {
+      const run = () => {
+        this._active++;
+        this._pending--;
+        fn()
+          .then(resolve)
+          .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((resolve) => setTimeout(resolve, 50));
+      }
+    }
+  }
+  private next() {
+    if (this._active < this.maxConcurrency && this._queue.length > 0) {
+      this._queue.shift()?.();
+    }
+  }
+}

package/src/base/logging.ts ADDED Viewed

@@ -0,0 +1,123 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/06.
+import { ChildProcess, type Serializable } from "child_process";
+import { pupLogLevel } from "./constants";
+export interface LoggerLike {
+  debug?(this: void, ...messages: unknown[]): void;
+  info?(this: void, ...messages: unknown[]): void;
+  warn?(this: void, ...messages: unknown[]): void;
+  error?(this: void, ...messages: unknown[]): void;
+}
+const DEBUG = "<pup@debug>";
+const INFO = "<pup@info>";
+const WARN = "<pup@warn>";
+const ERROR = "<pup@error>";
+const FATAL = "<pup@fatal>";
+class Logger implements LoggerLike {
+  private _impl?: LoggerLike;
+  get impl(): LoggerLike | undefined {
+    return this._impl;
+  }
+  set impl(value: LoggerLike) {
+    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 : undefined,
+      info: pupLogLevel >= 2 ? info : undefined,
+      warn: pupLogLevel >= 1 ? warn : undefined,
+      error: pupLogLevel >= 0 ? error : undefined,
+    };
+  }
+  constructor() {
+    this.impl = console;
+  }
+  debug(...messages: unknown[]): void {
+    this.impl?.debug?.(DEBUG, ...messages);
+  }
+  info(...messages: unknown[]): void {
+    this.impl?.info?.(INFO, ...messages);
+  }
+  warn(...messages: unknown[]): void {
+    this.impl?.warn?.(WARN, ...messages);
+  }
+  error(...messages: unknown[]): void {
+    this.impl?.error?.(ERROR, ...messages);
+  }
+  fatal(...messages: unknown[]): never {
+    this.impl?.error?.(FATAL, ...messages);
+    process.exit(1);
+  }
+  private dispatch(message: string) {
+    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: ChildProcess, name: string) {
+    return new Promise<void>((resolve, reject) => {
+      this.debug(`${name}.attach`);
+      let fatal: string = "";
+      const dispatch = (data: Buffer | Serializable) => {
+        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`);
+            resolve();
+          }
+        })
+        .on("unhandledRejection", (reason) => {
+          this.error(`${name}.unhandled`, reason);
+        })
+        .on("uncaughtExceptionMonitor", (err) => {
+          this.error(`${name}.unhandled`, err);
+        });
+    });
+  }
+}
+const logger = new Logger();
+export { logger };

package/src/base/noerr.ts ADDED Viewed

@@ -0,0 +1,18 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/24.
+export function noerr<Fn extends (...args: any[]) => any, D>(
+  fn: Fn,
+  defaultValue: D,
+): (...args: Parameters<Fn>) => ReturnType<Fn> | D {
+  return (...args) => {
+    try {
+      const ret = fn(...args);
+      if (ret instanceof Promise) {
+        return ret.catch(() => defaultValue);
+      }
+      return ret;
+    } catch {
+      return defaultValue;
+    }
+  };
+}

package/src/base/parser.ts ADDED Viewed

@@ -0,0 +1,12 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/01/30.
+export function parseNumber(value: unknown): number {
+  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;
+}

package/src/base/process.ts ADDED Viewed

@@ -0,0 +1,35 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/01/30.
+import { spawn, type ChildProcess, type SpawnOptions } from "child_process";
+import { logger } from "./logging";
+export const PUP_ARGS_ENV_KEY = "__PUP_ARGS__";
+export 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;
+}
+export interface ProcessHandle {
+  process: ChildProcess;
+  wait: Promise<void>;
+}
+export function exec(cmd: string, options?: SpawnOptions): ProcessHandle {
+  const parts = cmd.split(" ").filter((s) => s.length);
+  const [command, ...args] = parts;
+  if (!command) throw new Error("empty command");
+  const proc = spawn(command, args, {
+    stdio: "inherit",
+    ...options,
+  });
+  return { process: proc, wait: logger.attach(proc, command) };
+}

package/src/base/proxy.ts ADDED Viewed

@@ -0,0 +1,33 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/09.
+import { session } from "electron";
+import { logger } from "./logging";
+const TAG = "[Proxy]";
+export function proxiedUrl(url: string) {
+  if (!url.startsWith("http")) {
+    return url;
+  }
+  // Redirect boss.hdslb.com to boss.bilibili.co
+  const match = url.match(/^https:\/\/([^-]+)-boss\.hdslb\.com(.*)$/);
+  if (match) {
+    const [, prefix, path] = match;
+    return `http://${prefix}-boss.bilibili.co${path}`;
+  }
+  return url;
+}
+export function enableProxy() {
+  // Redirect boss.hdslb.com to boss.bilibili.co
+  session.defaultSession.webRequest.onBeforeRequest((details, callback) => {
+    const url = details.url;
+    const proxied = proxiedUrl(url);
+    if (proxied === url) {
+      return callback({ cancel: false });
+    } else {
+      logger.debug(TAG, `${url} -> ${proxied}`);
+      callback({ cancel: false, redirectURL: proxied });
+    }
+  });
+}

package/src/base/record.ts ADDED Viewed

@@ -0,0 +1,228 @@
+// Created by Autokaka (qq1909698494@gmail.com) on 2026/02/09.
+import { BrowserWindow, session, type NativeImage } from "electron";
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { FixedBufferWriter } from "../rust/lib";
+import {
+  buildWrapperHTML,
+  decodeTimestamp,
+  startSync,
+  stopSync,
+} from "./frame_sync";
+import { isEmpty } from "./image";
+import { logger } from "./logging";
+import { enableProxy, proxiedUrl } from "./proxy";
+import { useRetry } from "./retry";
+const TAG = "[Record]";
+export interface RecordOptions {
+  outDir: string;
+  duration: number;
+  fps: number;
+  width: number;
+  height: number;
+  withAlphaChannel: boolean;
+  useInnerProxy: boolean;
+}
+export interface RecordResult {
+  options: RecordOptions;
+  written: number;
+  bgraPath: string;
+}
+async function loadWindow(source: string, options: RecordOptions) {
+  if (!source.startsWith("file://") && !source.match(/^https?:\/\//)) {
+    throw new Error("invalid source");
+  }
+  const { width, height, useInnerProxy } = options;
+  // Remove X-Frame-Options and CSP headers to allow iframe loading
+  // Note: Electron's onHeadersReceived uses REPLACE behavior (not append).
+  // Only the last attached listener is used, so no cleanup needed.
+  // Ref: https://www.electronjs.org/docs/latest/api/web-request
+  session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
+    const responseHeaders = { ...details.responseHeaders };
+    delete responseHeaders["x-frame-options"];
+    delete responseHeaders["X-Frame-Options"];
+    delete responseHeaders["content-security-policy"];
+    delete responseHeaders["Content-Security-Policy"];
+    callback({ cancel: false, responseHeaders });
+  });
+  let src = source;
+  if (useInnerProxy) {
+    src = proxiedUrl(source);
+    enableProxy();
+  }
+  const win = new BrowserWindow({
+    width: width,
+    height: height + 1,
+    show: false,
+    transparent: true,
+    backgroundColor: undefined,
+    webPreferences: {
+      offscreen: true,
+      backgroundThrottling: false,
+      nodeIntegration: true,
+      contextIsolation: false,
+      webSecurity: false,
+      allowRunningInsecureContent: true,
+      experimentalFeatures: true,
+    },
+  });
+  win.webContents.on("console-message", (event) => {
+    if (event.level === "error") {
+      logger.error(TAG, "console:", event.message);
+    }
+  });
+  const wrapperHTML = buildWrapperHTML(src, { width, height });
+  const dataURL = `data:text/html;charset=utf-8,${encodeURIComponent(wrapperHTML)}`;
+  let token: NodeJS.Timeout | undefined;
+  await new Promise<void>((resolve, reject) => {
+    token = setTimeout(() => {
+      reject(new Error("load window timeout"));
+    }, 20 * 1000);
+    win.webContents.once("did-finish-load", resolve);
+    win.webContents.once("did-fail-load", (_event, code, desc, url) => {
+      reject(new Error(`failed to load ${url}: [${code}] ${desc}`));
+    });
+    win.webContents.once("render-process-gone", (_event, details) => {
+      const { exitCode, reason } = details;
+      reject(new Error(`renderer crashed: ${exitCode}, ${reason}`));
+    });
+    win.loadURL(dataURL);
+  });
+  clearTimeout(token);
+  return win;
+}
+export async function record(
+  source: string,
+  options: RecordOptions,
+): Promise<void> {
+  logger.info(TAG, `progress: 0%`);
+  const { outDir, fps, width, height, duration } = options;
+  const win = await useRetry({ fn: loadWindow, maxAttempts: 2 })(
+    source,
+    options,
+  );
+  await mkdir(outDir, { recursive: true });
+  const cdp = win.webContents.debugger;
+  cdp.attach("1.3");
+  win.webContents.setFrameRate(fps);
+  if (!win.webContents.isPainting()) {
+    win.webContents.startPainting();
+  }
+  const bgraPath = join(outDir, "output.bgra");
+  const total = Math.ceil(fps * duration);
+  const frameInterval = 1000 / fps;
+  const bufferSize = width * height * 4;
+  const writer = new FixedBufferWriter(bgraPath, bufferSize, fps);
+  let written = 0;
+  let lastWrittenTime: number | undefined;
+  let progress = 0;
+  let frameError: Error | undefined;
+  let resolver: (() => void) | undefined;
+  let rejecter: ((reason?: unknown) => void) | undefined;
+  const scheduleWrite = (buffer: Buffer) => {
+    written++;
+    try {
+      writer.write(buffer);
+    } catch (error) {
+      frameError ??= error as Error;
+    }
+  };
+  const paint = (_e: unknown, _r: unknown, image: NativeImage) => {
+    if (frameError) {
+      rejecter?.(frameError);
+      return;
+    }
+    if (written >= total) {
+      resolver?.();
+      return;
+    }
+    if (isEmpty(image)) return;
+    const bitmap = image.toBitmap();
+    const currentTime = decodeTimestamp(bitmap, image.getSize());
+    if (currentTime === undefined) {
+      frameError ??= new Error(`no timestamp @ ${written}`);
+      return;
+    }
+    const bytesPerRow = width * 4;
+    const cropped = bitmap.subarray(0, height * bytesPerRow);
+    if (lastWrittenTime === undefined) {
+      scheduleWrite(cropped);
+      lastWrittenTime = currentTime;
+      return;
+    }
+    const timeSinceLastFrame = currentTime - lastWrittenTime;
+    if (timeSinceLastFrame < frameInterval * 0.8) {
+      return;
+    }
+    if (timeSinceLastFrame <= frameInterval * 1.2) {
+      scheduleWrite(cropped);
+    } else {
+      const framesToInsert = Math.round(timeSinceLastFrame / frameInterval);
+      for (let i = 0; i < framesToInsert && written < total; i++) {
+        scheduleWrite(cropped);
+      }
+    }
+    lastWrittenTime = currentTime;
+    const newProgress = Math.floor((written / total) * 100);
+    if (Math.abs(newProgress - progress) > 10) {
+      progress = newProgress;
+      logger.info(TAG, `progress: ${Math.round(progress)}%`);
+    }
+  };
+  win.webContents.on("paint", paint);
+  await startSync(cdp);
+  try {
+    await new Promise<void>((r, j) => ([resolver, rejecter] = [r, j]));
+  } finally {
+    await stopSync(cdp);
+    win.webContents.off("paint", paint);
+    await writer.close();
+  }
+  if (frameError || written === 0) {
+    throw frameError ?? new Error("no frames captured");
+  }
+  try {
+    const result: RecordResult = { options, written, bgraPath };
+    await writeFile(join(outDir, "record.json"), JSON.stringify(result));
+    logger.info(TAG, `progress: 100%, ${written} frames written`);
+  } finally {
+    win.close();
+  }
+}