@y11i-3d/chrome-recording 1.1.0 → 2.0.0

package/README.md

@@ -19,21 +19,23 @@ CLI for recording Windows Chrome content from WSL, using ffmpeg's ddagrab.
 npm install -g @y11i-3d/chrome-recording
 ```
 
-Or run directly with `npx`:
+Or run directly with `npx` or `bunx`:
 
 ```bash
 npx @y11i-3d/chrome-recording <subcommand> [options]
+bunx @y11i-3d/chrome-recording <subcommand> [options]
 ```
 
-After installation, a PowerShell script (`chrome.ps1`) is automatically copied to `%LOCALAPPDATA%\y11i-3d\chrome-recording\` on Windows. This script is required by the `record` and `resize` commands.
+The `record`, `screenshot` and `resize` commands need a PowerShell script (`chrome.ps1`) on the Windows side. It is copied to `%LOCALAPPDATA%\y11i-3d\chrome-recording\` every time one of them runs.
 
 ## Subcommands
 
-| Subcommand | Description                                             |
-| ---------- | ------------------------------------------------------- |
-| `record`   | Capture Chrome browser content as a video or screenshot |
-| `resize`   | Set the Chrome viewport size                            |
-| `concat`   | Concatenate recorded mp4 files into one                 |
+| Subcommand   | Description                                     |
+| ------------ | ----------------------------------------------- |
+| `record`     | Capture Chrome browser content as a video       |
+| `screenshot` | Capture Chrome browser content as a still image |
+| `resize`     | Set the Chrome viewport size                    |
+| `concat`     | Concatenate recorded mp4 files into one         |
 
 ## record
 
@@ -43,11 +45,11 @@ Capture the Chrome content area using ffmpeg's ddagrab.
 chrome-recording record [options]
 ```
 
-By default, recording starts immediately and stops when you press Enter. The output is saved to `./recordings/<timestamp>.mp4`.
+Recording starts immediately and stops when you press Enter, unless `--manual` or `--duration` is given. The output is saved to `./recordings/<timestamp>.mp4`.
 
 | Option                               | Description                                                                             |
 | ------------------------------------ | --------------------------------------------------------------------------------------- |
-| `-s, --screenshot`                   | Take a screenshot instead of recording a video                                          |
+| `-s, --size <width>x<height>`        | Size of the captured region (see below)                                                 |
 | `-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                                                  |
@@ -58,14 +60,18 @@ By default, recording starts immediately and stops when you press Enter. The out
 | `-t, --title <text>`                 | Select a window whose page title contains this text                                     |
 | `-v, --verbose`                      | Show ffmpeg output                                                                      |
 
+`--size` captures a region of that size from the top-left corner of the Chrome
+content area, instead of the whole area. `--crop` is ignored when `--size` is
+given.
+
 ### Examples
 
 ```bash
 # Record until Enter is pressed
 chrome-recording record
 
-# Take a screenshot
-chrome-recording record -s
+# Record a 1920x1080 region, ignoring the padding kept by `resize`
+chrome-recording record -s 1920x1080
 
 # Record for 10 seconds at CRF 18
 chrome-recording record -d 10 -q 18
@@ -77,10 +83,44 @@ chrome-recording record -m -c 40:0:0:0
 chrome-recording record -o output.mp4 -q 4M
 ```
 
+## screenshot
+
+Capture a single frame of the Chrome content area as a PNG.
+
+```bash
+chrome-recording screenshot [options]
+```
+
+The capture happens immediately, unless `--manual` is given. The output is saved
+to `./recordings/<timestamp>.png`.
+
+| Option                               | Description                                         |
+| ------------------------------------ | --------------------------------------------------- |
+| `-s, --size <width>x<height>`        | Size of the captured region (same as `record`)      |
+| `-o, --output <file>`                | Output file path                                    |
+| `-c, --crop <top:right:bottom:left>` | Crop in CSS shorthand order (px)                    |
+| `-m, --manual`                       | Wait for Enter before capturing                     |
+| `-n, --no-pointer`                   | Hide the mouse pointer                              |
+| `-t, --title <text>`                 | Select a window whose page title contains this text |
+| `-v, --verbose`                      | Show ffmpeg output                                  |
+
+### Examples
+
+```bash
+# Capture the Chrome content area
+chrome-recording screenshot
+
+# Capture a 1920x1080 region without the mouse pointer
+chrome-recording screenshot -s 1920x1080 -n
+
+# Capture after pressing Enter, to a specific file
+chrome-recording screenshot -m -o shot.png
+```
+
 ## resize
 
 Set the viewport size through the Chrome DevTools Protocol. Chrome asks you to
-approve the connection each time this command runs.
+approve the connection.
 
 ```bash
 chrome-recording resize <width>x<height> [options]
@@ -94,10 +134,12 @@ Padding is added to the right and the bottom.
 | Option                           | Description                                        |
 | -------------------------------- | -------------------------------------------------- |
 | `-p, --padding <width>x<height>` | Padding kept outside the viewport (default: `0x0`) |
+| `-n, --no-scrollbar`             | Hide the scrollbars                                |
 | `-t, --title <text>`             | Select a page whose title contains this text       |
 
-The setting survives after the command exits, but it is lost when the page is
-reloaded.
+With `--padding` or `--no-scrollbar`, the command waits instead of exiting.
+Press Enter to release the viewport. The setting survives a page reload while it
+waits.
 
 ### Examples
 
@@ -106,8 +148,12 @@ reloaded.
 chrome-recording resize 1920x1080
 
 # Keep 4px below the viewport so the rounded corners are not captured
+# (waits until Enter is pressed)
 chrome-recording resize 1920x1080 -p 0x4
 
+# Hide the scrollbars (waits until Enter is pressed)
+chrome-recording resize 1920x1080 -n
+
 # Target a specific page
 chrome-recording resize 1280x720 -t "Example"
 ```

package/dist/capture.d.ts

@@ -0,0 +1,14 @@
+export interface CaptureOptions {
+    size?: string;
+    output?: string;
+    crop?: string;
+    manual: boolean;
+    pointer: boolean;
+    title?: string;
+    verbose: boolean;
+    duration?: string;
+    quality?: string;
+    fps?: string;
+}
+export type CaptureMode = "screenshot" | "video";
+export declare function runCapture(mode: CaptureMode, options: CaptureOptions): Promise<void>;

package/dist/capture.js

@@ -0,0 +1,143 @@
+import { execSync, spawn } from "child_process";
+import { mkdirSync } from "fs";
+import { dirname, resolve } from "path";
+import { createInterface } from "readline";
+import { parseSize, runChromeScript } from "./chrome.js";
+function requireCommands() {
+    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.`);
+    }
+}
+// The content rect is the render widget, which may be larger than the page
+// viewport when `resize --padding` is in effect.
+function locateContent(title) {
+    const infoArgs = ["info"];
+    if (title)
+        infoArgs.push("-Title", title);
+    const info = runChromeScript(infoArgs);
+    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");
+    return {
+        monitorIdx: monitor.idx,
+        offsetX: contentX - monitor.left,
+        offsetY: contentY - monitor.top,
+        width: contentW,
+        height: contentH,
+    };
+}
+// The crop filter also rounds the dimensions down to even numbers for H.264, so
+// it stays in the chain even when nothing is cropped away.
+function buildCropFilter(crop) {
+    const [top, right, bottom, left] = crop
+        ? crop.split(":").map(Number)
+        : [0, 0, 0, 0];
+    const width = `floor((iw-${(left ?? 0) + (right ?? 0)})/2)*2`;
+    const height = `floor((ih-${(top ?? 0) + (bottom ?? 0)})/2)*2`;
+    return `crop=${width}:${height}:${left ?? 0}:${top ?? 0}`;
+}
+export async function runCapture(mode, options) {
+    requireCommands();
+    const region = locateContent(options.title);
+    // `--size` picks the captured region itself rather than cropping it down, so
+    // any `--crop` becomes meaningless and is dropped.
+    const size = options.size ? parseSize(options.size, "size") : null;
+    const captureW = size?.width ?? region.width;
+    const captureH = size?.height ?? region.height;
+    const cropFilter = buildCropFilter(size ? undefined : options.crop);
+    console.log(`Capturing monitor ${region.monitorIdx + 1} at (${region.offsetX}, ${region.offsetY}), size ${captureW}x${captureH}`);
+    const rl = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    const waitEnter = (msg) => new Promise((res) => {
+        process.stdout.write(msg);
+        rl.once("line", () => res());
+    });
+    const screenshot = mode === "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=${region.monitorIdx}`,
+        `offset_x=${region.offsetX}`,
+        `offset_y=${region.offsetY}`,
+        `video_size=${captureW}x${captureH}`,
+        ...(options.fps !== undefined ? [`framerate=${options.fps}`] : []),
+        ...(options.pointer ? [] : ["draw_mouse=0"]),
+    ];
+    const ddagrab = ddagrabParams.join(":");
+    const filter = `${ddagrab},hwdownload,format=bgra,${cropFilter}`;
+    const ffmpegArgs = screenshot
+        ? ["-filter_complex", filter, "-frames:v", "1", "-y", outputWin]
+        : [
+            "-filter_complex",
+            filter,
+            ...(duration !== null ? ["-t", String(duration)] : []),
+            "-c:v",
+            "libx264",
+            "-pix_fmt",
+            "yuv420p",
+            ...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/dist/chrome.d.ts

@@ -1,4 +1,5 @@
 export declare function runChromeScript(args: string[]): string[];
+export declare function runChromeScriptInteractive(args: string[]): Promise<void>;
 export declare function parseSize(value: string, label: string): {
     width: number;
     height: number;

package/dist/chrome.js

@@ -1,14 +1,30 @@
-import { execSync } from "child_process";
+import { execSync, spawn } from "child_process";
+import { copyFileSync, mkdirSync, rmSync } from "fs";
+import { dirname, resolve } from "path";
+import { createInterface } from "readline";
+import { fileURLToPath } from "url";
+import pkg from "../package.json" with { type: "json" };
 const SCRIPT_NAME = "chrome.ps1";
-function scriptPathWin() {
+const LEGACY_SCRIPT_NAME = "get_chrome_info.ps1";
+function deployScript() {
     const localAppDataWin = execSync("powershell.exe -Command '$env:LOCALAPPDATA'")
         .toString()
         .trim();
-    return `${localAppDataWin}\\y11i-3d\\chrome-recording\\${SCRIPT_NAME}`;
+    const localAppDataLinux = execSync(`wslpath -u "${localAppDataWin}"`)
+        .toString()
+        .trim();
+    const segments = pkg.name.replace(/^@/, "").split("/");
+    const destDirLinux = resolve(localAppDataLinux, ...segments);
+    mkdirSync(destDirLinux, { recursive: true });
+    const srcDir = dirname(fileURLToPath(import.meta.url));
+    copyFileSync(resolve(srcDir, SCRIPT_NAME), resolve(destDirLinux, SCRIPT_NAME));
+    rmSync(resolve(destDirLinux, LEGACY_SCRIPT_NAME), { force: true });
+    return [localAppDataWin, ...segments, SCRIPT_NAME].join("\\");
 }
 export function runChromeScript(args) {
+    const scriptPathWin = deployScript();
     const quoted = args.map((arg) => `"${arg.replace(/"/g, '""')}"`).join(" ");
-    const command = `powershell.exe -ExecutionPolicy Bypass -File "${scriptPathWin()}" ${quoted}`;
+    const command = `powershell.exe -ExecutionPolicy Bypass -File "${scriptPathWin}" ${quoted}`;
     try {
         return execSync(command, { stdio: ["ignore", "pipe", "pipe"] })
             .toString()
@@ -24,6 +40,70 @@ export function runChromeScript(args) {
         });
     }
 }
+// Keeps the script's stdin open so it can hold the CDP session alive, and
+// releases it by writing a newline. Output is streamed as it arrives.
+export function runChromeScriptInteractive(args) {
+    const scriptPathWin = deployScript();
+    return new Promise((resolvePromise, rejectPromise) => {
+        const child = spawn("powershell.exe", ["-ExecutionPolicy", "Bypass", "-File", scriptPathWin, ...args], { stdio: ["pipe", "pipe", "pipe"] });
+        let pending = "";
+        const emit = (line) => {
+            const text = line.trim().replace(/\r/, "");
+            if (text.length > 0)
+                console.log(text);
+        };
+        child.stdout.setEncoding("utf8");
+        child.stdout.on("data", (chunk) => {
+            pending += chunk;
+            const lines = pending.split("\n");
+            pending = lines.pop() ?? "";
+            for (const line of lines)
+                emit(line);
+        });
+        let stderrText = "";
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            stderrText += chunk;
+        });
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout,
+        });
+        let released = false;
+        const release = () => {
+            if (released)
+                return;
+            released = true;
+            child.stdin.end("\n");
+        };
+        rl.once("line", release);
+        rl.once("close", release);
+        // readline puts a TTY stdin in raw mode, so Ctrl+C never reaches the child.
+        let interrupted = false;
+        rl.on("SIGINT", () => {
+            interrupted = true;
+            child.kill();
+        });
+        child.on("error", (error) => {
+            released = true;
+            rl.close();
+            rejectPromise(error);
+        });
+        child.on("close", (code) => {
+            emit(pending);
+            released = true;
+            rl.close();
+            if (code === 0 || interrupted) {
+                resolvePromise();
+                return;
+            }
+            const message = stderrText.trim();
+            rejectPromise(new Error(message.length > 0
+                ? message
+                : `chrome.ps1 exited with code ${String(code)}.`));
+        });
+    });
+}
 export function parseSize(value, label) {
     const match = /^(\d+)x(\d+)$/.exec(value);
     if (!match) {

package/dist/chrome.ps1

@@ -4,7 +4,9 @@ param(
     [int]$ViewportWidth = 0,
     [int]$ViewportHeight = 0,
     [int]$PaddingWidth = 0,
-    [int]$PaddingHeight = 0
+    [int]$PaddingHeight = 0,
+    [switch]$NoScrollbar,
+    [switch]$Hold
 )
 
 $ErrorActionPreference = "Stop"
@@ -194,12 +196,17 @@ try {
 
     $sessionId = (Invoke-Cdp "Target.attachToTarget" @{ targetId = $target.targetId; flatten = $true } $null).result.sessionId
     Invoke-Cdp "Emulation.setDeviceMetricsOverride" @{
-        width             = $ViewportWidth
-        height            = $ViewportHeight
-        deviceScaleFactor = 1
-        mobile            = $false
+        width              = $ViewportWidth
+        height             = $ViewportHeight
+        deviceScaleFactor  = 1
+        mobile             = $false
+        dontSetVisibleSize = $true
     } $sessionId | Out-Null
 
+    if ($NoScrollbar) {
+        Invoke-Cdp "Emulation.setScrollbarsHidden" @{ hidden = $true } $sessionId | Out-Null
+    }
+
     Write-Output "viewport $ViewportWidth $ViewportHeight"
     Write-Output "content $contentWidth $contentHeight"
     Write-Output "title $($target.title)"
@@ -209,4 +216,9 @@ catch {
     $ws.Dispose()
     exit 1
 }
+
+if ($Hold) {
+    Write-Output "Holding the viewport. Press Enter to release."
+    [Console]::ReadLine() | Out-Null
+}
 $ws.Dispose()

package/dist/cli.js

@@ -3,6 +3,7 @@ import { Command } from "commander";
 import { registerConcatCommand } from "./concat.js";
 import { registerRecordCommand } from "./record.js";
 import { registerResizeCommand } from "./resize.js";
+import { registerScreenshotCommand } from "./screenshot.js";
 function reportAndExit(error) {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
@@ -14,6 +15,7 @@ program
     .name("chrome-recording")
     .description("Record Chrome browser content in WSL");
 registerRecordCommand(program);
+registerScreenshotCommand(program);
 registerResizeCommand(program);
 registerConcatCommand(program);
 program.parse();

package/dist/record.js

@@ -1,13 +1,9 @@
-import { execSync, spawn } from "child_process";
-import { mkdirSync } from "fs";
-import { dirname, resolve } from "path";
-import { createInterface } from "readline";
-import { runChromeScript } from "./chrome.js";
+import { runCapture } from "./capture.js";
 export function registerRecordCommand(program) {
     program
         .command("record")
         .description("Record Chrome browser content")
-        .option("-s, --screenshot", "Take a screenshot", false)
+        .option("-s, --size <width>x<height>", "Capture size")
         .option("-o, --output <file>", "Output file path")
         .option("-c, --crop <top:right:bottom:left>", "Crop (CSS order)")
         .option("-m, --manual", "Start recording manually")
@@ -18,126 +14,6 @@ export function registerRecordCommand(program) {
         .option("-t, --title <text>", "Select a window whose page title contains this text")
         .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 infoArgs = ["info"];
-        if (options.title)
-            infoArgs.push("-Title", options.title);
-        const info = runChromeScript(infoArgs);
-        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}`] : []),
-            ...(options.pointer ? [] : ["draw_mouse=0"]),
-        ];
-        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",
-                "-pix_fmt",
-                "yuv420p",
-                ...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");
-        }
+        await runCapture("video", options);
     });
 }

package/dist/resize.js

@@ -1,12 +1,13 @@
-import { parseSize, runChromeScript } from "./chrome.js";
+import { parseSize, runChromeScript, runChromeScriptInteractive, } from "./chrome.js";
 export function registerResizeCommand(program) {
     program
         .command("resize")
         .description("Resize the Chrome viewport")
         .argument("<size>", "Viewport size as <width>x<height>")
         .option("-p, --padding <width>x<height>", "Padding kept outside the viewport (right and bottom)", "0x0")
+        .option("-n, --no-scrollbar", "Hide the scrollbars")
         .option("-t, --title <text>", "Select a page whose title contains this text")
-        .action((size, options) => {
+        .action(async (size, options) => {
         const viewport = parseSize(size, "size");
         const padding = parseSize(options.padding, "padding");
         const args = [
@@ -20,10 +21,19 @@ export function registerResizeCommand(program) {
             "-PaddingHeight",
             String(padding.height),
         ];
+        if (!options.scrollbar)
+            args.push("-NoScrollbar");
         if (options.title)
             args.push("-Title", options.title);
-        for (const line of runChromeScript(args)) {
-            console.log(line);
+        // Chrome drops the device metrics override the moment the CDP session
+        // closes, so padding and hidden scrollbars need the session held open.
+        const hold = padding.width > 0 || padding.height > 0 || !options.scrollbar;
+        if (!hold) {
+            for (const line of runChromeScript(args))
+                console.log(line);
+            return;
         }
+        args.push("-Hold");
+        await runChromeScriptInteractive(args);
     });
 }

package/dist/screenshot.d.ts

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

package/dist/screenshot.js

@@ -0,0 +1,16 @@
+import { runCapture } from "./capture.js";
+export function registerScreenshotCommand(program) {
+    program
+        .command("screenshot")
+        .description("Capture Chrome browser content as a still image")
+        .option("-s, --size <width>x<height>", "Capture size")
+        .option("-o, --output <file>", "Output file path")
+        .option("-c, --crop <top:right:bottom:left>", "Crop (CSS order)")
+        .option("-m, --manual", "Capture manually")
+        .option("-n, --no-pointer", "Hide the mouse pointer")
+        .option("-t, --title <text>", "Select a window whose page title contains this text")
+        .option("-v, --verbose", "Show ffmpeg output")
+        .action(async (options) => {
+        await runCapture("screenshot", options);
+    });
+}

package/package.json

@@ -8,7 +8,7 @@
     "windows",
     "wsl"
   ],
-  "version": "1.1.0",
+  "version": "2.0.0",
   "type": "module",
   "files": [
     "dist"
@@ -17,14 +17,15 @@
     "chrome-recording": "dist/cli.js"
   },
   "scripts": {
-    "build": "rm -rf dist && tsc && cp src/chrome.ps1 dist/",
-    "postinstall": "node dist/postinstall.js"
+    "build": "rm -rf dist && tsc && cp src/chrome.ps1 dist/"
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@types/node": "^25.6.0",
     "eslint": "^10.2.0",
     "globals": "^17.4.0",
+    "prettier": "^3.9.6",
+    "prettier-plugin-organize-imports": "^4.3.0",
     "typescript": "^6.0.2",
     "typescript-eslint": "^8.58.1"
   },

package/dist/postinstall.d.ts

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

package/dist/postinstall.js

@@ -1,19 +0,0 @@
-#!/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, "chrome.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, "chrome.ps1"));
-console.log(`Installed chrome.ps1 to ${destDir}`);