@y11i-3d/chrome-recording 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuichiroh Arai
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,101 @@
+# chrome-recording
+
+[![npm version](https://img.shields.io/npm/v/@y11i-3d/chrome-recording.svg)](https://www.npmjs.com/package/@y11i-3d/chrome-recording)
+[![Build](https://github.com/y11i-3d/chrome-recording/actions/workflows/build.yml/badge.svg)](https://github.com/y11i-3d/chrome-recording/actions/workflows/build.yml)
+
+CLI for recording Windows Chrome content from WSL, using ffmpeg's ddagrab.
+
+## Prerequisites
+
+- WSL (Windows Subsystem for Linux)
+- Chrome running on Windows
+- `ffmpeg.exe` available in PATH (Windows-side)
+- `powershell.exe` available in PATH (Windows-side)
+- `wslpath` available in PATH
+
+## Installation
+
+```bash
+npm install -g @y11i-3d/chrome-recording
+```
+
+Or run directly with `npx`:
+
+```bash
+npx @y11i-3d/chrome-recording <subcommand> [options]
+```
+
+After installation, a PowerShell script (`get_chrome_info.ps1`) is automatically copied to `%LOCALAPPDATA%\y11i-3d\chrome-recording\` on Windows. This script is required by the `record` command.
+
+## Subcommands
+
+| Subcommand | Description                                             |
+| ---------- | ------------------------------------------------------- |
+| `record`   | Capture Chrome browser content as a video or screenshot |
+| `concat`   | Concatenate recorded mp4 files into one                 |
+
+## record
+
+Capture the Chrome content area using ffmpeg's ddagrab.
+
+```bash
+chrome-recording record [options]
+```
+
+By default, recording starts immediately and stops when you press Enter. The output is saved to `./recordings/<timestamp>.mp4`.
+
+| Option                               | Description                                                                             |
+| ------------------------------------ | --------------------------------------------------------------------------------------- |
+| `-s, --screenshot`                   | Take a screenshot instead of recording a video                                          |
+| `-o, --output <file>`                | Output file path                                                                        |
+| `-c, --crop <top:right:bottom:left>` | Crop in CSS shorthand order (px)                                                        |
+| `-m, --manual`                       | Wait for Enter before starting capture                                                  |
+| `-d, --duration <seconds>`           | Stop recording automatically after N seconds                                            |
+| `-q, --quality <value>`              | Quality: plain number for CRF (e.g. `23`), number+unit for bitrate (e.g. `4000k`, `4M`) |
+| `-f, --fps <fps>`                    | Frame rate                                                                              |
+| `-v, --verbose`                      | Show ffmpeg output                                                                      |
+
+### Examples
+
+```bash
+# Record until Enter is pressed
+chrome-recording record
+
+# Take a screenshot
+chrome-recording record -s
+
+# Record for 10 seconds at CRF 18
+chrome-recording record -d 10 -q 18
+
+# Record with manual start and crop
+chrome-recording record -m -c 40:0:0:0
+
+# Record to a specific file at 4 Mbps
+chrome-recording record -o output.mp4 -q 4M
+```
+
+## concat
+
+Concatenate all mp4 files in a directory into a single file (stream copy, no re-encode).
+
+```bash
+chrome-recording concat [options]
+```
+
+Files named `concat_*.mp4` are excluded. Input files are sorted alphabetically.
+
+| Option                | Description                                                  |
+| --------------------- | ------------------------------------------------------------ |
+| `-i, --input <dir>`   | Input directory (default: `./recordings`)                    |
+| `-o, --output <file>` | Output file path (default: `<input>/concat_<timestamp>.mp4`) |
+| `-v, --verbose`       | Show ffmpeg output                                           |
+
+### Examples
+
+```bash
+# Concatenate all recordings in ./recordings
+chrome-recording concat
+
+# Concatenate from a specific directory
+chrome-recording concat -i ./clips -o final.mp4
+```

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { registerConcatCommand } from "./concat.js";
+import { registerRecordCommand } from "./record.js";
+const program = new Command();
+program
+    .name("chrome-recording")
+    .description("Record Chrome browser content in WSL");
+registerRecordCommand(program);
+registerConcatCommand(program);
+program.parse();

package/dist/concat.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerConcatCommand(program: Command): void;

package/dist/concat.js

@@ -0,0 +1,31 @@
+import { execSync } from "child_process";
+import { readdirSync, unlinkSync, writeFileSync } from "fs";
+import { tmpdir } from "os";
+import { resolve } from "path";
+export function registerConcatCommand(program) {
+    program
+        .command("concat")
+        .description("Concatenate recorded mp4 files")
+        .option("-i, --input <dir>", "Input directory", resolve(process.cwd(), "recordings"))
+        .option("-o, --output <file>", "Output file path")
+        .option("-v, --verbose", "Show ffmpeg output")
+        .action((options) => {
+        const files = readdirSync(options.input)
+            .filter((f) => f.endsWith(".mp4") && !f.startsWith("concat_"))
+            .sort()
+            .map((f) => resolve(options.input, f));
+        if (files.length === 0)
+            throw new Error("No mp4 files to concatenate");
+        const outputFile = options.output ?? resolve(options.input, `concat_${Date.now()}.mp4`);
+        const concatList = resolve(tmpdir(), `concat_list_${Date.now()}.txt`);
+        writeFileSync(concatList, files.map((f) => `file '${f}'`).join("\n"));
+        const stdio = options.verbose ? "inherit" : "ignore";
+        try {
+            execSync(`ffmpeg.exe -f concat -safe 0 -i "${concatList}" -c copy -y "${outputFile}"`, { stdio: ["ignore", stdio, stdio] });
+        }
+        finally {
+            unlinkSync(concatList);
+        }
+        console.log(`Done: ${outputFile}`);
+    });
+}

package/dist/get_chrome_info.ps1

@@ -0,0 +1,62 @@
+Add-Type -AssemblyName System.Windows.Forms
+
+Add-Type -TypeDefinition @"
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+using System.Text;
+public class Win32 {
+    public delegate bool EnumWindowsProc(IntPtr hwnd, IntPtr lParam);
+    [DllImport("user32.dll")] public static extern bool GetWindowRect(IntPtr h, out RECT r);
+    [DllImport("user32.dll")] public static extern int GetClassName(IntPtr hwnd, StringBuilder buf, int maxCount);
+    [DllImport("user32.dll")] public static extern bool EnumChildWindows(IntPtr parent, EnumWindowsProc cb, IntPtr lParam);
+    public struct RECT { public int Left, Top, Right, Bottom; }
+
+    public static List<RECT> FindContentRects(IntPtr chromeHwnd) {
+        RECT mainRect;
+        GetWindowRect(chromeHwnd, out mainRect);
+        var results = new List<RECT>();
+        EnumChildWindows(chromeHwnd, (h, _) => {
+            var buf = new StringBuilder(256);
+            GetClassName(h, buf, 256);
+            if (buf.ToString() == "Chrome_RenderWidgetHostHWND") {
+                RECT r;
+                GetWindowRect(h, out r);
+                if (r.Top >= mainRect.Top && r.Top < mainRect.Bottom) {
+                    results.Add(r);
+                }
+            }
+            return true;
+        }, IntPtr.Zero);
+        return results;
+    }
+}
+"@
+
+$proc = Get-Process chrome -ErrorAction SilentlyContinue | Where-Object { $_.MainWindowTitle -ne "" } | Select-Object -First 1
+if (-not $proc) {
+    Write-Error "Chrome is not running or has no visible window."
+    exit 1
+}
+
+$rects = [Win32]::FindContentRects($proc.MainWindowHandle)
+$best = $rects | Sort-Object { $_.Left }, { $_.Top } | Select-Object -First 1
+
+if (-not $best) {
+    Write-Error "Chrome content area (Chrome_RenderWidgetHostHWND) not found."
+    exit 1
+}
+
+$x = $best.Left
+$y = $best.Top
+$w = $best.Right - $best.Left
+$h = $best.Bottom - $best.Top
+
+Write-Output "content $x $y $w $h"
+
+$i = 0
+foreach ($s in [System.Windows.Forms.Screen]::AllScreens) {
+    $b = $s.Bounds
+    Write-Output "monitor $i $($b.Left) $($b.Top) $($b.Right) $($b.Bottom)"
+    $i++
+}

package/dist/postinstall.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/postinstall.js

@@ -0,0 +1,19 @@
+#!/usr/bin/env node
+import { copyFileSync, mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+import pkg from "../package.json" with { type: "json" };
+const [scope, pkgName] = pkg.name.replace(/^@/, "").split("/");
+const scriptDir = dirname(fileURLToPath(import.meta.url));
+const ps1Src = resolve(scriptDir, "get_chrome_info.ps1");
+const localAppDataWin = execSync("powershell.exe -Command '$env:LOCALAPPDATA'")
+    .toString()
+    .trim();
+const localAppDataLinux = execSync(`wslpath -u "${localAppDataWin}"`)
+    .toString()
+    .trim();
+const destDir = resolve(localAppDataLinux, scope ?? pkg.name, pkgName ?? "");
+mkdirSync(destDir, { recursive: true });
+copyFileSync(ps1Src, resolve(destDir, "get_chrome_info.ps1"));
+console.log(`Installed get_chrome_info.ps1 to ${destDir}`);

package/dist/record.d.ts

@@ -0,0 +1,2 @@
+import type { Command } from "commander";
+export declare function registerRecordCommand(program: Command): void;

package/dist/record.js

@@ -0,0 +1,142 @@
+import { execSync, spawn } from "child_process";
+import { mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+import { createInterface } from "readline";
+export function registerRecordCommand(program) {
+    program
+        .command("record")
+        .description("Record Chrome browser content")
+        .option("-s, --screenshot", "Take a screenshot", false)
+        .option("-o, --output <file>", "Output file path")
+        .option("-c, --crop <top:right:bottom:left>", "Crop (CSS order)")
+        .option("-m, --manual", "Start recording manually")
+        .option("-d, --duration <seconds>", "Recording duration in seconds")
+        .option("-q, --quality <value>", "Quality: number for CRF, number+unit for bitrate (e.g. 23, 4000k, 4M)")
+        .option("-f, --fps <fps>", "Frame rate")
+        .option("-v, --verbose", "Show ffmpeg output")
+        .action(async (options) => {
+        const missing = ["powershell.exe", "ffmpeg.exe", "wslpath"].filter((cmd) => {
+            try {
+                execSync(`which ${cmd}`, { stdio: "ignore" });
+                return false;
+            }
+            catch {
+                return true;
+            }
+        });
+        if (missing.length > 0) {
+            throw new Error(`Command(s) not found: ${missing.join(", ")}\nWSL + Windows environment required.`);
+        }
+        const localAppDataWin = execSync("powershell.exe -Command '$env:LOCALAPPDATA'")
+            .toString()
+            .trim();
+        const ps1Win = `${localAppDataWin}\\y11i-3d\\chrome-recording\\get_chrome_info.ps1`;
+        const info = execSync(`powershell.exe -ExecutionPolicy Bypass -File "${ps1Win}"`)
+            .toString()
+            .trim()
+            .split("\n")
+            .map((l) => l.trim().replace(/\r/, ""));
+        const contentLine = info.find((l) => l.startsWith("content"));
+        if (!contentLine) {
+            throw new Error("Failed to get Chrome content area info");
+        }
+        const contentParts = contentLine.split(/\s+/).slice(1).map(Number);
+        const contentX = contentParts[0] ?? 0;
+        const contentY = contentParts[1] ?? 0;
+        const contentW = contentParts[2] ?? 0;
+        const contentH = contentParts[3] ?? 0;
+        const monitors = info
+            .filter((l) => l.startsWith("monitor"))
+            .map((l) => {
+            const parts = l.split(/\s+/).map(Number);
+            const idx = parts[1] ?? 0;
+            const left = parts[2] ?? 0;
+            const top = parts[3] ?? 0;
+            const right = parts[4] ?? 0;
+            const bottom = parts[5] ?? 0;
+            return { idx, left, top, right, bottom };
+        });
+        const monitor = monitors.find((m) => contentX >= m.left &&
+            contentX < m.right &&
+            contentY >= m.top &&
+            contentY < m.bottom);
+        if (!monitor)
+            throw new Error("Chrome content area not found");
+        const offsetX = contentX - monitor.left;
+        const offsetY = contentY - monitor.top;
+        console.log(`Capturing monitor ${monitor.idx + 1} at (${offsetX}, ${offsetY}), size ${contentW}x${contentH}`);
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        const waitEnter = (msg) => new Promise((res) => {
+            process.stdout.write(msg);
+            rl.once("line", () => res());
+        });
+        const [cropT, cropR, cropB, cropL] = options.crop
+            ? options.crop.split(":").map(Number)
+            : [0, 0, 0, 0];
+        const cropW = `floor((iw-${(cropL ?? 0) + (cropR ?? 0)})/2)*2`;
+        const cropH = `floor((ih-${(cropT ?? 0) + (cropB ?? 0)})/2)*2`;
+        const cropFilter = `crop=${cropW}:${cropH}:${cropL ?? 0}:${cropT ?? 0}`;
+        const screenshot = options.screenshot;
+        const duration = options.duration !== undefined ? Number(options.duration) : null;
+        const qualityArgs = options.quality === undefined
+            ? []
+            : /[a-zA-Z]$/.test(options.quality)
+                ? ["-b:v", options.quality]
+                : ["-crf", options.quality];
+        const ext = screenshot ? "png" : "mp4";
+        const outputLinux = options.output ??
+            resolve(process.cwd(), "recordings", `${Date.now()}.${ext}`);
+        mkdirSync(dirname(outputLinux), { recursive: true });
+        const outputWin = execSync(`wslpath -w "${outputLinux}"`)
+            .toString()
+            .trim();
+        if (options.manual) {
+            await waitEnter(`Press Enter to ${screenshot ? "capture" : "start recording"}...`);
+        }
+        const ddagrabParams = [
+            `ddagrab=output_idx=${monitor.idx}`,
+            `offset_x=${offsetX}`,
+            `offset_y=${offsetY}`,
+            `video_size=${contentW}x${contentH}`,
+            ...(options.fps !== undefined ? [`framerate=${options.fps}`] : []),
+        ];
+        const ddagrab = ddagrabParams.join(":");
+        const ffmpegArgs = screenshot
+            ? [
+                "-filter_complex",
+                `${ddagrab},hwdownload,format=bgra,${cropFilter}`,
+                "-frames:v",
+                "1",
+                "-y",
+                outputWin,
+            ]
+            : [
+                "-filter_complex",
+                `${ddagrab},hwdownload,format=bgra,${cropFilter}`,
+                ...(duration !== null ? ["-t", String(duration)] : []),
+                "-c:v",
+                "libx264",
+                ...qualityArgs,
+                "-y",
+                outputWin,
+            ];
+        const io = options.verbose ? "inherit" : "ignore";
+        const ffmpeg = spawn("ffmpeg.exe", ffmpegArgs, {
+            stdio: ["pipe", io, io],
+        });
+        ffmpeg.on("close", () => {
+            console.log(`\nDone: ${outputLinux}`);
+        });
+        if (screenshot || duration !== null) {
+            rl.close();
+        }
+        else {
+            await waitEnter("Press Enter to stop recording...");
+            rl.close();
+            ffmpeg.stdin?.end("q");
+        }
+    });
+}

package/package.json

@@ -0,0 +1,40 @@
+{
+  "name": "@y11i-3d/chrome-recording",
+  "description": "CLI for recording Windows Chrome content from WSL, using ffmpeg's ddagrab.",
+  "keywords": [
+    "recording",
+    "chrome",
+    "ffmpeg",
+    "windows",
+    "wsl"
+  ],
+  "version": "1.0.0",
+  "type": "module",
+  "files": [
+    "dist"
+  ],
+  "bin": {
+    "chrome-recording": "dist/cli.js"
+  },
+  "scripts": {
+    "build": "rm -rf dist && tsc && cp src/get_chrome_info.ps1 dist/",
+    "postinstall": "node dist/postinstall.js"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@types/node": "^25.6.0",
+    "eslint": "^10.2.0",
+    "globals": "^17.4.0",
+    "typescript": "^6.0.2",
+    "typescript-eslint": "^8.58.1"
+  },
+  "license": "MIT",
+  "author": {
+    "name": "Yuichiroh Arai",
+    "url": "https://yuichiroharai.com/"
+  },
+  "repository": "github:y11i-3d/chrome-recording",
+  "dependencies": {
+    "commander": "^14.0.3"
+  }
+}