termdock 1.4.333 → 1.4.335

package/dist/server/android/scrcpy.js

@@ -4,6 +4,7 @@ import net from 'node:net';
 import { delimiter, dirname, join } from 'node:path';
 import { randomInt } from 'node:crypto';
 import { adbSearchPath, resolveAdbBinary } from './adb.js';
+import { connectScrcpyForward } from './scrcpyForward.js';
 import { LiveBitrateChannel, inspectLiveBitrate, resolveBundledPreviewServer, bitrateOverlayPath, bitrateOverlayRemote } from './liveBitrate.js';
 const DEVICE_NAME_LENGTH = 64;
 const VIDEO_HEADER_LENGTH = 12;
@@ -126,11 +127,15 @@ function runAdbCapture(args, timeout = 30_000) {
 function scidHex(scid) {
     return scid.toString(16).padStart(8, '0');
 }
-/** 单设备的一条 scrcpy 会话：推送 server → adb reverse → 启动 server → 解析 H.264/H.265 流。 */
+/** 单设备的一条 scrcpy 会话：推送 server → ADB 隧道 → 启动 server → 解析视频流。 */
 export class ScrcpySession {
     serial;
     events;
     options;
+    // Network ADB can acknowledge reverse rules without carrying their data.
+    tunnelForward;
+    forwardPort = 0;
+    connectionAbort = new AbortController();
     scid = randomInt(1, 0x7fffffff);
     bitrateChannel = null;
     child = null;
@@ -148,11 +153,13 @@ export class ScrcpySession {
     started = false;
     deviceName = '';
     resolveHeader = null;
+    rejectHeader = null;
     logLines = [];
     constructor(serial, events, options = {}) {
         this.serial = serial;
         this.events = events;
         this.options = options;
+        this.tunnelForward = /[:.]/.test(serial);
     }
     get running() { return this.started && !this.stopped; }
     log(line) {
@@ -166,6 +173,7 @@ export class ScrcpySession {
     fail(error) {
         if (this.stopped)
             return;
+        this.rejectHeader?.(error);
         this.events.onError(error);
         void this.stop();
     }
@@ -178,14 +186,23 @@ export class ScrcpySession {
             this.protocol = Number.parseInt(version.split('.')[0] ?? '0', 10) >= 4 ? 'session' : 'legacy';
             const remoteJar = remoteJarPath(version);
             await runAdbCapture(['-s', this.serial, 'push', serverJar, remoteJar], 60_000);
-            const server = net.createServer();
-            this.server = server;
-            server.on('connection', socket => this.acceptSocket(socket));
-            await new Promise((resolve, reject) => {
-                server.once('error', reject);
-                server.listen(0, '127.0.0.1', () => { this.port = server.address().port; resolve(); });
-            });
-            await runAdbCapture(['-s', this.serial, 'reverse', `localabstract:scrcpy_${scidHex(this.scid)}`, `tcp:${this.port}`], 15_000);
+            if (this.tunnelForward) {
+                const assigned = await runAdbCapture(['-s', this.serial, 'forward', 'tcp:0', `localabstract:scrcpy_${scidHex(this.scid)}`], 15_000);
+                const port = Number(assigned);
+                if (!Number.isInteger(port) || port < 1 || port > 65535)
+                    throw new Error('SCRCPY_FORWARD_INVALID_PORT');
+                this.forwardPort = port;
+            }
+            else {
+                const server = net.createServer();
+                this.server = server;
+                server.on('connection', socket => this.acceptSocket(socket));
+                await new Promise((resolve, reject) => {
+                    server.once('error', reject);
+                    server.listen(0, '127.0.0.1', () => { this.port = server.address().port; resolve(); });
+                });
+                await runAdbCapture(['-s', this.serial, 'reverse', `localabstract:scrcpy_${scidHex(this.scid)}`, `tcp:${this.port}`], 15_000);
+            }
             let liveBitrate = false;
             let bitrateFailure = await inspectLiveBitrate(serverJar, version);
             let bitrateStage = 'BITRATE_LISTEN_FAILED';
@@ -218,6 +235,7 @@ export class ScrcpySession {
             if (this.stopped) {
                 this.bitrateChannel?.close();
                 this.server?.close();
+                await this.removeForward();
                 await Promise.allSettled(['scrcpy_', 'termdock_bitrate_'].map(prefix => runAdbCapture(['-s', this.serial, 'reverse', '--remove', `localabstract:${prefix}${scidHex(this.scid)}`], 8000)));
                 return;
             }
@@ -230,7 +248,7 @@ export class ScrcpySession {
                 'log_level=info',
                 'audio=false',
                 'control=true',
-                'tunnel_forward=false',
+                `tunnel_forward=${this.tunnelForward}`,
                 'power_on=true',
                 'stay_awake=true',
                 'clipboard_autosync=false',
@@ -239,14 +257,21 @@ export class ScrcpySession {
             ];
             if (this.options.maxFps && this.options.maxFps > 0)
                 args.push(`max_fps=${this.options.maxFps}`);
+            const headerReady = this.waitForHeader();
+            // Handle early process exit even while forward is establishing its sockets.
+            void headerReady.catch(() => { });
             const child = spawn(adbBinary(), args, { stdio: ['ignore', 'pipe', 'pipe'], env: { ...process.env, PATH: adbSearchPath() } });
             this.child = child;
             child.stdout?.on('data', chunk => this.log(String(chunk).replace(/^\[server\]\s*/, '')));
             child.stderr?.on('data', chunk => this.log(String(chunk)));
             child.on('error', error => this.fail(error instanceof Error ? error : new Error('SCRCPY_SPAWN_FAILED')));
-            child.on('close', () => { if (!this.stopped)
-                this.fail(new Error(this.logLines.at(-1) || 'SCRCPY_SERVER_EXITED')); });
-            await this.waitForHeader();
+            child.on('close', (code, signal) => {
+                if (!this.stopped)
+                    this.fail(new Error(`SCRCPY_SERVER_EXITED: code=${code ?? 'null'} signal=${signal ?? 'none'}; tunnel=${this.tunnelForward ? 'forward' : 'reverse'}; video=${this.videoSocket ? 'connected' : 'not_connected'}\n${this.logLines.slice(-8).join('\n')}`));
+            });
+            await Promise.all([headerReady, this.tunnelForward
+                    ? connectScrcpyForward(this.forwardPort, this.connectionAbort.signal, socket => this.acceptSocket(socket))
+                    : Promise.resolve()]);
         }
         catch (error) {
             const normalized = error instanceof Error ? error : new Error('SCRCPY_START_FAILED');
@@ -257,8 +282,10 @@ export class ScrcpySession {
     }
     waitForHeader() {
         return new Promise((resolve, reject) => {
-            const timer = setTimeout(() => { this.resolveHeader = null; reject(new Error('SCRCPY_CONNECT_TIMEOUT')); }, CONNECT_TIMEOUT_MS);
-            this.resolveHeader = () => { clearTimeout(timer); this.resolveHeader = null; resolve(); };
+            const clear = () => { clearTimeout(timer); this.resolveHeader = null; this.rejectHeader = null; };
+            const timer = setTimeout(() => { clear(); reject(new Error('SCRCPY_CONNECT_TIMEOUT')); }, CONNECT_TIMEOUT_MS);
+            this.resolveHeader = () => { clear(); resolve(); };
+            this.rejectHeader = error => { clear(); reject(error); };
         });
     }
     acceptSocket(socket) {
@@ -268,7 +295,7 @@ export class ScrcpySession {
             socket.on('data', chunk => this.readVideo(chunk));
             socket.on('error', error => this.fail(error instanceof Error ? error : new Error('VIDEO_SOCKET_ERROR')));
             socket.on('close', () => { if (!this.stopped)
-                this.fail(new Error(this.logLines.at(-1) || 'VIDEO_SOCKET_CLOSED')); });
+                this.fail(new Error(`VIDEO_SOCKET_CLOSED: tunnel=${this.tunnelForward ? 'forward' : 'reverse'}\n${this.logLines.slice(-8).join('\n')}`)); });
             return;
         }
         if (!this.controlSocket) {
@@ -416,10 +443,22 @@ export class ScrcpySession {
     setBitrate(value) {
         return this.bitrateChannel?.setBitrate(value) ?? Promise.resolve(false);
     }
+    async removeForward() {
+        const port = this.forwardPort;
+        this.forwardPort = 0;
+        if (port) {
+            try {
+                await runAdbCapture(['-s', this.serial, 'forward', '--remove', `tcp:${port}`], 8000);
+            }
+            catch { /* The device or ADB may already have removed this exact rule. */ }
+        }
+    }
     async stop() {
         if (this.stopped)
             return;
         this.stopped = true;
+        this.connectionAbort.abort();
+        this.rejectHeader?.(new Error('SCRCPY_SESSION_STOPPED'));
         activeSessions.delete(this);
         this.bitrateChannel?.close();
         const child = this.child;
@@ -445,6 +484,7 @@ export class ScrcpySession {
             }
             catch { /* ignore */ }
         }
+        await this.removeForward();
         try {
             await runAdbCapture(['-s', this.serial, 'reverse', '--remove', `localabstract:scrcpy_${scidHex(this.scid)}`], 8000);
         }

package/dist/server/android/scrcpyForward.js

@@ -0,0 +1,83 @@
+import net from 'node:net';
+/** Wait for scrcpy's dummy byte: an ADB forward TCP accept alone does not
+ * prove the device-side localabstract listener has started yet. */
+export async function connectScrcpyForward(port, signal, accept, timeoutMs = 12_000) {
+    const deadline = Date.now() + timeoutMs;
+    const open = (dummy) => new Promise((resolve, reject) => {
+        if (signal.aborted) {
+            reject(new Error('SCRCPY_SESSION_STOPPED'));
+            return;
+        }
+        const socket = net.connect({ host: '127.0.0.1', port });
+        const timer = setTimeout(() => fail(new Error('SCRCPY_FORWARD_CONNECT_TIMEOUT')), Math.min(500, Math.max(1, deadline - Date.now())));
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal.removeEventListener('abort', abort);
+            socket.removeListener('error', fail);
+            socket.removeListener('close', closed);
+            socket.removeListener('data', data);
+            socket.removeListener('connect', connected);
+        };
+        const fail = (error) => { cleanup(); socket.destroy(); reject(error); };
+        const closed = () => fail(new Error('SCRCPY_FORWARD_CONNECTION_CLOSED'));
+        const abort = () => fail(new Error('SCRCPY_SESSION_STOPPED'));
+        const ready = () => { socket.pause(); cleanup(); resolve(socket); };
+        const connected = () => { if (!dummy)
+            ready(); };
+        const data = (chunk) => {
+            if (!chunk.length)
+                return;
+            if (chunk[0] !== 0) {
+                fail(new Error('SCRCPY_FORWARD_HANDSHAKE_INVALID'));
+                return;
+            }
+            socket.pause();
+            if (chunk.length > 1)
+                socket.unshift(chunk.subarray(1));
+            ready();
+        };
+        signal.addEventListener('abort', abort, { once: true });
+        socket.on('error', fail);
+        socket.on('close', closed);
+        socket.on('connect', connected);
+        if (dummy)
+            socket.on('data', data);
+    });
+    let video;
+    let control;
+    try {
+        while (!signal.aborted && Date.now() < deadline) {
+            try {
+                video = await open(true);
+                break;
+            }
+            catch (error) {
+                if (signal.aborted || Date.now() >= deadline)
+                    throw error;
+                await new Promise(resolve => {
+                    const done = () => { clearTimeout(timer); signal.removeEventListener('abort', done); resolve(); };
+                    const timer = setTimeout(done, 100);
+                    signal.addEventListener('abort', done, { once: true });
+                    if (signal.aborted)
+                        done();
+                });
+            }
+        }
+        if (!video || signal.aborted)
+            throw new Error(signal.aborted ? 'SCRCPY_SESSION_STOPPED' : 'SCRCPY_FORWARD_CONNECT_TIMEOUT');
+        // Install video error/close listeners before waiting for control.
+        accept(video);
+        control = await open(false);
+        if (signal.aborted)
+            throw new Error('SCRCPY_SESSION_STOPPED');
+        // Keep video paused until both sockets have listeners and definite roles.
+        accept(control);
+        video.resume();
+        control.resume();
+    }
+    catch (error) {
+        video?.destroy();
+        control?.destroy();
+        throw error;
+    }
+}

package/dist/server/routes/android.js

@@ -162,14 +162,17 @@ export function handleAndroidWebSocket(socket, serial, _clientId, requested = {}
     const shutdown = (reason) => {
         if (closed)
             return;
+        // send() rejects closed sessions: deliver the cause before marking it closed.
+        if (reason) {
+            console.warn(`[android] session failed serial=${serial}: ${reason}`);
+            send({ type: 'error', message: reason });
+        }
         closed = true;
         clearInterval(flowTimer);
         if (statsTimer)
             clearInterval(statsTimer);
         if (DEBUG_ANDROID)
             console.log(`[android] session end serial=${serial} sent=${sent} acked=${acked} reason=${reason ?? 'ok'}`);
-        if (reason)
-            send({ type: 'error', message: reason });
         try {
             session?.stop();
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "termdock",
-  "version": "1.4.333",
+  "version": "1.4.335",
   "description": "A complete web-based terminal application with modern UI",
   "type": "module",
   "main": ".desktop-dist/main.js",

package/runtime-manifest.json

@@ -1,13 +1,13 @@
 {
   "schemaVersion": 1,
   "packageName": "termdock",
-  "version": "1.4.333",
+  "version": "1.4.335",
   "runtimeProtocolVersion": 1,
   "minimumDesktopVersion": "1.4.46",
   "nodeMajor": 22,
   "dependencyHash": "sha256-oaGYi/P5ob8sd6VnNBOwshKozjhdV+hYiCmLAsn5x00=",
-  "serverBundleHash": "sha256-3no4R3NbStrmDJJLVupnUBWo7XLepTMTQ6C+w+LDL6g=",
-  "clientBundleHash": "sha256-gqWugg/ce7uDBMDWu7qHf22tZHe4d6gCfG3PUkKlSZA=",
+  "serverBundleHash": "sha256-oP7hnH+0kNAIOiaQqS+7gVZR8blwiKXULzIZ8eQYCOE=",
+  "clientBundleHash": "sha256-5AO8soGCDDxFlZjr8zTeNxVLFL4bw+MXYLTu2kdyLs0=",
   "entrypoint": "dist/server/cli.js",
   "clientEntrypoint": "dist/client/index.html"
 }

package/scripts/android-bitrate/README.md

@@ -26,6 +26,14 @@ checksum before writing). Its source is https://github.com/Genymobile/scrcpy/tre
 An explicit TERMDOCK_SCRCPY_SERVER override is honored. Missing/invalid bundled
 assets fall back to the host server; unverified host builds then retain current
 quality with a diagnostic. Rejections and channel failures also preserve video.
+
+Network ADB preview sessions use `adb forward` for video and control; USB
+sessions retain `adb reverse`. The forward connector waits for the scrcpy dummy
+byte before opening control and removes only its own allocated TCP rule on stop.
+The optional bitrate channel still uses a separate reverse rule. If reverse rules
+register but carry no data, its handshake times out with a diagnostic; preview
+continues at the configured bitrate.
+
 Extend the allowlist only after verifying the CaptureReset ABI and real-device
 behavior. No global scrcpy installation is modified.
 
@@ -40,8 +48,15 @@ desktop runtime packager. Apache-2.0 license is included.
 
 Validation: Mi MIX 2S / Android 13 accepted 1.8 → 6 → 0.9 → 4 Mbps within
 one session, continuously producing frames, with one video header and one codec
-configuration packet. Other vendor encoders and macOS/iOS clients require real
-device verification.
+configuration packet.
+
+Mac server and iPhone preview rendering were also verified with network
+PTP-AN00 / Android 16 and Pixel 9 / Android 15 using forward video. On those cloud
+routes, reverse registration succeeded without carrying data: bitrate handshakes
+timed out while preview stayed alive. Physical identity properties matched across
+the PTP IPv4/IPv6 routes; option grouping and selected-route preservation are
+covered by tests. These observations do not establish live bitrate support on
+those devices or full native input/recording acceptance.
 
 Diagnostics distinguish version/build, missing/corrupt extension, ADB push/reverse,
 15s handshake timeout, 2.5s device ACK timeout, 4s client confirmation timeout,