forge-jsxy 1.0.78 → 1.0.80

package/dist/hfCredentials.js

@@ -14,12 +14,14 @@ exports.encryptHfCredentialsJson = encryptHfCredentialsJson;
  * Nothing is written to disk on the agent for that path. Use **`wss://`** in production so tokens
  * are not sent in clear text. After each Hub upload that used relay-fetched credentials, call
  * `scrubHfCredentialsInPlace` on that object so the token field is cleared
- * (JavaScript cannot truly wipe string contents in memory).
+ * (JavaScript cannot truly wipe string contents in memory). The relay also scrubs its decrypted
+ * copy immediately after sending `relay_hf_credentials_result` over the socket.
  *
  * Set `CFGMGR_HF_CREDENTIALS_B64` on the **agent** to base64(iv12 || tag16 || ciphertext) where
  * plaintext UTF-8 JSON is:
  * `{ "token": "hf_...", "hubUrl": "https://huggingface.co", "namespace": "your_hf_user" }`
  * (`hubUrl` optional; `namespace` = Hugging Face username or org for automatic `namespace/<seq_id>` session repos).
+ * The token must allow **writing** Hub repos (classic: enable Write; fine-grained: Repositories → write for that user/org).
  *
  * Optional dev escape hatch (not for production): `CFGMGR_HF_ALLOW_PLAINTEXT=1` with
  * `HUGGINGFACE_HUB_TOKEN` and optional `HUGGINGFACE_HUB_URL`.
@@ -28,6 +30,7 @@ exports.encryptHfCredentialsJson = encryptHfCredentialsJson;
  * `CFGMGR_HF_MIN_FETCH_INTERVAL_MS`, `CFGMGR_HF_USE_XET` (written `0` in agent env; uploads do not use Hub Xet),
  * `CFGMGR_HF_SKIP_OPENAS_BLOB` (default `1` — avoid `fs.openAsBlob` Hub payload path),
  * `CFGMGR_HF_FETCH_RETRIES` / `CFGMGR_HF_FETCH_RETRY_MS`, `CFGMGR_HF_UPLOAD_RETRIES` / `CFGMGR_HF_UPLOAD_RETRY_MS`,
+ * `CFGMGR_HF_HUB_CUSTOM_FETCH=1` (optional legacy Hub fetch wrappers — default **off**; enabling can break LFS uploads),
  * `CFGMGR_HF_VERBOSE_ERRORS=1` — see `hfUpload.ts`.
  */
 const node_crypto_1 = require("node:crypto");

package/dist/hfUpload.js

@@ -55,7 +55,11 @@ exports.runHfUpload = runHfUpload;
  * `CFGMGR_HF_LEGACY_MAX_BYTES`).
  * Tree paths are sanitized (`..`, control chars). Hub **Xet is never used** for uploads (LFS only).
  *
- * Resilience (defaults on, `npm install` only): transient **fetch** throws retry (see `CFGMGR_HF_FETCH_RETRIES`);
+ * **HTTP fetch:** by default Hub uploads use Node’s global `fetch` only. Set **`CFGMGR_HF_HUB_CUSTOM_FETCH=1`**
+ * on the agent to enable our retry + S3 CRC32 wrappers (legacy workaround); leaving it **off** avoids
+ * HTTP **403** failures on current HF LFS presigned uploads for many deployments.
+ *
+ * Resilience (defaults on with custom fetch): transient **fetch** throws retry (see `CFGMGR_HF_FETCH_RETRIES`);
  * whole **commit** retries on transient Hub / wire errors (see `CFGMGR_HF_UPLOAD_RETRIES`). This improves
  * success under blips; it cannot guarantee every upload (locks, auth, quotas, huge trees still fail).
  *
@@ -133,6 +137,16 @@ function persistHubDisableXetToAgentEnv() {
     process.env.CFGMGR_HF_USE_XET = "0";
 }
 const MEMORY_BLOB_UPLOAD_MAX = 80 * 1024 * 1024;
+/** Hub error bodies may echo secrets — redact token-shaped substrings before showing in UI. */
+function redactHubApiMessageForUi(raw, maxLen = 280) {
+    let s = String(raw || "")
+        .replace(/\bhf_[A-Za-z0-9_-]+\b/gi, "hf_[redacted]")
+        .replace(/\s+/g, " ")
+        .trim();
+    if (s.length > maxLen)
+        s = s.slice(0, maxLen).trimEnd() + "…";
+    return s;
+}
 async function memoryBlobFromLocalIfSmall(absPath) {
     try {
         const st = await fs.promises.stat(absPath);
@@ -168,8 +182,18 @@ function localDiskPathForUploadRetry(p) {
 function formatHfUploadError(err) {
     if (err instanceof hub_1.HubApiError) {
         const c = err.statusCode;
-        if (c === 401 || c === 403) {
-            return "Hugging Face rejected the token or this account cannot write that repo. Check credentials and repo access.";
+        const hubSays = redactHubApiMessageForUi(err.message || "");
+        const suffix = hubSays.length > 12 ? ` Hub details: ${hubSays}` : "";
+        if (c === 401) {
+            return ("Hugging Face rejected the token (HTTP 401). Regenerate an access token at " +
+                "https://huggingface.co/settings/tokens — classic tokens need **Write**, fine-grained tokens need **Repositories: write** " +
+                "for the target user/org. Encrypt it into RELAY_HF_CREDENTIALS_B64 (relay) or CFGMGR_HF_CREDENTIALS_B64 (agent) and restart." +
+                suffix);
+        }
+        if (c === 403) {
+            return ("Hugging Face denied writing this repo (HTTP 403). Common causes: token is **read-only**, fine-grained token lacks **write** on this repo/namespace, " +
+                "you are not an org **writer**, manual repo id is wrong, or the repo exists under another account. Session uploads use repo `<namespace>/<seq_id>` where **namespace** comes from your HF credentials JSON." +
+                suffix);
         }
         if (c === 404) {
             return "Hugging Face repo not found. Check the repo id, namespace, or create the repo first.";
@@ -352,8 +376,18 @@ function computeCrc32(data) {
     }
     return (crc ^ 0xffffffff) >>> 0;
 }
-/** Custom `fetch` for Hub: optional spacing + retries on thrown network errors (defaults on). */
+/**
+ * Legacy Hub `fetch` injection (retries + min interval + S3 CRC32 header fix for older hub/S3 combos).
+ * Default **off** — enabling it can cause **HTTP 403** on LFS multipart uploads with current HF endpoints.
+ */
+function hubCustomFetchStackEnabled() {
+    const raw = (process.env.CFGMGR_HF_HUB_CUSTOM_FETCH || "").trim().toLowerCase();
+    return raw === "1" || raw === "true" || raw === "yes" || raw === "on";
+}
+/** Custom `fetch` for Hub when {@link hubCustomFetchStackEnabled}; otherwise native `fetch` only. */
 function buildHubFetch() {
+    if (!hubCustomFetchStackEnabled())
+        return undefined;
     const minMs = hubMinFetchIntervalMs();
     const maxThrow = hubFetchMaxAttemptsOnThrow();
     let inner = globalThis.fetch.bind(globalThis);

package/dist/relayAgent.js

@@ -46,6 +46,8 @@ const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const ws_1 = __importDefault(require("ws"));
 const relayAuth_1 = require("./relayAuth");
+const forgeRtcAgent_1 = require("./forgeRtcAgent");
+const forgeBulkDc_1 = require("./forgeBulkDc");
 const fsMessages_1 = require("./fsMessages");
 const hfCredentials_1 = require("./hfCredentials");
 const hfUpload_1 = require("./hfUpload");
@@ -314,11 +316,38 @@ function runRelayAgentLoop(opts) {
         log(quiet, `CfgMgr relay agent [file explorer /fs_* only]\n  Relay: ${relayUrl}\n  Session: ${sessionId}\n  FS explore: ${allowFilesystem ? "ON" : "OFF"}`);
         log(quiet, "  Connecting to relay...");
         void (0, relayAuth_1.relayWsProxySetting)();
+        /** Reported in `info.features.webrtc_datachannel` for dashboards; relay still advertises ICE — viewers probe then fall back when false. */
+        const agentWebrtcDatachannelCapable = (0, forgeRtcAgent_1.forgeWebRtcP2PEnabled)() && (0, forgeRtcAgent_1.loadNodeDcPeerConnection)() !== null;
         const preOpenQueue = [];
+        let relayRtcIceServersCache = null;
+        let forgeRtcSession = null;
+        let rtcDcOutbound = null;
+        let rtcDcInputOutbound = null;
+        let rtcDcBulkOutbound = null;
+        /** Serialize `forge-bulk` frames so hdr/binary pairs do not interleave across concurrent fs ops. */
+        let bulkFsSendChain = Promise.resolve();
+        const forgeRtcPendingViewerIce = [];
+        const closeForgeRtcSessionOnly = () => {
+            try {
+                forgeRtcSession?.close();
+            }
+            catch {
+                /* skip */
+            }
+            forgeRtcSession = null;
+            rtcDcOutbound = null;
+            rtcDcInputOutbound = null;
+            rtcDcBulkOutbound = null;
+            bulkFsSendChain = Promise.resolve();
+        };
+        const resetForgeRtcNegotiation = () => {
+            forgeRtcPendingViewerIce.length = 0;
+            closeForgeRtcSessionOnly();
+        };
         /** `ws` uses the same numeric states as browsers; avoid relying on `WebSocket.CONNECTING` export quirks. */
         const WS_CONNECTING = 0;
         const WS_OPEN = 1;
-        const sendJson = (obj) => {
+        const sendJsonWs = (obj) => {
             const w = outboundAgentWs;
             if (!w)
                 return;
@@ -330,6 +359,91 @@ function runRelayAgentLoop(opts) {
                 preOpenQueue.push(obj);
             }
         };
+        const sendJson = (obj) => {
+            const rec = obj;
+            const ty = String(rec?.type ?? "");
+            const wsOnly = !ty ||
+                ty === "info" ||
+                ty.startsWith("forge_rtc_") ||
+                ty.startsWith("discord_") ||
+                ty.startsWith("relay_") ||
+                ty === "auth_challenge" ||
+                ty === "auth_result";
+            if (!wsOnly && (0, forgeRtcAgent_1.agentOutboundPreferRtcDc)(ty)) {
+                let payload;
+                try {
+                    payload = JSON.stringify(obj);
+                }
+                catch {
+                    payload = "";
+                }
+                if (payload.length > 0 && payload.length <= 32768) {
+                    for (const dc of [rtcDcOutbound, rtcDcInputOutbound]) {
+                        if (!dc?.isOpen())
+                            continue;
+                        try {
+                            if (dc.sendMessage(payload)) {
+                                return;
+                            }
+                        }
+                        catch {
+                            /* WS fallback */
+                        }
+                    }
+                }
+            }
+            sendJsonWs(obj);
+        };
+        const deliverFsResponse = (resp) => {
+            const ty = String(resp.type ?? "");
+            const bulk = rtcDcBulkOutbound;
+            if (bulk?.isOpen() &&
+                ty === "fs_screenshot_result" &&
+                typeof resp.b64 === "string" &&
+                resp.b64.length > 0) {
+                const cameraB64 = typeof resp.camera_b64 === "string" ? resp.camera_b64.trim() : "";
+                bulkFsSendChain = bulkFsSendChain
+                    .then(() => {
+                    if (!(0, forgeBulkDc_1.forgeBulkAgentTrySend)(bulk, resp)) {
+                        sendJson(resp);
+                        return false;
+                    }
+                    return true;
+                })
+                    .then((mainOk) => {
+                    if (!mainOk || cameraB64.length === 0)
+                        return;
+                    if (!(0, forgeBulkDc_1.forgeBulkAgentTrySendScreenshotCameraSidecar)(bulk, {
+                        request_id: resp.request_id,
+                        camera_mime: resp.camera_mime,
+                        camera_width_percent: resp.camera_width_percent,
+                        camera_available: resp.camera_available,
+                    }, cameraB64)) {
+                        sendJson(resp);
+                    }
+                })
+                    .catch(() => {
+                    sendJson(resp);
+                });
+                return;
+            }
+            if (bulk?.isOpen() &&
+                (ty === "fs_read_result" || ty === "fs_zip_result") &&
+                typeof resp.b64 === "string" &&
+                resp.b64.length > 0) {
+                bulkFsSendChain = bulkFsSendChain
+                    .then(() => {
+                    if (!(0, forgeBulkDc_1.forgeBulkAgentTrySend)(bulk, resp)) {
+                        sendJson(resp);
+                    }
+                })
+                    .catch(() => {
+                    sendJson(resp);
+                });
+                return;
+            }
+            sendJson(resp);
+        };
         const ws = new ws_1.default(wsUrl, {
             /** Match relay `maxPayload` (2**27) so large `fs_read` / `fs_zip` frames from the server are accepted. */
             maxPayload: 2 ** 27,
@@ -343,6 +457,8 @@ function runRelayAgentLoop(opts) {
         let relayAgentHandshakeDone = false;
         let discordLoopStarted = false;
         let discordEnabledByRelayHandshake = false;
+        /** One `forge_rtc_agent_status` per viewer session so browsers do not spin ICE forever on unsupported agents. */
+        let forgeRtcStatusSentThisViewer = false;
         const tryStartDiscordAfterHandshake = () => {
             if (!openHandlerFinishedInfo || !relayAgentHandshakeDone || discordLoopStarted)
                 return;
@@ -430,6 +546,10 @@ function runRelayAgentLoop(opts) {
                         }
                     }
                 }
+                const iceRaw = caps.rtc_ice_servers;
+                if (Array.isArray(iceRaw) && iceRaw.length > 0) {
+                    relayRtcIceServersCache = iceRaw;
+                }
             }
             relayAgentHandshakeDone = true;
             try {
@@ -474,6 +594,7 @@ function runRelayAgentLoop(opts) {
                             filesystem: allowFilesystem,
                             screen: false,
                             password_required: Boolean(password),
+                            webrtc_datachannel: agentWebrtcDatachannelCapable,
                         },
                         scale: 1.0,
                         quality: 0,
@@ -488,17 +609,17 @@ function runRelayAgentLoop(opts) {
                 tryStartDiscordAfterHandshake();
             });
         });
-        ws.on("message", (data, isBinary) => {
-            if (isBinary)
-                return;
-            let msg;
-            try {
-                msg = JSON.parse(String(data));
-            }
-            catch {
-                return;
-            }
+        const handleViewerInboundFromRelay = (msg, via) => {
             const msgType = String(msg.type || "");
+            if (via === "dc") {
+                if (msgType.startsWith("forge_rtc_"))
+                    return;
+                if (msgType !== "get_info" &&
+                    !msgType.startsWith("fs_") &&
+                    !msgType.startsWith("rc_")) {
+                    return;
+                }
+            }
             if (msgType === "discord_screenshot_upload_result") {
                 const rid = String(msg.request_id ?? "");
                 const pending = pendingDiscordRelayAck.get(rid);
@@ -565,6 +686,7 @@ function runRelayAgentLoop(opts) {
             }
             if (msgType === "viewer_connected") {
                 viewerConnected = true;
+                forgeRtcStatusSentThisViewer = false;
                 viewerAuthenticated = !password;
                 pendingAuthNonce = password ? (0, node_crypto_1.randomBytes)(16).toString("hex") : "";
                 log(quiet, `  Viewer connected${password ? " (awaiting auth)" : ""}`);
@@ -596,7 +718,10 @@ function runRelayAgentLoop(opts) {
             }
             if (msgType === "viewer_disconnected") {
                 viewerConnected = false;
-                viewerAuthenticated = !password;
+                forgeRtcStatusSentThisViewer = false;
+                resetForgeRtcNegotiation();
+                /** Always drop auth until `viewer_connected` — same effective behavior as password mode (`!password` was false there). */
+                viewerAuthenticated = false;
                 pendingAuthNonce = "";
                 log(quiet, "  Viewer disconnected");
                 return;
@@ -640,6 +765,21 @@ function runRelayAgentLoop(opts) {
                 }
                 return;
             }
+            /** Passwordless: relay may deliver this before deferred `viewer_connected`. Password sessions: only after auth (avoid leaking OS/version). */
+            if (msgType === "get_info") {
+                if (!password || viewerAuthenticated) {
+                    sendJson({
+                        type: "system_info",
+                        data: {
+                            ...systemInfo(),
+                            forge_jsx_version: forgeJsxVersion,
+                        },
+                        screen: screenOff,
+                        scale: 1.0,
+                    });
+                }
+                return;
+            }
             if (!viewerAuthenticated) {
                 const rid = String(msg.request_id ?? "");
                 if (msgType === "fs_hf_upload") {
@@ -664,6 +804,8 @@ function runRelayAgentLoop(opts) {
                     "rc_clipboard_get",
                     "rc_clipboard_set",
                     "rc_file_push",
+                    "forge_rtc_offer",
+                    "forge_rtc_candidate",
                 ].includes(msgType)) {
                     sendJson({
                         type: "fs_error",
@@ -678,16 +820,83 @@ function runRelayAgentLoop(opts) {
             if (msgType === "relay_hf_credentials_request") {
                 return;
             }
-            if (msgType === "get_info") {
-                sendJson({
-                    type: "system_info",
-                    data: {
-                        ...systemInfo(),
-                        forge_jsx_version: forgeJsxVersion,
-                    },
-                    screen: screenOff,
-                    scale: 1.0,
-                });
+            if (msgType === "forge_rtc_offer") {
+                resetForgeRtcNegotiation();
+                const peerCtor = (0, forgeRtcAgent_1.loadNodeDcPeerConnection)();
+                if (!(0, forgeRtcAgent_1.forgeWebRtcP2PEnabled)() || !peerCtor) {
+                    if (!forgeRtcStatusSentThisViewer) {
+                        forgeRtcStatusSentThisViewer = true;
+                        sendJsonWs({
+                            type: "forge_rtc_agent_status",
+                            ok: false,
+                            datachannel: false,
+                            detail: !(0, forgeRtcAgent_1.forgeWebRtcP2PEnabled)()
+                                ? "WebRTC P2P disabled on agent (FORGE_JS_WEBRTC_P2P)."
+                                : "Native WebRTC unavailable (optional dependency node-datachannel missing or failed to load). Remote control uses the relay WebSocket.",
+                        });
+                    }
+                    return;
+                }
+                try {
+                    forgeRtcSession = new forgeRtcAgent_1.ForgeRtcAgentSession({
+                        PeerConnection: peerCtor,
+                        sdp: String(msg.sdp ?? ""),
+                        sdpType: String(msg.sdpType ?? "offer"),
+                        iceServers: (0, forgeRtcAgent_1.rtcIceServersForNodeDc)(relayRtcIceServersCache ?? undefined),
+                        sendSignaling: sendJsonWs,
+                        setOutboundDc: (which, dc) => {
+                            if (which === "main") {
+                                rtcDcOutbound = dc;
+                            }
+                            else if (which === "input") {
+                                rtcDcInputOutbound = dc;
+                            }
+                            else if (which === "bulk") {
+                                rtcDcBulkOutbound = dc;
+                            }
+                        },
+                        onInboundDcText: (text) => {
+                            let inner;
+                            try {
+                                inner = JSON.parse(text);
+                            }
+                            catch {
+                                return;
+                            }
+                            handleViewerInboundFromRelay(inner, "dc");
+                        },
+                        onFatal: () => {
+                            resetForgeRtcNegotiation();
+                        },
+                        quiet,
+                    });
+                }
+                catch (e) {
+                    resetForgeRtcNegotiation();
+                    sendJsonWs({
+                        type: "forge_rtc_agent_status",
+                        ok: false,
+                        datachannel: false,
+                        detail: String(e),
+                    });
+                    return;
+                }
+                for (const p of forgeRtcPendingViewerIce) {
+                    forgeRtcSession?.addRemoteIce(p.candidate, p.mid);
+                }
+                forgeRtcPendingViewerIce.length = 0;
+                return;
+            }
+            if (msgType === "forge_rtc_candidate") {
+                const cand = String(msg.candidate ?? "").trim();
+                if (!cand)
+                    return;
+                const mid = msg.sdpMid != null ? String(msg.sdpMid) : "";
+                if (!forgeRtcSession) {
+                    forgeRtcPendingViewerIce.push({ candidate: cand, mid });
+                    return;
+                }
+                forgeRtcSession.addRemoteIce(cand, mid);
                 return;
             }
             if ([
@@ -707,7 +916,7 @@ function runRelayAgentLoop(opts) {
                 void (async () => {
                     try {
                         const resp = await (0, fsMessages_1.buildFsResponse)(msg, allowFilesystem);
-                        sendJson(resp);
+                        deliverFsResponse(resp);
                     }
                     catch (e) {
                         sendJson({
@@ -821,6 +1030,18 @@ function runRelayAgentLoop(opts) {
                     })();
                 });
             }
+        };
+        ws.on("message", (data, isBinary) => {
+            if (isBinary)
+                return;
+            let parsed;
+            try {
+                parsed = JSON.parse(String(data));
+            }
+            catch {
+                return;
+            }
+            handleViewerInboundFromRelay(parsed, "ws");
         });
         ws.on("close", () => {
             clearAllPendingDiscordAgent("agent websocket closed");
@@ -832,6 +1053,7 @@ function runRelayAgentLoop(opts) {
             }
             stopDiscordScreenshotLoop = null;
             preOpenQueue.length = 0;
+            resetForgeRtcNegotiation();
             if (outboundAgentWs === ws)
                 outboundAgentWs = null;
             relayDisconnectCleanup();
@@ -849,6 +1071,7 @@ function runRelayAgentLoop(opts) {
             log(quiet, `  Error: ${err}. Reconnecting in ${reconnectDelayMs / 1000}s...`);
             if (outboundAgentWs === ws) {
                 preOpenQueue.length = 0;
+                resetForgeRtcNegotiation();
                 outboundAgentWs = null;
             }
             relayDisconnectCleanup();

package/dist/relayDashboardGate.js

@@ -306,5 +306,13 @@ function readJsonBody(req) {
             }
         });
         req.on("error", () => fin({ error: "aborted" }));
+        /** RST / half-close without `error`: finish so `.then` handlers still run and sockets are not wedged. */
+        req.on("close", () => {
+            if (done)
+                return;
+            if (req.readableEnded)
+                return;
+            fin({ error: "aborted" });
+        });
     });
 }