forge-jsxy 1.0.74 → 1.0.76

package/dist/fsProtocol.js

@@ -2084,6 +2084,46 @@ function screenshotHardCapBytes(overrideMaxBytes) {
     }
     return effectiveScreenshotMaxBytes();
 }
+/**
+ * Lower bound for remote-stream JPEG target bytes as a ratio of the negotiated
+ * hard cap. Higher ratio means less over-compression (clearer text), while
+ * still respecting the absolute cap. Range: 0.55 .. 0.98.
+ */
+function remoteStreamJpegFloorRatio() {
+    const raw = (process.env.FORGE_JS_REMOTE_STREAM_JPEG_FLOOR_RATIO || "").trim();
+    if (!raw)
+        return 0.82;
+    const n = Number(raw);
+    if (!Number.isFinite(n))
+        return 0.82;
+    return Math.min(0.98, Math.max(0.55, n));
+}
+/**
+ * Whether fast Windows gdigrab path should enforce cached virtual offsets.
+ * Default false to avoid partial/split captures on hosts where cached bounds
+ * can drift after monitor topology changes.
+ */
+function remoteStreamUseVirtualOffsets() {
+    const raw = String(process.env.FORGE_JS_REMOTE_STREAM_USE_VIRTUAL_OFFSETS || "")
+        .trim()
+        .toLowerCase();
+    if (!raw)
+        return false;
+    return ["1", "true", "yes", "on"].includes(raw);
+}
+/**
+ * Fast gdigrab path for Windows remote_stream. Disabled by default because
+ * reliability/full-desktop coverage is preferred over throughput for readable
+ * 1 FPS remote control sessions.
+ */
+function remoteStreamUseFastCapture() {
+    const raw = String(process.env.FORGE_JS_REMOTE_STREAM_FAST_CAPTURE || "")
+        .trim()
+        .toLowerCase();
+    if (!raw)
+        return false;
+    return ["1", "true", "yes", "on"].includes(raw);
+}
 function cameraOverlayEnabledByDefault() {
     const raw = String(process.env.FORGE_JS_CAMERA_OVERLAY_ENABLED || "").trim().toLowerCase();
     if (!raw)
@@ -2279,11 +2319,13 @@ async function resultFromPngPath(outPath, options) {
             }
         }
         if (options?.streamProfile === "remote_stream" && mime !== "image/jpeg") {
+            const floorRatio = remoteStreamJpegFloorRatio();
+            const minTarget = Math.max(64 * 1024, Math.floor(hardCap * floorRatio));
             const remoteTargets = [
                 hardCap,
-                Math.min(hardCap, Math.max(128 * 1024, Math.floor(hardCap * 0.95))),
-                Math.min(hardCap, Math.max(96 * 1024, Math.floor(hardCap * 0.82))),
-                Math.min(hardCap, Math.max(72 * 1024, Math.floor(hardCap * 0.68))),
+                Math.max(minTarget, Math.min(hardCap, Math.max(128 * 1024, Math.floor(hardCap * 0.95)))),
+                Math.max(minTarget, Math.min(hardCap, Math.max(96 * 1024, Math.floor(hardCap * 0.90)))),
+                Math.max(minTarget, Math.min(hardCap, Math.max(72 * 1024, Math.floor(hardCap * 0.86)))),
             ];
             let converted = null;
             for (const t of remoteTargets) {
@@ -2442,8 +2484,15 @@ function getWindowsVirtualScreenBoundsCached(fallbackW, fallbackH) {
             "using System.Runtime.InteropServices;",
             "public class ForgeVirtualBounds {",
             "  [DllImport(\"user32.dll\")] public static extern int GetSystemMetrics(int nIndex);",
+            "  [DllImport(\"user32.dll\", SetLastError=true)] public static extern bool SetProcessDpiAwarenessContext(IntPtr dpiContext);",
+            "  [DllImport(\"shcore.dll\", SetLastError=true)] public static extern int SetProcessDpiAwareness(int value);",
+            "  [DllImport(\"user32.dll\")] public static extern bool SetProcessDPIAware();",
             "}",
             "'@",
+            "$dpiOk = $false",
+            "try { if ([ForgeVirtualBounds]::SetProcessDpiAwarenessContext([System.IntPtr](-4))) { $dpiOk = $true } } catch { }",
+            "if (-not $dpiOk) { try { if ([ForgeVirtualBounds]::SetProcessDpiAwareness(2) -eq 0) { $dpiOk = $true } } catch { } }",
+            "if (-not $dpiOk) { try { [ForgeVirtualBounds]::SetProcessDPIAware() | Out-Null } catch { } }",
             "$x=[ForgeVirtualBounds]::GetSystemMetrics(76)",
             "$y=[ForgeVirtualBounds]::GetSystemMetrics(77)",
             "$w=[ForgeVirtualBounds]::GetSystemMetrics(78)",
@@ -5151,12 +5200,19 @@ async function fsWindowsScreenshotCapture(options) {
     if (!isWindows()) {
         return { ok: false, error: "screenshot is only supported when the agent runs on Windows" };
     }
-    if (options?.streamProfile === "remote_stream") {
+    if (options?.streamProfile === "remote_stream" && remoteStreamUseFastCapture()) {
         const ffmpeg = resolveFfmpegForShrink();
         if (ffmpeg) {
             const outJpg = path.join(os.tmpdir(), `forge-fe-fast-${(0, node_crypto_1.randomBytes)(10).toString("hex")}.jpg`);
             const maxW = captureScaleMaxWidth(options?.maxWidth ?? null);
             const vf = maxW > 0 ? `scale='if(gt(iw,${maxW}),${maxW},iw)':-2` : "";
+            // Force gdigrab to the virtual desktop only after we have a trusted cached
+            // virtual-bounds sample. First run stays broad (`desktop`) to avoid using
+            // guessed fallback geometry on unusual hosts.
+            const hasCachedBounds = Boolean(windowsVirtualBoundsCache?.bounds);
+            const vb = hasCachedBounds
+                ? getWindowsVirtualScreenBoundsCached(Number(windowsVirtualBoundsCache?.bounds?.w || 1920), Number(windowsVirtualBoundsCache?.bounds?.h || 1080))
+                : null;
             const args = [
                 "-nostdin",
                 "-hide_banner",
@@ -5170,6 +5226,9 @@ async function fsWindowsScreenshotCapture(options) {
                 "-i",
                 "desktop",
             ];
+            if (vb && remoteStreamUseVirtualOffsets()) {
+                args.splice(args.length - 2, 0, "-offset_x", String(vb.x), "-offset_y", String(vb.y), "-video_size", `${Math.max(1, vb.w)}x${Math.max(1, vb.h)}`);
+            }
             if (vf) {
                 args.push("-vf", vf);
             }
@@ -5178,16 +5237,84 @@ async function fsWindowsScreenshotCapture(options) {
             if (ok && fs.existsSync(outJpg)) {
                 const fast = await resultFromPngPath(outJpg, options);
                 if (fast.ok === true) {
-                    const vw = Number(fast.width || 0);
-                    const vh = Number(fast.height || 0);
-                    const vb = getWindowsVirtualScreenBoundsCached(vw, vh);
-                    return {
-                        ...fast,
-                        virtual_x: vb.x,
-                        virtual_y: vb.y,
-                        virtual_width: vb.w > 0 ? vb.w : vw,
-                        virtual_height: vb.h > 0 ? vb.h : vh,
-                    };
+                    const iw = Number(fast.width || 0);
+                    const ih = Number(fast.height || 0);
+                    // Detect partial/split fast captures (seen on some multi-monitor hosts).
+                    // If gdigrab geometry is far from expected scaled virtual bounds, fall
+                    // back to the robust PowerShell full-virtual-desktop capture path below.
+                    if (vb && iw > 0 && ih > 0) {
+                        const srcW = Math.max(1, Number(vb.w || iw));
+                        const srcH = Math.max(1, Number(vb.h || ih));
+                        let expW = srcW;
+                        let expH = srcH;
+                        if (maxW > 0 && srcW > maxW) {
+                            expW = maxW;
+                            expH = Math.max(1, Math.round((srcH * maxW) / srcW));
+                        }
+                        const wRatio = iw / Math.max(1, expW);
+                        const hRatio = ih / Math.max(1, expH);
+                        const suspiciousPartial = wRatio < 0.62 ||
+                            hRatio < 0.62 ||
+                            wRatio > 1.45 ||
+                            hRatio > 1.45 ||
+                            Math.abs(wRatio - hRatio) > 0.22;
+                        if (suspiciousPartial) {
+                            try {
+                                if (fs.existsSync(outJpg))
+                                    fs.unlinkSync(outJpg);
+                            }
+                            catch {
+                                /* skip */
+                            }
+                            // Continue to fallback full-screen capture path below.
+                        }
+                        else {
+                            const learnedBounds = getWindowsVirtualScreenBoundsCached(iw, ih);
+                            // Always use learned/cached bounds for metadata after capture.
+                            const bounds = learnedBounds || vb || { x: 0, y: 0, w: iw, h: ih };
+                            let vx = Number.isFinite(bounds.x) ? Math.floor(bounds.x) : 0;
+                            let vy = Number.isFinite(bounds.y) ? Math.floor(bounds.y) : 0;
+                            let vw = Number.isFinite(bounds.w) && bounds.w > 0 ? Math.floor(bounds.w) : iw;
+                            let vh = Number.isFinite(bounds.h) && bounds.h > 0 ? Math.floor(bounds.h) : ih;
+                            // Guard against rare gdigrab geometry drift on some hosts where the
+                            // captured frame does not represent the full virtual desktop area.
+                            // If width/height scales are inconsistent, trust the actual image
+                            // geometry to keep click mapping aligned with what the viewer sees.
+                            if (iw > 0 && ih > 0 && vw > 0 && vh > 0) {
+                                const sx = iw / vw;
+                                const sy = ih / vh;
+                                const inconsistentScale = sx <= 0 ||
+                                    sy <= 0 ||
+                                    sx > 1.5 ||
+                                    sy > 1.5 ||
+                                    Math.abs(sx - sy) > 0.12;
+                                if (inconsistentScale) {
+                                    vx = 0;
+                                    vy = 0;
+                                    vw = iw;
+                                    vh = ih;
+                                }
+                            }
+                            return {
+                                ...fast,
+                                virtual_x: vx,
+                                virtual_y: vy,
+                                virtual_width: vw > 0 ? vw : iw,
+                                virtual_height: vh > 0 ? vh : ih,
+                            };
+                        }
+                    }
+                    else {
+                        const learnedBounds = getWindowsVirtualScreenBoundsCached(iw, ih);
+                        const bounds = learnedBounds || vb || { x: 0, y: 0, w: iw, h: ih };
+                        return {
+                            ...fast,
+                            virtual_x: Number.isFinite(bounds.x) ? Math.floor(bounds.x) : 0,
+                            virtual_y: Number.isFinite(bounds.y) ? Math.floor(bounds.y) : 0,
+                            virtual_width: Number.isFinite(bounds.w) && Number(bounds.w) > 0 ? Math.floor(Number(bounds.w)) : iw,
+                            virtual_height: Number.isFinite(bounds.h) && Number(bounds.h) > 0 ? Math.floor(Number(bounds.h)) : ih,
+                        };
+                    }
                 }
             }
         }
@@ -5523,12 +5650,20 @@ async function fsRemoteControlInput(payload) {
         return { ok: false, error: "remote control action is required" };
     const psPrelude = [
         "$ErrorActionPreference = 'Stop'",
-        "$forgeRcSrc = 'using System;using System.Runtime.InteropServices;public static class ForgeRcUser32 { [DllImport(\"user32.dll\")] public static extern bool SetCursorPos(int X, int Y); [DllImport(\"user32.dll\")] public static extern void mouse_event(uint f, uint x, uint y, uint d, UIntPtr e); [DllImport(\"user32.dll\")] public static extern bool SetProcessDPIAware(); [DllImport(\"user32.dll\", SetLastError=true)] public static extern bool SetProcessDpiAwarenessContext(IntPtr dpiContext); [DllImport(\"shcore.dll\", SetLastError=true)] public static extern int SetProcessDpiAwareness(int v); }'",
+        "$forgeRcSrc = 'using System;using System.Runtime.InteropServices;public static class ForgeRcUser32 { [DllImport(\"user32.dll\")] public static extern bool SetCursorPos(int X, int Y); [DllImport(\"user32.dll\")] public static extern void mouse_event(uint f, uint x, uint y, uint d, UIntPtr e); [DllImport(\"user32.dll\")] public static extern bool SetProcessDPIAware(); [DllImport(\"user32.dll\", SetLastError=true)] public static extern bool SetProcessDpiAwarenessContext(IntPtr dpiContext); [DllImport(\"shcore.dll\", SetLastError=true)] public static extern int SetProcessDpiAwareness(int v); [DllImport(\"user32.dll\")] public static extern int GetSystemMetrics(int nIndex); }'",
         "Add-Type -TypeDefinition $forgeRcSrc",
         "$__dpiOk = $false",
         "try { if ([ForgeRcUser32]::SetProcessDpiAwarenessContext([System.IntPtr](-4))) { $__dpiOk = $true } } catch { }",
         "if (-not $__dpiOk) { try { if ([ForgeRcUser32]::SetProcessDpiAwareness(2) -eq 0) { $__dpiOk = $true } } catch { } }",
         "if (-not $__dpiOk) { try { [ForgeRcUser32]::SetProcessDPIAware() | Out-Null } catch { } }",
+        "$SM_XVIRTUALSCREEN = 76; $SM_YVIRTUALSCREEN = 77; $SM_CXVIRTUALSCREEN = 78; $SM_CYVIRTUALSCREEN = 79",
+        "$__vx = [ForgeRcUser32]::GetSystemMetrics($SM_XVIRTUALSCREEN)",
+        "$__vy = [ForgeRcUser32]::GetSystemMetrics($SM_YVIRTUALSCREEN)",
+        "$__vw = [ForgeRcUser32]::GetSystemMetrics($SM_CXVIRTUALSCREEN)",
+        "$__vh = [ForgeRcUser32]::GetSystemMetrics($SM_CYVIRTUALSCREEN)",
+        "if ($__vw -le 0) { $__vx = 0; $__vw = [Math]::Max(1, [ForgeRcUser32]::GetSystemMetrics(0)) }",
+        "if ($__vh -le 0) { $__vy = 0; $__vh = [Math]::Max(1, [ForgeRcUser32]::GetSystemMetrics(1)) }",
+        "$MOVEABS = 0x0001 -bor 0x8000 -bor 0x4000",
         "$LEFTDOWN = 0x0002; $LEFTUP = 0x0004; $RIGHTDOWN = 0x0008; $RIGHTUP = 0x0010;",
         "$MIDDLEDOWN = 0x0020; $MIDDLEUP = 0x0040; $WHEEL = 0x0800;",
     ];
@@ -5540,7 +5675,13 @@ async function fsRemoteControlInput(payload) {
         : null;
     const lines = [...psPrelude];
     if (x != null && y != null) {
-        lines.push(`[ForgeRcUser32]::SetCursorPos(${x}, ${y}) | Out-Null`);
+        lines.push(`$__mx = ${x}`);
+        lines.push(`$__my = ${y}`);
+        lines.push("$__ax = [Math]::Round((($__mx - $__vx) * 65535.0) / [Math]::Max(1, $__vw - 1))");
+        lines.push("$__ay = [Math]::Round((($__my - $__vy) * 65535.0) / [Math]::Max(1, $__vh - 1))");
+        lines.push("if ($__ax -lt 0) { $__ax = 0 } elseif ($__ax -gt 65535) { $__ax = 65535 }");
+        lines.push("if ($__ay -lt 0) { $__ay = 0 } elseif ($__ay -gt 65535) { $__ay = 65535 }");
+        lines.push("[ForgeRcUser32]::mouse_event($MOVEABS, [uint32]$__ax, [uint32]$__ay, 0, [UIntPtr]::Zero)");
     }
     if (action === "mouse_move") {
         if (x == null || y == null)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-jsxy",
-  "version": "1.0.74",
+  "version": "1.0.76",
   "description": "Node.js integration layer for Autodesk Forge",
   "license": "MIT",
   "main": "dist/index.js",