@elizaos/capacitor-screencapture 1.0.0

package/dist/esm/definitions.d.ts

@@ -0,0 +1,101 @@
+import type { PluginListenerHandle } from "@capacitor/core";
+export interface ScreenshotOptions {
+    format?: "png" | "jpeg" | "webp";
+    quality?: number;
+    scale?: number;
+    captureSystemUI?: boolean;
+}
+export interface ScreenshotResult {
+    base64: string;
+    format: string;
+    width: number;
+    height: number;
+    timestamp: number;
+}
+export interface ScreenRecordingOptions {
+    quality?: "low" | "medium" | "high" | "highest";
+    maxDuration?: number;
+    maxFileSize?: number;
+    fps?: number;
+    bitrate?: number;
+    captureAudio?: boolean;
+    captureSystemAudio?: boolean;
+    captureMicrophone?: boolean;
+    showTouches?: boolean;
+}
+export interface ScreenRecordingState {
+    isRecording: boolean;
+    duration: number;
+    fileSize: number;
+    fps?: number;
+}
+export interface ScreenRecordingResult {
+    path: string;
+    duration: number;
+    width: number;
+    height: number;
+    fileSize: number;
+    mimeType: string;
+}
+export interface ScreenCapturePermissionStatus {
+    screenCapture: "granted" | "denied" | "prompt" | "not_supported";
+    microphone: "granted" | "denied" | "prompt";
+}
+export interface ScreenCaptureErrorEvent {
+    code: string;
+    message: string;
+}
+export interface ScreenCapturePlugin {
+    /**
+     * Check if screen capture is supported on this device
+     */
+    isSupported(): Promise<{
+        supported: boolean;
+        features: string[];
+    }>;
+    /**
+     * Capture a screenshot of the current screen
+     */
+    captureScreenshot(options?: ScreenshotOptions): Promise<ScreenshotResult>;
+    /**
+     * Start screen recording
+     */
+    startRecording(options?: ScreenRecordingOptions): Promise<void>;
+    /**
+     * Stop screen recording and return the video file
+     */
+    stopRecording(): Promise<ScreenRecordingResult>;
+    /**
+     * Pause the current recording
+     */
+    pauseRecording(): Promise<void>;
+    /**
+     * Resume a paused recording
+     */
+    resumeRecording(): Promise<void>;
+    /**
+     * Get current recording state
+     */
+    getRecordingState(): Promise<ScreenRecordingState>;
+    /**
+     * Check screen capture permissions
+     */
+    checkPermissions(): Promise<ScreenCapturePermissionStatus>;
+    /**
+     * Request screen capture permissions
+     */
+    requestPermissions(): Promise<ScreenCapturePermissionStatus>;
+    /**
+     * Add event listener for recording state changes
+     */
+    addListener(eventName: "recordingState", listenerFunc: (event: ScreenRecordingState) => void): Promise<PluginListenerHandle>;
+    /**
+     * Add event listener for errors
+     */
+    addListener(eventName: "error", listenerFunc: (event: ScreenCaptureErrorEvent) => void): Promise<PluginListenerHandle>;
+    /**
+     * Remove all event listeners
+     */
+    removeAllListeners(): Promise<void>;
+}
+//# sourceMappingURL=definitions.d.ts.map

package/dist/esm/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"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"}

package/dist/esm/definitions.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/index.d.ts

@@ -0,0 +1,4 @@
+import type { ScreenCapturePlugin } from "./definitions";
+export * from "./definitions";
+export declare const ScreenCapture: ScreenCapturePlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,eAAe,CAAC;AAEzD,cAAc,eAAe,CAAC;AAI9B,eAAO,MAAM,aAAa,qBAKzB,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,6 @@
+import { registerPlugin } from "@capacitor/core";
+export * from "./definitions";
+const loadWeb = () => import("./web").then((m) => new m.ScreenCaptureWeb());
+export const ScreenCapture = registerPlugin("ScreenCapture", {
+    web: loadWeb,
+});

package/dist/esm/web.d.ts

@@ -0,0 +1,56 @@
+import { WebPlugin } from "@capacitor/core";
+import type { ScreenCaptureErrorEvent, ScreenCapturePermissionStatus, ScreenRecordingOptions, ScreenRecordingResult, ScreenRecordingState, ScreenshotOptions, ScreenshotResult } from "./definitions";
+type ScreenCaptureEventData = ScreenRecordingState | ScreenCaptureErrorEvent;
+export declare class ScreenCaptureWeb extends WebPlugin {
+    private mediaStream;
+    private mediaRecorder;
+    private recordedChunks;
+    private isRecording;
+    private isPaused;
+    private recordingStartTime;
+    private pausedDuration;
+    private pauseStartTime;
+    private recordingStateInterval;
+    private pluginListeners;
+    isSupported(): Promise<{
+        supported: boolean;
+        features: string[];
+    }>;
+    captureScreenshot(options?: ScreenshotOptions): Promise<ScreenshotResult>;
+    startRecording(options?: ScreenRecordingOptions): Promise<void>;
+    stopRecording(): Promise<ScreenRecordingResult>;
+    pauseRecording(): Promise<void>;
+    resumeRecording(): Promise<void>;
+    getRecordingState(): Promise<ScreenRecordingState>;
+    /**
+     * Check screen capture permissions.
+     *
+     * LIMITATION: The Screen Capture API (getDisplayMedia) does not support permission queries.
+     * Unlike camera/microphone, there's no way to check if permission was previously granted.
+     * Each call to getDisplayMedia always prompts the user.
+     *
+     * `screenCapture` will be:
+     * - "not_supported": getDisplayMedia API not available
+     * - "prompt": API available, but actual permission state is unknown (always requires prompt)
+     */
+    checkPermissions(): Promise<ScreenCapturePermissionStatus>;
+    /**
+     * Request screen capture permissions.
+     *
+     * LIMITATION: Screen capture (getDisplayMedia) cannot be pre-requested.
+     * The user is prompted only when an actual capture is initiated.
+     * This method only requests microphone permission for audio capture during recording.
+     *
+     * `screenCapture` will be:
+     * - "not_supported": getDisplayMedia API not available
+     * - "prompt": API available (permission prompt happens during actual capture)
+     */
+    requestPermissions(): Promise<ScreenCapturePermissionStatus>;
+    addListener(eventName: string, listenerFunc: (event: ScreenCaptureEventData) => void): Promise<{
+        remove: () => Promise<void>;
+    }>;
+    removeAllListeners(): Promise<void>;
+    protected notifyListeners(eventName: string, data: ScreenCaptureEventData): void;
+}
+export {};
+//# sourceMappingURL=web.d.ts.map

package/dist/esm/web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAE5C,OAAO,KAAK,EACV,uBAAuB,EACvB,6BAA6B,EAC7B,sBAAsB,EACtB,qBAAqB,EACrB,oBAAoB,EACpB,iBAAiB,EACjB,gBAAgB,EACjB,MAAM,eAAe,CAAC;AAEvB,KAAK,sBAAsB,GAAG,oBAAoB,GAAG,uBAAuB,CAAC;AA4B7E,qBAAa,gBAAiB,SAAQ,SAAS;IAC7C,OAAO,CAAC,WAAW,CAA4B;IAC/C,OAAO,CAAC,aAAa,CAA8B;IACnD,OAAO,CAAC,cAAc,CAAc;IACpC,OAAO,CAAC,WAAW,CAAS;IAC5B,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,kBAAkB,CAAK;IAC/B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,cAAc,CAAK;IAC3B,OAAO,CAAC,sBAAsB,CAA+C;IAC7E,OAAO,CAAC,eAAe,CAGf;IAEF,WAAW,IAAI,OAAO,CAAC;QAAE,SAAS,EAAE,OAAO,CAAC;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IASlE,iBAAiB,CACrB,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,gBAAgB,CAAC;IAoDtB,cAAc,CAAC,OAAO,CAAC,EAAE,sBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC;IAmG/D,aAAa,IAAI,OAAO,CAAC,qBAAqB,CAAC;IAuE/C,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;IA2B/B,eAAe,IAAI,OAAO,CAAC,IAAI,CAAC;IAchC,iBAAiB,IAAI,OAAO,CAAC,oBAAoB,CAAC;IAgBxD;;;;;;;;;;OAUG;IACG,gBAAgB,IAAI,OAAO,CAAC,6BAA6B,CAAC;IAiBhE;;;;;;;;;;OAUG;IACG,kBAAkB,IAAI,OAAO,CAAC,6BAA6B,CAAC;IAkB5D,WAAW,CACf,SAAS,EAAE,MAAM,EACjB,YAAY,EAAE,CAAC,KAAK,EAAE,sBAAsB,KAAK,IAAI,GACpD,OAAO,CAAC;QAAE,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC;IAWrC,kBAAkB,IAAI,OAAO,CAAC,IAAI,CAAC;IAIzC,SAAS,CAAC,eAAe,CACvB,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,sBAAsB,GAC3B,IAAI;CAOR"}

package/dist/esm/web.js

@@ -0,0 +1,330 @@
+import { WebPlugin } from "@capacitor/core";
+const VIDEO_MIME_TYPES = [
+    "video/webm;codecs=vp9,opus",
+    "video/webm;codecs=vp8,opus",
+    "video/webm",
+    "video/mp4",
+];
+const getSupportedMimeType = () => VIDEO_MIME_TYPES.find((m) => MediaRecorder.isTypeSupported(m)) ?? null;
+const hasDisplayMedia = () => !!navigator.mediaDevices.getDisplayMedia;
+const getDisplayMedia = (opts) => navigator.mediaDevices.getDisplayMedia(opts);
+export class ScreenCaptureWeb extends WebPlugin {
+    constructor() {
+        super(...arguments);
+        this.mediaStream = null;
+        this.mediaRecorder = null;
+        this.recordedChunks = [];
+        this.isRecording = false;
+        this.isPaused = false;
+        this.recordingStartTime = 0;
+        this.pausedDuration = 0;
+        this.pauseStartTime = 0;
+        this.recordingStateInterval = null;
+        this.pluginListeners = [];
+    }
+    async isSupported() {
+        const supported = hasDisplayMedia();
+        const features = [];
+        if (supported)
+            features.push("screenshot", "recording");
+        if (typeof MediaRecorder !== "undefined")
+            features.push("video_encoding");
+        if (typeof AudioContext !== "undefined")
+            features.push("system_audio");
+        return { supported, features };
+    }
+    async captureScreenshot(options) {
+        const format = options?.format || "png";
+        const quality = (options?.quality || 100) / 100;
+        const scale = options?.scale || 1;
+        const stream = await getDisplayMedia({
+            video: { displaySurface: "monitor" },
+            audio: false,
+        });
+        const track = stream.getVideoTracks()[0];
+        const settings = track.getSettings();
+        const width = (settings.width || 1920) * scale;
+        const height = (settings.height || 1080) * scale;
+        const imageCapture = new ImageCapture(track);
+        const bitmap = await imageCapture.grabFrame();
+        stream.getTracks().forEach((t) => {
+            t.stop();
+        });
+        const canvas = document.createElement("canvas");
+        canvas.width = width;
+        canvas.height = height;
+        const ctx = canvas.getContext("2d");
+        if (!ctx) {
+            throw new Error("Failed to get canvas context");
+        }
+        ctx.drawImage(bitmap, 0, 0, width, height);
+        bitmap.close();
+        const mimeType = format === "png"
+            ? "image/png"
+            : format === "webp"
+                ? "image/webp"
+                : "image/jpeg";
+        const dataUrl = canvas.toDataURL(mimeType, quality);
+        const base64 = dataUrl.split(",")[1];
+        return {
+            base64,
+            format,
+            width,
+            height,
+            timestamp: Date.now(),
+        };
+    }
+    async startRecording(options) {
+        if (this.isRecording)
+            throw new Error("Recording already in progress");
+        const videoConstraints = {
+            displaySurface: "monitor",
+        };
+        if (options?.fps)
+            videoConstraints.frameRate = { ideal: options.fps };
+        this.mediaStream = await getDisplayMedia({
+            video: videoConstraints,
+            audio: options?.captureSystemAudio !== false,
+        });
+        if (options?.captureMicrophone) {
+            const micStream = await navigator.mediaDevices.getUserMedia({
+                audio: true,
+            });
+            micStream.getAudioTracks().forEach((t) => {
+                this.mediaStream?.addTrack(t);
+            });
+        }
+        const mimeType = getSupportedMimeType();
+        if (!mimeType) {
+            this.mediaStream.getTracks().forEach((t) => {
+                t.stop();
+            });
+            throw new Error("No supported video mime type found");
+        }
+        const recorderOptions = { mimeType };
+        if (options?.bitrate)
+            recorderOptions.videoBitsPerSecond = options.bitrate;
+        this.recordedChunks = [];
+        this.mediaRecorder = new MediaRecorder(this.mediaStream, recorderOptions);
+        this.mediaRecorder.ondataavailable = (event) => {
+            if (event.data.size > 0) {
+                this.recordedChunks.push(event.data);
+            }
+        };
+        this.mediaRecorder.onerror = (event) => {
+            this.notifyListeners("error", {
+                code: "RECORDING_ERROR",
+                message: `Recording error: ${event.message || "Unknown error"}`,
+            });
+        };
+        this.mediaStream.getVideoTracks()[0].addEventListener("ended", () => {
+            if (this.isRecording) {
+                this.stopRecording().catch((err) => {
+                    console.error("[ScreenCapture] Auto-stop on track end failed:", err);
+                });
+            }
+        });
+        this.recordingStartTime = Date.now();
+        this.pausedDuration = 0;
+        this.isRecording = true;
+        this.isPaused = false;
+        this.mediaRecorder.start(1000);
+        this.notifyListeners("recordingState", {
+            isRecording: true,
+            duration: 0,
+            fileSize: 0,
+        });
+        let autoStopping = false;
+        this.recordingStateInterval = setInterval(() => {
+            if (!this.isRecording || this.isPaused || autoStopping)
+                return;
+            const duration = (Date.now() - this.recordingStartTime - this.pausedDuration) / 1000;
+            const fileSize = this.recordedChunks.reduce((acc, chunk) => acc + chunk.size, 0);
+            this.notifyListeners("recordingState", {
+                isRecording: true,
+                duration,
+                fileSize,
+            });
+            const overLimit = (options?.maxDuration && duration >= options.maxDuration) ||
+                (options?.maxFileSize && fileSize >= options.maxFileSize);
+            if (overLimit) {
+                autoStopping = true;
+                this.stopRecording().catch((err) => {
+                    console.error("[ScreenCapture] Auto-stop recording failed:", err);
+                });
+            }
+        }, 500);
+    }
+    async stopRecording() {
+        if (!this.isRecording || !this.mediaRecorder) {
+            throw new Error("Not recording");
+        }
+        return new Promise((resolve, reject) => {
+            if (!this.mediaRecorder) {
+                reject(new Error("MediaRecorder not initialized"));
+                return;
+            }
+            const duration = (Date.now() - this.recordingStartTime - this.pausedDuration) / 1000;
+            this.mediaRecorder.onstop = () => {
+                if (this.recordingStateInterval) {
+                    clearInterval(this.recordingStateInterval);
+                    this.recordingStateInterval = null;
+                }
+                this.isRecording = false;
+                this.isPaused = false;
+                if (this.mediaStream) {
+                    this.mediaStream.getTracks().forEach((track) => {
+                        track.stop();
+                    });
+                    this.mediaStream = null;
+                }
+                const blob = new Blob(this.recordedChunks, {
+                    type: this.mediaRecorder?.mimeType || "video/webm",
+                });
+                const url = URL.createObjectURL(blob);
+                const video = document.createElement("video");
+                video.src = url;
+                video.onloadedmetadata = () => {
+                    resolve({
+                        path: url,
+                        duration,
+                        width: video.videoWidth,
+                        height: video.videoHeight,
+                        fileSize: blob.size,
+                        mimeType: this.mediaRecorder?.mimeType || "video/webm",
+                    });
+                };
+                video.onerror = () => {
+                    resolve({
+                        path: url,
+                        duration,
+                        width: 0,
+                        height: 0,
+                        fileSize: blob.size,
+                        mimeType: this.mediaRecorder?.mimeType || "video/webm",
+                    });
+                };
+                this.notifyListeners("recordingState", {
+                    isRecording: false,
+                    duration,
+                    fileSize: blob.size,
+                });
+            };
+            this.mediaRecorder.stop();
+        });
+    }
+    async pauseRecording() {
+        if (!this.isRecording || !this.mediaRecorder) {
+            throw new Error("Not recording");
+        }
+        if (this.isPaused) {
+            return;
+        }
+        this.mediaRecorder.pause();
+        this.isPaused = true;
+        this.pauseStartTime = Date.now();
+        const duration = (Date.now() - this.recordingStartTime - this.pausedDuration) / 1000;
+        const fileSize = this.recordedChunks.reduce((acc, chunk) => acc + chunk.size, 0);
+        this.notifyListeners("recordingState", {
+            isRecording: true,
+            duration,
+            fileSize,
+        });
+    }
+    async resumeRecording() {
+        if (!this.isRecording || !this.mediaRecorder) {
+            throw new Error("Not recording");
+        }
+        if (!this.isPaused) {
+            return;
+        }
+        this.pausedDuration += Date.now() - this.pauseStartTime;
+        this.mediaRecorder.resume();
+        this.isPaused = false;
+    }
+    async getRecordingState() {
+        const duration = this.isRecording
+            ? (Date.now() - this.recordingStartTime - this.pausedDuration) / 1000
+            : 0;
+        const fileSize = this.recordedChunks.reduce((acc, chunk) => acc + chunk.size, 0);
+        return {
+            isRecording: this.isRecording,
+            duration,
+            fileSize,
+        };
+    }
+    /**
+     * Check screen capture permissions.
+     *
+     * LIMITATION: The Screen Capture API (getDisplayMedia) does not support permission queries.
+     * Unlike camera/microphone, there's no way to check if permission was previously granted.
+     * Each call to getDisplayMedia always prompts the user.
+     *
+     * `screenCapture` will be:
+     * - "not_supported": getDisplayMedia API not available
+     * - "prompt": API available, but actual permission state is unknown (always requires prompt)
+     */
+    async checkPermissions() {
+        let microphone = "prompt";
+        try {
+            const result = await navigator.permissions.query({
+                name: "microphone",
+            });
+            microphone = result.state;
+        }
+        catch {
+            // Permissions API may not support microphone query in this browser
+        }
+        // Screen capture permission cannot be queried - getDisplayMedia always prompts
+        const screenCaptureStatus = hasDisplayMedia() ? "prompt" : "not_supported";
+        return { screenCapture: screenCaptureStatus, microphone };
+    }
+    /**
+     * Request screen capture permissions.
+     *
+     * LIMITATION: Screen capture (getDisplayMedia) cannot be pre-requested.
+     * The user is prompted only when an actual capture is initiated.
+     * This method only requests microphone permission for audio capture during recording.
+     *
+     * `screenCapture` will be:
+     * - "not_supported": getDisplayMedia API not available
+     * - "prompt": API available (permission prompt happens during actual capture)
+     */
+    async requestPermissions() {
+        let microphone = "denied";
+        try {
+            const stream = await navigator.mediaDevices.getUserMedia({ audio: true });
+            stream.getTracks().forEach((t) => {
+                t.stop();
+            });
+            microphone = "granted";
+        }
+        catch {
+            microphone = "denied";
+        }
+        // Cannot pre-request screen capture permission - it requires user gesture + actual capture
+        const screenCaptureStatus = hasDisplayMedia() ? "prompt" : "not_supported";
+        return { screenCapture: screenCaptureStatus, microphone };
+    }
+    async addListener(eventName, listenerFunc) {
+        const entry = { eventName, callback: listenerFunc };
+        this.pluginListeners.push(entry);
+        return {
+            remove: async () => {
+                const i = this.pluginListeners.indexOf(entry);
+                if (i >= 0)
+                    this.pluginListeners.splice(i, 1);
+            },
+        };
+    }
+    async removeAllListeners() {
+        this.pluginListeners = [];
+    }
+    notifyListeners(eventName, data) {
+        this.pluginListeners
+            .filter((l) => l.eventName === eventName)
+            .forEach((l) => {
+            l.callback(data);
+        });
+    }
+}