@9b9387/android-stream-scrcpy 0.1.0 → 0.1.2

package/README.md

@@ -251,22 +251,54 @@ const snapshots = new FfmpegSnapshotCache(service, {
   enabled: true,
   fps: 2,
   quality: 85,
+  // Optional robustness knobs (defaults shown):
+  drainTimeoutMs: 5000, // tear down ffmpeg if stdin stalls this long
+  killTimeoutMs: 2000, // SIGTERM grace before SIGKILL on stop()
+  staleTimeoutMs: 10000, // emit "stale" when no new frame for this long (0 = off)
+  maxStdoutBytes: 16 * 1024 * 1024, // cap on the JPEG reassembly buffer
 });
 
 await service.start();
-snapshots.start();
+snapshots.start(); // must be called after service.start()
 
+// Non-blocking read of the most recent frame (may be null before the first):
 const latest = snapshots.latest();
-if (latest) {
-  // latest.contentType === "image/jpeg"
-  // latest.data is a Buffer containing JPEG bytes.
+
+// Or wait up to N ms for the first/next frame instead of busy-polling 404s:
+try {
+  const shot = await snapshots.waitForFresh(3000);
+  // shot.contentType === "image/jpeg"; shot.data is a JPEG Buffer
+} catch {
+  // no frame within the timeout — surface a 503 / "warming up" to the client
 }
+
+// Observe a stalled stream (device asleep, encoder paused, etc.):
+snapshots.on("stale", ({ ageMs }) => {
+  console.warn(`no new snapshot for ${ageMs}ms`);
+});
 ```
 
 The first implementation supports H.264 input and JPEG output. The configured
 `fps` limits how often ffmpeg emits JPEG frames; ffmpeg still receives the
 continuous H.264 stream so inter-frame decoding remains correct.
 
+### Lifecycle & resource safety
+
+- `FfmpegSnapshotCache` listens to the service state: when the service stops or
+  errors, the ffmpeg process is killed automatically, so it never lingers as an
+  orphan across reconnects. You should still call `snapshots.stop()` explicitly
+  when you tear a session down yourself.
+- `waitForFresh()` resolves immediately if a frame is cached, otherwise it
+  resolves on the next frame or rejects after the timeout — use it in HTTP
+  handlers so a single request never hangs and clients never busy-poll.
+- The WebSocket bridge applies backpressure: a slow client's droppable video
+  frames are dropped (config/keyframe/session packets are preserved) once its
+  outbound buffer exceeds `maxBufferedBytes` (8MiB default), preventing
+  unbounded memory growth. Tune via `new ScrcpyWebSocketBridge(service, { maxBufferedBytes })`.
+
+For multi-device streaming and per-device screenshot HTTP routes, see
+[docs/multi-device-screenshot.md](./docs/multi-device-screenshot.md) (Web integration guide, 中文).
+
 ## Next.js And Electron Usage
 
 ### Next.js

package/dist/backend/io/buffered-stream-reader.d.ts

@@ -1,9 +1,10 @@
 import * as net from "node:net";
 export declare class BufferedStreamReader {
+    private readonly maxBufferBytes;
     private buffer;
     private waiters;
     private ended;
-    constructor(stream: net.Socket);
+    constructor(stream: net.Socket, maxBufferBytes?: number);
     readExact(n: number): Promise<Uint8Array>;
     private rejectAll;
     private checkWaiters;

package/dist/backend/io/buffered-stream-reader.js

@@ -1,11 +1,23 @@
 import { concatBytes } from "../../protocol/core/binary.js";
+// Safety cap on the reassembly buffer. A single scrcpy frame is well under
+// this; exceeding it means the stream is desynchronized or a bogus frame size
+// was read, so we fail fast instead of growing memory without bound.
+const DEFAULT_MAX_BUFFER_BYTES = 64 * 1024 * 1024;
 export class BufferedStreamReader {
+    maxBufferBytes;
     buffer = new Uint8Array(0);
     waiters = [];
     ended = false;
-    constructor(stream) {
+    constructor(stream, maxBufferBytes = DEFAULT_MAX_BUFFER_BYTES) {
+        this.maxBufferBytes = maxBufferBytes;
         stream.on("data", (chunk) => {
             this.buffer = concatBytes([this.buffer, chunk]);
+            if (this.buffer.byteLength > this.maxBufferBytes) {
+                this.ended = true;
+                this.rejectAll(new Error(`stream reader buffer exceeded ${this.maxBufferBytes} bytes; aborting`));
+                stream.destroy();
+                return;
+            }
             this.checkWaiters();
         });
         stream.on("error", (err) => {

package/dist/backend/server/options.d.ts

@@ -13,14 +13,16 @@ export interface ScrcpyBackendOptions {
     control?: boolean;
     videoCodec?: VideoCodec;
     audioCodec?: AudioCodec;
+    videoEncoder?: string;
     connectionTimeoutMs?: number;
     deployTimeoutMs?: number;
     pushTimeoutMs?: number;
     serverJarPath?: string;
 }
-export interface NormalizedScrcpyBackendOptions extends Required<Omit<ScrcpyBackendOptions, "serverJarPath">> {
+export interface NormalizedScrcpyBackendOptions extends Required<Omit<ScrcpyBackendOptions, "serverJarPath" | "videoEncoder">> {
     protocol: ScrcpyProtocol;
     socketName: string;
     serverJarPath: string;
+    videoEncoder?: string;
 }
 export declare function normalizeBackendOptions(options?: ScrcpyBackendOptions): NormalizedScrcpyBackendOptions;

package/dist/backend/server/options.js

@@ -22,6 +22,7 @@ export function normalizeBackendOptions(options = {}) {
         control: options.control !== false,
         videoCodec: options.videoCodec ?? VideoCodec.H264,
         audioCodec: options.audioCodec ?? AudioCodec.OPUS,
+        videoEncoder: options.videoEncoder,
         connectionTimeoutMs: options.connectionTimeoutMs ?? 8000,
         deployTimeoutMs: options.deployTimeoutMs ?? 5000,
         pushTimeoutMs: options.pushTimeoutMs ?? 60000,

package/dist/backend/server/server-command.js

@@ -1,5 +1,5 @@
 export function getDeviceServerPath(serverVersion) {
-    return `/data/local/tmp/scrcpy-server-v${serverVersion}.jar`;
+    return "/data/local/tmp/scrcpy-server.jar";
 }
 export function buildServerCommand(deviceServerPath, options) {
     const args = [
@@ -14,6 +14,7 @@ export function buildServerCommand(deviceServerPath, options) {
             control: options.control,
             videoCodec: options.videoCodec,
             audioCodec: options.audioCodec,
+            videoEncoder: options.videoEncoder,
             maxSize: options.maxSize,
             maxFps: options.maxFps,
             videoBitRate: options.videoBitRate,

package/dist/protocol/v4_0/server-options.d.ts

@@ -10,6 +10,7 @@ export interface ScrcpyServerOptionInput {
     control: boolean;
     videoCodec: VideoCodec;
     audioCodec: AudioCodec;
+    videoEncoder?: string;
     maxSize: number;
     maxFps: number;
     videoBitRate: number;

package/dist/protocol/v4_0/server-options.js

@@ -11,28 +11,37 @@ export function getSocketName(scid = DEFAULT_SCRCPY_SCID) {
 }
 export function buildServerOptions(input) {
     const scid = input.scid ?? DEFAULT_SCRCPY_SCID;
-    return [
+    const opts = [
         SCRCPY_4_0_SERVER_VERSION,
+        `scid=${(scid >>> 0).toString(16).padStart(8, "0")}`,
         `log_level=${input.logLevel ?? "info"}`,
         "tunnel_forward=true",
-        `scid=${scid.toString(16)}`,
         `video=${input.video}`,
         `audio=${input.audio}`,
         `control=${input.control}`,
-        `video_codec=${input.videoCodec}`,
-        `audio_codec=${input.audioCodec}`,
-        `max_size=${input.maxSize}`,
-        `max_fps=${input.maxFps}`,
-        `video_bit_rate=${input.videoBitRate}`,
-        `audio_bit_rate=${input.audioBitRate}`,
-        "send_device_meta=true",
-        "send_frame_meta=true",
-        "send_dummy_byte=true",
-        "send_stream_meta=true",
-        "cleanup=true",
-        "stay_awake=false",
-        "show_touches=false",
-        "power_off_on_close=false",
-        "clipboard_autosync=false",
     ];
+    if (input.videoCodec) {
+        opts.push(`video_codec=${input.videoCodec}`);
+    }
+    if (input.audioCodec) {
+        opts.push(`audio_codec=${input.audioCodec}`);
+    }
+    if (input.videoEncoder) {
+        opts.push(`video_encoder=${input.videoEncoder}`);
+    }
+    if (input.maxSize > 0) {
+        opts.push(`max_size=${input.maxSize}`);
+    }
+    if (input.maxFps > 0) {
+        opts.push(`max_fps=${input.maxFps}`);
+    }
+    if (input.videoBitRate > 0 && input.videoBitRate !== 8000000) {
+        opts.push(`video_bit_rate=${input.videoBitRate}`);
+    }
+    if (input.audioBitRate > 0 && input.audioBitRate !== 128000) {
+        opts.push(`audio_bit_rate=${input.audioBitRate}`);
+    }
+    // Other options like cleanup, send_device_meta, etc. use server-side defaults
+    // to keep the command line short and avoid Samsung-specific crashes.
+    return opts;
 }

package/dist/snapshot/ffmpeg-snapshot-cache.d.ts

@@ -12,6 +12,10 @@ export declare class FfmpegSnapshotCache extends EventEmitter {
     private readonly fps;
     private readonly quality;
     private readonly ffmpegPath;
+    private readonly drainTimeoutMs;
+    private readonly killTimeoutMs;
+    private readonly staleTimeoutMs;
+    private readonly maxStdoutBytes;
     private readonly spawnProcess;
     private process;
     private subscription;
@@ -19,16 +23,31 @@ export declare class FfmpegSnapshotCache extends EventEmitter {
     private stderrTail;
     private currentSnapshot;
     private running;
+    private staleTimer;
+    private staleEmitted;
+    private readonly onServiceState;
     constructor(service: ScrcpyStreamService, options?: SnapshotCacheOptions);
     start(): void;
     stop(): void;
     latest(): Snapshot | null;
+    /**
+     * Resolve with a snapshot, waiting up to `timeoutMs` for the first frame if
+     * the cache has not produced one yet. Lets HTTP handlers avoid both a busy
+     * 404-poll loop and an unbounded hang while ffmpeg warms up.
+     */
+    waitForFresh(timeoutMs?: number): Promise<Snapshot>;
     private buildFfmpegArgs;
     private pumpVideoPackets;
     private writePacket;
+    private waitForDrain;
     private handleStdout;
     private handleStderr;
     private handleProcessError;
+    private handlePumpError;
+    private startStaleWatchdog;
+    private bindServiceState;
+    private unbindServiceState;
     private cleanup;
+    private killProcess;
     private formatStderrTail;
 }

package/dist/snapshot/ffmpeg-snapshot-cache.js

@@ -1,12 +1,16 @@
 import { spawn } from "node:child_process";
 import { EventEmitter } from "node:events";
-import { once } from "node:events";
-import { MediaKind, } from "../service/index.js";
+import { MediaKind, StreamState, } from "../service/index.js";
 import { VideoCodec } from "../protocol/index.js";
 const JPEG_SOI = Buffer.from([0xff, 0xd8]);
 const JPEG_EOI = Buffer.from([0xff, 0xd9]);
 const DEFAULT_SNAPSHOT_FPS = 2;
 const DEFAULT_JPEG_QUALITY = 85;
+const DEFAULT_DRAIN_TIMEOUT_MS = 5000;
+const DEFAULT_KILL_TIMEOUT_MS = 2000;
+const DEFAULT_STALE_TIMEOUT_MS = 10000;
+const DEFAULT_MAX_STDOUT_BYTES = 16 * 1024 * 1024;
+const STALE_CHECK_INTERVAL_MS = 1000;
 export function extractJpegFrames(buffer) {
     const frames = [];
     let offset = 0;
@@ -34,6 +38,10 @@ export class FfmpegSnapshotCache extends EventEmitter {
     fps;
     quality;
     ffmpegPath;
+    drainTimeoutMs;
+    killTimeoutMs;
+    staleTimeoutMs;
+    maxStdoutBytes;
     spawnProcess;
     process = null;
     subscription = null;
@@ -41,6 +49,9 @@ export class FfmpegSnapshotCache extends EventEmitter {
     stderrTail = "";
     currentSnapshot = null;
     running = false;
+    staleTimer = null;
+    staleEmitted = false;
+    onServiceState;
     constructor(service, options = {}) {
         super();
         this.service = service;
@@ -48,11 +59,23 @@ export class FfmpegSnapshotCache extends EventEmitter {
         this.fps = normalizeFps(options.fps ?? DEFAULT_SNAPSHOT_FPS);
         this.quality = normalizeJpegQuality(options.quality ?? DEFAULT_JPEG_QUALITY);
         this.ffmpegPath = options.ffmpegPath ?? "ffmpeg";
+        this.drainTimeoutMs = options.drainTimeoutMs ?? DEFAULT_DRAIN_TIMEOUT_MS;
+        this.killTimeoutMs = options.killTimeoutMs ?? DEFAULT_KILL_TIMEOUT_MS;
+        this.staleTimeoutMs = options.staleTimeoutMs ?? DEFAULT_STALE_TIMEOUT_MS;
+        this.maxStdoutBytes = options.maxStdoutBytes ?? DEFAULT_MAX_STDOUT_BYTES;
         this.spawnProcess =
             options.spawnProcess ??
                 ((command, args) => spawn(command, args, {
                     stdio: ["pipe", "pipe", "pipe"],
                 }));
+        this.onServiceState = (state) => {
+            // When the underlying stream stops or errors out, the subscription dries
+            // up but ffmpeg would otherwise linger as an orphan process. Tear it down
+            // so each device's ffmpeg lifetime is bounded by its service.
+            if (state === StreamState.STOPPED || state === StreamState.ERROR) {
+                this.stop();
+            }
+        };
     }
     start() {
         if (!this.enabled || this.running)
@@ -62,6 +85,8 @@ export class FfmpegSnapshotCache extends EventEmitter {
             throw new Error(`snapshot cache only supports h264 video, got ${videoCodec}`);
         }
         this.running = true;
+        this.staleEmitted = false;
+        this.bindServiceState();
         this.process = this.spawnProcess(this.ffmpegPath, this.buildFfmpegArgs());
         this.process.stdout.on("data", (chunk) => this.handleStdout(chunk));
         this.process.stderr.on("data", (chunk) => {
@@ -75,6 +100,7 @@ export class FfmpegSnapshotCache extends EventEmitter {
             }
         });
         this.subscription = this.service.subscribe();
+        this.startStaleWatchdog();
         void this.pumpVideoPackets();
     }
     stop() {
@@ -83,6 +109,40 @@ export class FfmpegSnapshotCache extends EventEmitter {
     latest() {
         return this.currentSnapshot;
     }
+    /**
+     * Resolve with a snapshot, waiting up to `timeoutMs` for the first frame if
+     * the cache has not produced one yet. Lets HTTP handlers avoid both a busy
+     * 404-poll loop and an unbounded hang while ffmpeg warms up.
+     */
+    waitForFresh(timeoutMs = 3000) {
+        if (this.currentSnapshot)
+            return Promise.resolve(this.currentSnapshot);
+        if (!this.running || !this.enabled) {
+            return Promise.reject(new Error("snapshot cache is not running"));
+        }
+        return new Promise((resolve, reject) => {
+            const onShot = (shot) => {
+                cleanup();
+                resolve(shot);
+            };
+            const onError = (e) => {
+                cleanup();
+                reject(e);
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                reject(new Error(`snapshot not available within ${timeoutMs}ms`));
+            }, timeoutMs);
+            timer.unref?.();
+            const cleanup = () => {
+                clearTimeout(timer);
+                this.removeListener("snapshot", onShot);
+                this.removeListener("error", onError);
+            };
+            this.once("snapshot", onShot);
+            this.once("error", onError);
+        });
+    }
     buildFfmpegArgs() {
         return [
             "-hide_banner",
@@ -124,17 +184,45 @@ export class FfmpegSnapshotCache extends EventEmitter {
             }
         }
         catch (e) {
-            if (this.running)
-                this.emit("error", e);
+            this.handlePumpError(e);
         }
     }
     async writePacket(proc, packet) {
         if (proc.stdin.write(packet.payload))
             return;
-        await once(proc.stdin, "drain");
+        await this.waitForDrain(proc);
+    }
+    waitForDrain(proc) {
+        return new Promise((resolve, reject) => {
+            const onDrain = () => {
+                cleanup();
+                resolve();
+            };
+            const onError = (e) => {
+                cleanup();
+                reject(e);
+            };
+            const timer = setTimeout(() => {
+                cleanup();
+                reject(new Error(`ffmpeg stdin did not drain within ${this.drainTimeoutMs}ms`));
+            }, this.drainTimeoutMs);
+            timer.unref?.();
+            const cleanup = () => {
+                clearTimeout(timer);
+                proc.stdin.removeListener("drain", onDrain);
+                proc.stdin.removeListener("error", onError);
+            };
+            proc.stdin.once("drain", onDrain);
+            proc.stdin.once("error", onError);
+        });
     }
     handleStdout(chunk) {
         this.stdoutBuffer = Buffer.concat([this.stdoutBuffer, chunk]);
+        // Guard against a corrupt/headerless ffmpeg stream where no EOI ever
+        // arrives: without a cap the remainder would grow without bound.
+        if (this.stdoutBuffer.byteLength > this.maxStdoutBytes) {
+            this.stdoutBuffer = this.stdoutBuffer.subarray(-this.maxStdoutBytes);
+        }
         const result = extractJpegFrames(this.stdoutBuffer);
         this.stdoutBuffer = result.remainder;
         for (const frame of result.frames) {
@@ -143,6 +231,7 @@ export class FfmpegSnapshotCache extends EventEmitter {
                 data: frame,
                 timestampMs: Date.now(),
             };
+            this.staleEmitted = false;
             this.emit("snapshot", this.currentSnapshot);
         }
     }
@@ -157,8 +246,44 @@ export class FfmpegSnapshotCache extends EventEmitter {
         this.cleanup({ clearSnapshot: true, killProcess: false });
         this.emit("error", e);
     }
+    handlePumpError(e) {
+        if (!this.running)
+            return;
+        // A pump failure (e.g. stdin stalled past the drain timeout) means ffmpeg
+        // is wedged; kill it so the cache can be restarted cleanly.
+        this.cleanup({ clearSnapshot: true, killProcess: true });
+        this.emit("error", e);
+    }
+    startStaleWatchdog() {
+        if (this.staleTimeoutMs <= 0)
+            return;
+        const timer = setInterval(() => {
+            if (!this.running || !this.currentSnapshot || this.staleEmitted)
+                return;
+            const age = Date.now() - this.currentSnapshot.timestampMs;
+            if (age > this.staleTimeoutMs) {
+                this.staleEmitted = true;
+                this.emit("stale", { ageMs: age, snapshot: this.currentSnapshot });
+            }
+        }, STALE_CHECK_INTERVAL_MS);
+        timer.unref?.();
+        this.staleTimer = timer;
+    }
+    bindServiceState() {
+        const emitter = this.service;
+        emitter.on?.("state", this.onServiceState);
+    }
+    unbindServiceState() {
+        const emitter = this.service;
+        emitter.removeListener?.("state", this.onServiceState);
+    }
     cleanup(options) {
         this.running = false;
+        this.unbindServiceState();
+        if (this.staleTimer) {
+            clearInterval(this.staleTimer);
+            this.staleTimer = null;
+        }
         this.subscription?.return?.();
         this.subscription = null;
         const proc = this.process;
@@ -166,13 +291,27 @@ export class FfmpegSnapshotCache extends EventEmitter {
         if (proc) {
             proc.stdin.end();
             if (options.killProcess)
-                proc.kill();
+                this.killProcess(proc);
         }
         this.stdoutBuffer = Buffer.alloc(0);
         this.stderrTail = "";
         if (options.clearSnapshot)
             this.currentSnapshot = null;
     }
+    killProcess(proc) {
+        proc.kill();
+        // Escalate to SIGKILL if ffmpeg ignores the polite signal.
+        const timer = setTimeout(() => {
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch {
+                // process already gone
+            }
+        }, this.killTimeoutMs);
+        timer.unref?.();
+        proc.once("exit", () => clearTimeout(timer));
+    }
     formatStderrTail() {
         const tail = this.stderrTail.trim();
         return tail ? ` stderr=${tail}` : "";

package/dist/snapshot/types.d.ts

@@ -9,6 +9,27 @@ export interface SnapshotCacheOptions {
     fps?: number;
     quality?: number;
     ffmpegPath?: string;
+    /**
+     * Max time to wait for ffmpeg stdin to drain before treating the process as
+     * stalled and tearing it down. Defaults to 5000ms.
+     */
+    drainTimeoutMs?: number;
+    /**
+     * Grace period after SIGTERM before escalating to SIGKILL on stop. Defaults
+     * to 2000ms.
+     */
+    killTimeoutMs?: number;
+    /**
+     * Emit a `stale` event when the newest snapshot is older than this many ms
+     * (e.g. the device stopped producing frames). 0 disables. Defaults to
+     * 10000ms.
+     */
+    staleTimeoutMs?: number;
+    /**
+     * Cap on the internal ffmpeg stdout reassembly buffer, guarding against a
+     * corrupt stream with no JPEG end marker. Defaults to 16MiB.
+     */
+    maxStdoutBytes?: number;
     spawnProcess?: FfmpegProcessFactory;
 }
 export type FfmpegProcess = Pick<ChildProcessWithoutNullStreams, "stdin" | "stdout" | "stderr" | "kill" | "on" | "once">;

package/dist/websocket/scrcpy-websocket-bridge.d.ts

@@ -3,8 +3,10 @@ import { WebSocketBridgeOptions } from "./types.js";
 export declare class ScrcpyWebSocketBridge {
     private service;
     private wss;
+    private readonly maxBufferedBytes;
     constructor(service: ScrcpyStreamService, options?: WebSocketBridgeOptions);
     close(): void;
     private handleConnection;
+    private isDroppable;
     private createInitMessage;
 }

package/dist/websocket/scrcpy-websocket-bridge.js

@@ -1,12 +1,17 @@
 import { WebSocket, WebSocketServer } from "ws";
+import { MediaKind } from "../service/types.js";
 import { serializeMediaPacket } from "./binary-packet.js";
 import { parseControlJson } from "./control-json.js";
 import { WEBSOCKET_HEADER_SIZE, WEBSOCKET_KIND_AUDIO, WEBSOCKET_KIND_SESSION, WEBSOCKET_KIND_VIDEO, } from "./types.js";
+const DEFAULT_MAX_BUFFERED_BYTES = 8 * 1024 * 1024;
 export class ScrcpyWebSocketBridge {
     service;
     wss;
+    maxBufferedBytes;
     constructor(service, options = {}) {
         this.service = service;
+        this.maxBufferedBytes =
+            options.maxBufferedBytes ?? DEFAULT_MAX_BUFFERED_BYTES;
         this.wss = new WebSocketServer({
             port: options.port,
             server: options.server,
@@ -38,6 +43,14 @@ export class ScrcpyWebSocketBridge {
             for await (const packet of subscription) {
                 if (ws.readyState !== WebSocket.OPEN)
                     break;
+                // Apply backpressure: when the client falls behind, drop droppable
+                // frames instead of letting ws buffer them without bound. Config,
+                // key frames and session packets are kept so the decoder can recover.
+                if (this.maxBufferedBytes > 0 &&
+                    ws.bufferedAmount > this.maxBufferedBytes &&
+                    this.isDroppable(packet)) {
+                    continue;
+                }
                 ws.send(serializeMediaPacket(packet));
             }
         }
@@ -45,6 +58,9 @@ export class ScrcpyWebSocketBridge {
             ws.close();
         }
     }
+    isDroppable(packet) {
+        return (packet.kind === MediaKind.VIDEO && !packet.config && !packet.keyFrame);
+    }
     createInitMessage() {
         const meta = this.service.currentMeta;
         return {

package/dist/websocket/types.d.ts

@@ -2,6 +2,12 @@ export interface WebSocketBridgeOptions {
     port?: number;
     server?: any;
     path?: string;
+    /**
+     * Drop media frames for a connection whose outbound buffer exceeds this many
+     * bytes. Protects the process from unbounded memory growth when a client is
+     * slower than the stream. 0 disables. Defaults to 8MiB.
+     */
+    maxBufferedBytes?: number;
 }
 export declare const WEBSOCKET_HEADER_SIZE = 16;
 export declare const WEBSOCKET_KIND_VIDEO = 1;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@9b9387/android-stream-scrcpy",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Versioned scrcpy protocol client for Node.js/Electron",
   "type": "module",
   "main": "./dist/index.js",