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

package/README.md

@@ -4,8 +4,6 @@ TypeScript scrcpy client library for Node.js and Electron. It starts `scrcpy-ser
 
 The bundled protocol implementation targets scrcpy `4.0`. Protocol code is versioned so future versions, such as `4.1`, can be added side by side without rewriting the backend or service layers.
 
-> Runtime note: the root package is Node-only. Use it from a Node.js process, an Electron main process, a Next.js Node runtime route/server, or another long-lived backend process. Do not import the root package from browser code, Next.js Client Components, or Edge Runtime handlers.
-
 ## Project Structure
 
 ```text
@@ -47,10 +45,6 @@ node-lib/
       scrcpy-stream-service.ts
       types.ts
       index.ts
-    snapshot/
-      ffmpeg-snapshot-cache.ts
-      types.ts
-      index.ts
     websocket/
       binary-packet.ts
       control-json.ts
@@ -65,19 +59,18 @@ node-lib/
 - `src/protocol/`: scrcpy wire protocol implementation. `core/` contains shared binary helpers and protocol interfaces; `registry.ts` selects a protocol adapter by version; `v4_0/` contains scrcpy 4.0 frame, control, device, codec, and server-option logic.
 - `src/backend/`: adbkit-only device integration. `adb/` wraps adbkit operations, `io/` contains socket reading utilities, `server/` builds and normalizes scrcpy server launch details, and `scrcpy-backend.ts` orchestrates the streaming connection.
 - `src/service/`: public stream service. It manages state, caches decoder config/session snapshots, and exposes `for await...of` media packet subscriptions.
-- `src/snapshot/`: optional Node-side screenshot cache. It pipes H.264 packets into ffmpeg and stores the latest JPEG frame.
 - `src/websocket/`: optional `ws` bridge for browser clients. It is exported from the `./websocket` subpath and is not part of the root API.
 - `examples/`: runnable examples kept outside the library build.
 
-## Install
-
-Install the package in your application:
+## Install And Build
 
 ```bash
-npm install @9b9387/android-stream-scrcpy
+cd node-lib
+npm install
+npm run build
 ```
 
-Core runtime dependency is `@devicefarmer/adbkit`. The library does not call the `adb` system command directly.
+Core runtime dependency is only `@devicefarmer/adbkit`. The library does not call the `adb` system command directly.
 
 If your application uses the optional WebSocket bridge, install `ws` in the application:
 
@@ -85,25 +78,6 @@ If your application uses the optional WebSocket bridge, install `ws` in the appl
 npm install ws
 ```
 
-If your application uses the optional screenshot cache, make sure `ffmpeg` is available on `PATH`, or pass `ffmpegPath` to `FfmpegSnapshotCache`.
-
-## Build From Source
-
-```bash
-cd node-lib
-npm install
-npm run build
-```
-
-## Package Entrypoints
-
-- `@9b9387/android-stream-scrcpy`: Node-only service/backend API.
-- `@9b9387/android-stream-scrcpy/protocol`: protocol adapters and types. This is the safest entrypoint for code that only needs scrcpy protocol constants, codecs, and message types.
-- `@9b9387/android-stream-scrcpy/websocket`: optional Node-only `ws` bridge.
-- `@9b9387/android-stream-scrcpy/snapshot`: optional Node-only ffmpeg screenshot cache.
-
-The package is ESM-only and requires Node.js 20 or newer.
-
 ## Run Examples
 
 Run the console stream demo:
@@ -267,34 +241,6 @@ 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.
 
-## Next.js And Electron Usage
-
-### Next.js
-
-Use this package only from the server side of a self-hosted or long-lived Node.js runtime:
-
-```typescript
-export const runtime = "nodejs";
-
-import { ScrcpyStreamService } from "@9b9387/android-stream-scrcpy";
-```
-
-Do not import the root package from Client Components, browser bundles, Middleware,
-or Edge Runtime route handlers. The backend opens ADB sockets and long-lived media
-streams, so a custom Node.js server or separate local daemon is usually a better
-fit than a short-lived serverless function.
-
-### Electron
-
-Create and manage `ScrcpyStreamService` in the main process. Renderer processes
-should communicate with the main process through IPC or connect to the optional
-WebSocket bridge.
-
-When packaging Electron apps, make sure `assets/scrcpy-server-v4.0.jar` is copied
-as a runtime resource. If your packager moves or packs assets into an archive,
-pass an explicit `serverJarPath` to `ScrcpyStreamService`. If screenshot caching
-is enabled, also ship `ffmpeg` yourself or pass `ffmpegPath`.
-
 ## Protocol Versioning
 
 `protocolVersion` defaults to `"4.0"`:
@@ -320,32 +266,6 @@ npm run lint
 npm run typecheck
 npm test
 npm run build
-npm pack --dry-run
 ```
 
 End-to-end streaming requires a connected Android device. Unit tests cover protocol serialization/parsing, backend option normalization, subscriber queue behavior, and WebSocket packet encoding.
-
-## Publish
-
-Before publishing, make sure you are logged in to the npm account that owns the
-`@9b9387` scope:
-
-```bash
-npm whoami
-```
-
-Run the release checks and inspect the tarball contents:
-
-```bash
-npm run typecheck
-npm run test
-npm run lint
-npm run build
-npm pack --dry-run
-```
-
-Publish the public scoped package:
-
-```bash
-npm publish --access public
-```

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/package.json

@@ -1,19 +1,13 @@
 {
   "name": "@9b9387/android-stream-scrcpy",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Versioned scrcpy protocol client for Node.js/Electron",
   "type": "module",
-  "main": "./dist/index.js",
-  "types": "./dist/index.d.ts",
   "exports": {
     ".": {
       "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
-    "./protocol": {
-      "import": "./dist/protocol/index.js",
-      "types": "./dist/protocol/index.d.ts"
-    },
     "./websocket": {
       "import": "./dist/websocket/index.js",
       "types": "./dist/websocket/index.d.ts"
@@ -21,18 +15,12 @@
     "./snapshot": {
       "import": "./dist/snapshot/index.js",
       "types": "./dist/snapshot/index.d.ts"
-    },
-    "./package.json": "./package.json"
+    }
   },
   "files": [
     "dist",
-    "assets",
-    "README.md",
-    "LICENSE"
+    "assets"
   ],
-  "engines": {
-    "node": ">=20"
-  },
   "scripts": {
     "clean": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\"",
     "build": "npm run clean && tsc",
@@ -40,33 +28,9 @@
     "test": "vitest run",
     "lint": "prettier --check .",
     "format": "prettier --write .",
-    "prepack": "npm run build",
-    "prepublishOnly": "npm run typecheck && npm run test && npm run lint && npm run build",
     "example:demo": "npm run build && node --loader ts-node/esm examples/demo.ts",
     "example:server": "npm run build && node --loader ts-node/esm examples/server.ts"
   },
-  "keywords": [
-    "scrcpy",
-    "android",
-    "adb",
-    "streaming",
-    "electron",
-    "nextjs",
-    "typescript"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+ssh://git@github.com/9b9387/android-stream.git",
-    "directory": "node-lib"
-  },
-  "bugs": {
-    "url": "https://github.com/9b9387/android-stream/issues"
-  },
-  "homepage": "https://github.com/9b9387/android-stream/tree/main/node-lib#readme",
-  "publishConfig": {
-    "access": "public"
-  },
   "dependencies": {
     "@devicefarmer/adbkit": "^3.2.3"
   },

package/LICENSE

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