pupeteer-screen-recorder 0.0.1-security → 3.0.6

package/build/main/lib/PuppeteerScreenRecorder.js

@@ -0,0 +1,149 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PuppeteerScreenRecorder = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = require("path");
+const pageVideoStreamCollector_1 = require("./pageVideoStreamCollector");
+const pageVideoStreamWriter_1 = __importDefault(require("./pageVideoStreamWriter"));
+/**
+ * @ignore
+ * @default
+ * @description This will be option passed to the puppeteer screen recorder
+ */
+const defaultPuppeteerScreenRecorderOptions = {
+    followNewTab: true,
+    fps: 15,
+    quality: 100,
+    ffmpeg_Path: null,
+    videoFrame: {
+        width: null,
+        height: null,
+    },
+    aspectRatio: '4:3',
+};
+/**
+ * PuppeteerScreenRecorder class is responsible for managing the video
+ *
+ * ```typescript
+ * const screenRecorderOptions = {
+ *  followNewTab: true,
+ *  fps: 15,
+ * }
+ * const savePath = "./test/demo.mp4";
+ * const screenRecorder = new PuppeteerScreenRecorder(page, screenRecorderOptions);
+ * await screenRecorder.start(savePath);
+ *  // some puppeteer action or test
+ * await screenRecorder.stop()
+ * ```
+ */
+class PuppeteerScreenRecorder {
+    constructor(page, options = {}) {
+        this.isScreenCaptureEnded = null;
+        this.options = Object.assign({}, defaultPuppeteerScreenRecorderOptions, options);
+        this.streamReader = new pageVideoStreamCollector_1.pageVideoStreamCollector(page, this.options);
+        this.page = page;
+    }
+    /**
+     * @ignore
+     */
+    setupListeners() {
+        this.page.once('close', async () => await this.stop());
+        this.streamReader.on('pageScreenFrame', (pageScreenFrame) => {
+            this.streamWriter.insert(pageScreenFrame);
+        });
+        this.streamWriter.once('videoStreamWriterError', () => this.stop());
+    }
+    /**
+     * @ignore
+     */
+    async ensureDirectoryExist(dirPath) {
+        return new Promise((resolve, reject) => {
+            try {
+                fs_1.default.mkdirSync(dirPath, { recursive: true });
+                return resolve(dirPath);
+            }
+            catch (error) {
+                reject(error);
+            }
+        });
+    }
+    /**
+     * @ignore
+     * @private
+     * @method startStreamReader
+     * @description start listening for video stream from the page.
+     * @returns PuppeteerScreenRecorder
+     */
+    async startStreamReader() {
+        this.setupListeners();
+        await this.streamReader.start();
+        return this;
+    }
+    /**
+     * @public
+     * @method getRecordDuration
+     * @description return the total duration of the video recorded,
+     *  1. if this method is called before calling the stop method, it would be return the time till it has recorded.
+     *  2. if this method is called after stop method, it would give the total time for recording
+     * @returns total duration of video
+     */
+    getRecordDuration() {
+        if (!this.streamWriter) {
+            return '00:00:00:00';
+        }
+        return this.streamWriter.duration;
+    }
+    /**
+     *
+     * @public
+     * @method start
+     * @param savePath accepts a path string to store the video
+     * @description Start the video capturing session
+     * @returns PuppeteerScreenRecorder
+     * @example
+     * ```
+     *  const savePath = './test/demo.mp4'; //.mp4 is required
+     *  await recorder.start(savePath);
+     * ```
+     */
+    async start(savePath) {
+        await this.ensureDirectoryExist((0, path_1.dirname)(savePath));
+        this.streamWriter = new pageVideoStreamWriter_1.default(savePath, this.options);
+        return this.startStreamReader();
+    }
+    /**
+     *
+     * @public
+     * @method startStream
+     * @description Start the video capturing session in a stream
+     * @returns {PuppeteerScreenRecorder}
+     * @example
+     * ```
+     *  const stream = new PassThrough();
+     *  await recorder.startStream(stream);
+     * ```
+     */
+    async startStream(stream) {
+        this.streamWriter = new pageVideoStreamWriter_1.default(stream, this.options);
+        return this.startStreamReader();
+    }
+    /**
+     * @public
+     * @method stop
+     * @description stop the video capturing session
+     * @returns indicate whether stop is completed correct or not, if true without any error else false.
+     */
+    async stop() {
+        if (this.isScreenCaptureEnded !== null) {
+            return this.isScreenCaptureEnded;
+        }
+        await this.streamReader.stop();
+        this.isScreenCaptureEnded = await this.streamWriter.stop();
+        return this.isScreenCaptureEnded;
+    }
+}
+exports.PuppeteerScreenRecorder = PuppeteerScreenRecorder;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/pageVideoStreamCollector.d.ts

@@ -0,0 +1,28 @@
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Page } from 'puppeteer';
+import { PuppeteerScreenRecorderOptions } from './pageVideoStreamTypes';
+/**
+ * @ignore
+ */
+export declare class pageVideoStreamCollector extends EventEmitter {
+    private page;
+    private options;
+    private sessionsStack;
+    private isStreamingEnded;
+    private isFrameAckReceived;
+    constructor(page: Page, options: PuppeteerScreenRecorderOptions);
+    private get shouldFollowPopupWindow();
+    private getPageSession;
+    private getCurrentSession;
+    private addListenerOnTabOpens;
+    private removeListenerOnTabClose;
+    private registerTabListener;
+    private startScreenCast;
+    private stopScreenCast;
+    private startSession;
+    private handleScreenCastFrame;
+    private endSession;
+    start(): Promise<void>;
+    stop(): Promise<boolean>;
+}

package/build/main/lib/pageVideoStreamCollector.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pageVideoStreamCollector = void 0;
+const events_1 = require("events");
+/**
+ * @ignore
+ */
+class pageVideoStreamCollector extends events_1.EventEmitter {
+    constructor(page, options) {
+        super();
+        this.sessionsStack = [];
+        this.isStreamingEnded = false;
+        this.page = page;
+        this.options = options;
+    }
+    get shouldFollowPopupWindow() {
+        return this.options.followNewTab;
+    }
+    async getPageSession(page) {
+        try {
+            const context = page.target();
+            return await context.createCDPSession();
+        }
+        catch (error) {
+            console.log('Failed to create CDP Session', error);
+            return null;
+        }
+    }
+    getCurrentSession() {
+        return this.sessionsStack[this.sessionsStack.length - 1];
+    }
+    addListenerOnTabOpens(page) {
+        page.on('popup', (newPage) => this.registerTabListener(newPage));
+    }
+    removeListenerOnTabClose(page) {
+        page.off('popup', (newPage) => this.registerTabListener(newPage));
+    }
+    async registerTabListener(newPage) {
+        await this.startSession(newPage);
+        newPage.once('close', async () => await this.endSession());
+    }
+    async startScreenCast(shouldDeleteSessionOnFailure = false) {
+        const currentSession = this.getCurrentSession();
+        const quality = Number.isNaN(this.options.quality)
+            ? 100
+            : Math.max(Math.min(this.options.quality, 100), 0);
+        try {
+            await currentSession.send('Animation.setPlaybackRate', {
+                playbackRate: 1,
+            });
+            await currentSession.send('Page.startScreencast', {
+                everyNthFrame: 1,
+                format: this.options.format || 'jpeg',
+                quality: quality,
+            });
+        }
+        catch (e) {
+            if (shouldDeleteSessionOnFailure) {
+                this.endSession();
+            }
+        }
+    }
+    async stopScreenCast() {
+        const currentSession = this.getCurrentSession();
+        if (!currentSession) {
+            return;
+        }
+        await currentSession.send('Page.stopScreencast');
+    }
+    async startSession(page) {
+        const pageSession = await this.getPageSession(page);
+        if (!pageSession) {
+            return;
+        }
+        await this.stopScreenCast();
+        this.sessionsStack.push(pageSession);
+        this.handleScreenCastFrame(pageSession);
+        await this.startScreenCast(true);
+    }
+    async handleScreenCastFrame(session) {
+        this.isFrameAckReceived = new Promise((resolve) => {
+            session.on('Page.screencastFrame', async ({ metadata, data, sessionId }) => {
+                if (!metadata.timestamp || this.isStreamingEnded) {
+                    return resolve();
+                }
+                const ackPromise = session.send('Page.screencastFrameAck', {
+                    sessionId: sessionId,
+                });
+                this.emit('pageScreenFrame', {
+                    blob: Buffer.from(data, 'base64'),
+                    timestamp: metadata.timestamp,
+                });
+                try {
+                    await ackPromise;
+                }
+                catch (error) {
+                    console.error('Error in sending Acknowledgment for PageScreenCast', error.message);
+                }
+            });
+        });
+    }
+    async endSession() {
+        this.sessionsStack.pop();
+        await this.startScreenCast();
+    }
+    async start() {
+        await this.startSession(this.page);
+        this.page.once('close', async () => await this.endSession());
+        if (this.shouldFollowPopupWindow) {
+            this.addListenerOnTabOpens(this.page);
+        }
+    }
+    async stop() {
+        if (this.isStreamingEnded) {
+            return this.isStreamingEnded;
+        }
+        if (this.shouldFollowPopupWindow) {
+            this.removeListenerOnTabClose(this.page);
+        }
+        await Promise.race([
+            this.isFrameAckReceived,
+            new Promise((resolve) => setTimeout(resolve, 1000)),
+        ]);
+        this.isStreamingEnded = true;
+        try {
+            for (const currentSession of this.sessionsStack) {
+                await currentSession.detach();
+            }
+        }
+        catch (e) {
+            console.warn('Error detaching session', e.message);
+        }
+        return true;
+    }
+}
+exports.pageVideoStreamCollector = pageVideoStreamCollector;
+//# sourceMappingURL=data:application/json;base64,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

package/build/main/lib/pageVideoStreamTypes.d.ts

@@ -0,0 +1,147 @@
+/// <reference types="node" />
+/**
+ * @ignore
+ * @enum VIDEO_WRITE_STATUS
+ */
+export declare enum VIDEO_WRITE_STATUS {
+    'NOT_STARTED' = 0,
+    'IN_PROGRESS' = 1,
+    'COMPLETED' = 2,
+    'ERROR' = 3
+}
+/**
+ * @ignore
+ * @type PageScreen
+ */
+export type pageScreenFrame = {
+    readonly blob: Buffer;
+    readonly timestamp: number;
+    readonly duration?: number;
+};
+export type PuppeteerScreenRecorderOptions = {
+    /**
+     * @name followNewTab
+     * @member PuppeteerScreenRecorderOptions
+     * @description Boolean value which is indicate whether to follow the tab or not. Default value is true.
+     * @default true
+     * */
+    readonly followNewTab: boolean;
+    /**
+     * @name fps
+     * @member PuppeteerScreenRecorderOptions
+     * @description Numeric value which denotes no.of Frames per second in which the video should be recorded. default value is 25.
+     * @default 25
+     */
+    readonly fps?: number;
+    /**
+     * @name quality
+     * @member PuppeteerScreenRecorderOptions
+     * @description Numeric value which denotes no.of quality of individual frame captured by chrome. Value accepted 0 - 100.  100 denotes the highest quality and 0 denotes the lowest quality
+     * @default 100
+     */
+    readonly quality?: number;
+    /**
+     * @name format
+     * @member PuppeteerScreenRecorderOptions
+     * @description specify the format for recording the video
+     * @default jpeg
+     */
+    readonly format?: 'jpeg' | 'png';
+    /**
+     * @name ffmpeg_Path
+     * @member PuppeteerScreenRecorderOptions
+     * @description String value pointing to the installation of FFMPEG. Default is null (Automatically install the FFMPEG and use it).
+     * @default null
+     */
+    readonly ffmpeg_Path?: string | null;
+    /**
+     * @name videoFrame
+     * @member PuppeteerScreenRecorderOptions
+     * @description An object which specifies the width and height of the output video frame.
+     * Note: VideoFrame option is not applicable for capturing the video.
+     */
+    readonly videoFrame?: {
+        width: number | null;
+        height: number | null;
+    };
+    /**
+     * @name aspectRatio
+     * @member PuppeteerScreenRecorderOptions
+     * @description Specify the aspect ratio of the video. Default value is 4:3.
+     * @default 4:3
+     */
+    readonly aspectRatio?: '3:2' | '4:3' | '16:9';
+    /**
+     * @name videoCodec
+     * @member PuppeteerScreenRecorderOptions
+     * @description Specify the codec used by FFMPEG when creating the final video file. The default value is libx264.
+     */
+    readonly videoCodec?: string;
+    /**
+     * @name videoBitrate
+     * @member PuppeteerScreenRecorderOptions
+     * @description Specify the target bitrate of the final video file in bits/s. The default value is 1000.
+     */
+    readonly videoBitrate?: number;
+    /**
+     * @name videoCrf
+     * @member PuppeteerScreenRecorderOptions
+     * @description Specify the crf of the final video file. The default value is 23.
+     */
+    readonly videoCrf?: number;
+    /**
+     * @name videoPreset
+     * @member PuppeteerScreenRecorderOptions
+     * @description Specify the preset to use when encoding the video file. The default value is 'ultrafast'.
+     */
+    readonly videoPreset?: string;
+    /**
+     * @name videoPixelFormat
+     * @member PuppeteerScreenRecorderOptions
+     * @description Specify the pixel format to use when encoding the video file. The default value is 'yuv420p'.
+     */
+    readonly videoPixelFormat?: string;
+    /**
+     * @name videOutputOptions
+     * @member PuppeteerScreenRecorderOptions
+     * @description Allows you to pass additional options to the ffmpeg encoder -
+     * @example you might want to pass "-movflags +faststart"
+     */
+    readonly videOutputOptions?: string[];
+    /**
+     * @name autopad
+     * @member PuppeteerScreenRecorderOptions
+     * @description Specify whether autopad option is used and its color. Default to autopad deactivation mode.
+     */
+    readonly autopad?: {
+        color?: string;
+    };
+    /**
+     * @name recordDurationLimit
+     * @member PuppeteerScreenRecorderOptions
+     * @description  Numerical value specify duration (in seconds) to record the video. By default video is recorded till stop method is invoked`. (Note: It's mandatory to invoke Stop() method even if this value is set)
+     */
+    readonly recordDurationLimit?: number;
+    /**
+     * @name metadata
+     * @member PuppeteerScreenRecorderOptions
+     * @description Specify metadata information as key value pairs.
+     */
+    readonly metadata?: string[];
+};
+/** @ignore */
+export type VideoOptions = Omit<PuppeteerScreenRecorderOptions, 'followNewTab'>;
+/**
+ * @description supported video format for recording.
+ * @example
+ *  recording.start('./video.mp4');
+ *  recording.start('./video.mov');
+ *  recording.start('./video.webm');
+ *  recording.start('./video.avi');
+ */
+export declare enum SupportedFileFormats {
+    MP4 = "mp4",
+    MOV = "mov",
+    AVI = "avi",
+    WEBM = "webm"
+}

package/build/main/lib/pageVideoStreamTypes.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SupportedFileFormats = exports.VIDEO_WRITE_STATUS = void 0;
+/**
+ * @ignore
+ * @enum VIDEO_WRITE_STATUS
+ */
+var VIDEO_WRITE_STATUS;
+(function (VIDEO_WRITE_STATUS) {
+    VIDEO_WRITE_STATUS[VIDEO_WRITE_STATUS["NOT_STARTED"] = 0] = "NOT_STARTED";
+    VIDEO_WRITE_STATUS[VIDEO_WRITE_STATUS["IN_PROGRESS"] = 1] = "IN_PROGRESS";
+    VIDEO_WRITE_STATUS[VIDEO_WRITE_STATUS["COMPLETED"] = 2] = "COMPLETED";
+    VIDEO_WRITE_STATUS[VIDEO_WRITE_STATUS["ERROR"] = 3] = "ERROR";
+})(VIDEO_WRITE_STATUS || (exports.VIDEO_WRITE_STATUS = VIDEO_WRITE_STATUS = {}));
+/**
+ * @description supported video format for recording.
+ * @example
+ *  recording.start('./video.mp4');
+ *  recording.start('./video.mov');
+ *  recording.start('./video.webm');
+ *  recording.start('./video.avi');
+ */
+var SupportedFileFormats;
+(function (SupportedFileFormats) {
+    SupportedFileFormats["MP4"] = "mp4";
+    SupportedFileFormats["MOV"] = "mov";
+    SupportedFileFormats["AVI"] = "avi";
+    SupportedFileFormats["WEBM"] = "webm";
+})(SupportedFileFormats || (exports.SupportedFileFormats = SupportedFileFormats = {}));
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicGFnZVZpZGVvU3RyZWFtVHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbGliL3BhZ2VWaWRlb1N0cmVhbVR5cGVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7OztBQUFBOzs7R0FHRztBQUNILElBQVksa0JBS1g7QUFMRCxXQUFZLGtCQUFrQjtJQUM1Qix5RUFBYSxDQUFBO0lBQ2IseUVBQWEsQ0FBQTtJQUNiLHFFQUFXLENBQUE7SUFDWCw2REFBTyxDQUFBO0FBQ1QsQ0FBQyxFQUxXLGtCQUFrQixrQ0FBbEIsa0JBQWtCLFFBSzdCO0FBOElEOzs7Ozs7O0dBT0c7QUFDSCxJQUFZLG9CQUtYO0FBTEQsV0FBWSxvQkFBb0I7SUFDOUIsbUNBQVcsQ0FBQTtJQUNYLG1DQUFXLENBQUE7SUFDWCxtQ0FBVyxDQUFBO0lBQ1gscUNBQWEsQ0FBQTtBQUNmLENBQUMsRUFMVyxvQkFBb0Isb0NBQXBCLG9CQUFvQixRQUsvQiJ9

package/build/main/lib/pageVideoStreamWriter.d.ts

@@ -0,0 +1,40 @@
+/// <reference types="node" />
+/// <reference types="node" />
+/// <reference types="node" />
+import { EventEmitter } from 'events';
+import { Writable } from 'stream';
+import { pageScreenFrame, VideoOptions } from './pageVideoStreamTypes';
+/**
+ * @ignore
+ */
+export default class PageVideoStreamWriter extends EventEmitter {
+    private readonly screenLimit;
+    private screenCastFrames;
+    duration: string;
+    frameGain: number;
+    frameLoss: number;
+    private status;
+    private options;
+    private videoMediatorStream;
+    private writerPromise;
+    constructor(destinationSource: string | Writable, options?: VideoOptions);
+    private get videoFrameSize();
+    private get autopad();
+    private getFfmpegPath;
+    private getDestinationPathExtension;
+    private configureFFmPegPath;
+    private isWritableStream;
+    private configureVideoFile;
+    private configureVideoWritableStream;
+    private getOutputOption;
+    private addVideoMetadata;
+    private getDestinationStream;
+    private handleWriteStreamError;
+    private findSlot;
+    insert(frame: pageScreenFrame): void;
+    private trimFrame;
+    private processFrameBeforeWrite;
+    write(data: Buffer, durationSeconds?: number): void;
+    private drainFrames;
+    stop(stoppedTime?: number): Promise<boolean>;
+}