forge-jsxy 1.0.78 → 1.0.80

package/dist/forgeRtcAgent.js

@@ -0,0 +1,259 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ForgeRtcAgentSession = void 0;
+exports.forgeWebRtcP2PEnabled = forgeWebRtcP2PEnabled;
+exports.agentOutboundPreferRtcDc = agentOutboundPreferRtcDc;
+exports.rtcIceServersForNodeDc = rtcIceServersForNodeDc;
+exports.loadNodeDcPeerConnection = loadNodeDcPeerConnection;
+function forgeWebRtcP2PEnabled() {
+    const raw = (process.env.FORGE_JS_WEBRTC_P2P || "1").trim().toLowerCase();
+    return !["0", "false", "no", "off"].includes(raw);
+}
+/** ICE UDP multiplexing (libdatachannel): fewer ports; often pairs better with browser bundle/mux. */
+function forgeRtcIceUdpMuxEnabled() {
+    const raw = (process.env.FORGE_JS_WEBRTC_ICE_UDP_MUX || "1").trim().toLowerCase();
+    return !["0", "false", "no", "off"].includes(raw);
+}
+/** ICE over TCP candidates when UDP is blocked (may trade latency for connectivity). */
+function forgeRtcIceTcpEnabled() {
+    const raw = (process.env.FORGE_JS_WEBRTC_ICE_TCP || "1").trim().toLowerCase();
+    return !["0", "false", "no", "off"].includes(raw);
+}
+/** Small agent→viewer JSON safe on SCTP data channels (≤ ~32k applied in relayAgent). Large/binary stays on WebSocket. */
+const AGENT_OUTBOUND_RTC_DC_TYPES = new Set([
+    "rc_input_result",
+    "rc_clipboard_set_result",
+    "rc_clipboard_get_result",
+    "fs_roots_result",
+    "fs_list_result",
+    "fs_parent_result",
+    "fs_delete_result",
+    "fs_error",
+    /** Short shell output uses DC; large stdout/stderr exceeds relayAgent 32k cap and falls back to WebSocket. */
+    "fs_shell_exec_result",
+    "fs_hf_upload_progress",
+]);
+function agentOutboundPreferRtcDc(msgType) {
+    return AGENT_OUTBOUND_RTC_DC_TYPES.has(msgType);
+}
+function rtcIceServersForNodeDc(raw) {
+    if (!raw || !Array.isArray(raw) || raw.length === 0) {
+        return ["stun:stun.l.google.com:19302"];
+    }
+    const out = [];
+    for (const entry of raw) {
+        if (typeof entry === "string") {
+            const s = entry.trim();
+            if (s)
+                out.push(s);
+            continue;
+        }
+        if (!entry || typeof entry !== "object")
+            continue;
+        const o = entry;
+        const urlsRaw = o.urls;
+        const username = typeof o.username === "string" ? o.username : "";
+        const credential = typeof o.credential === "string"
+            ? o.credential
+            : typeof o.credential === "number"
+                ? String(o.credential)
+                : "";
+        const pushUrl = (u) => {
+            const url = u.trim();
+            if (!url)
+                return;
+            const lower = url.toLowerCase();
+            if (username &&
+                credential &&
+                (lower.startsWith("turn:") || lower.startsWith("turns:"))) {
+                const rest = url.replace(/^turns?:/i, "");
+                const encU = encodeURIComponent(username);
+                const encP = encodeURIComponent(credential);
+                const prefix = lower.startsWith("turns:") ? "turns:" : "turn:";
+                out.push(`${prefix}${encU}:${encP}@${rest.replace(/^\/\//, "")}`);
+            }
+            else {
+                out.push(url);
+            }
+        };
+        if (typeof urlsRaw === "string") {
+            pushUrl(urlsRaw);
+        }
+        else if (Array.isArray(urlsRaw)) {
+            for (const u of urlsRaw) {
+                if (typeof u === "string")
+                    pushUrl(u);
+            }
+        }
+    }
+    return out.length > 0 ? out : ["stun:stun.l.google.com:19302"];
+}
+function normalizeRemoteOfferType(raw) {
+    const x = raw.trim().toLowerCase();
+    if (x === "answer")
+        return "answer";
+    return "offer";
+}
+class ForgeRtcAgentSession {
+    pc;
+    destroyed = false;
+    constructor(opts) {
+        const rtcConfig = {
+            iceServers: opts.iceServers,
+            iceTransportPolicy: "all",
+        };
+        if (forgeRtcIceUdpMuxEnabled()) {
+            rtcConfig.enableIceUdpMux = true;
+        }
+        if (forgeRtcIceTcpEnabled()) {
+            rtcConfig.enableIceTcp = true;
+        }
+        const pc = new opts.PeerConnection("forge-agent", rtcConfig);
+        this.pc = pc;
+        pc.onLocalDescription((sdp, type) => {
+            if (this.destroyed)
+                return;
+            opts.sendSignaling({
+                type: "forge_rtc_answer",
+                sdp,
+                sdpType: type,
+            });
+        });
+        pc.onLocalCandidate((candidate, mid) => {
+            if (this.destroyed || !String(candidate || "").trim())
+                return;
+            opts.sendSignaling({
+                type: "forge_rtc_agent_candidate",
+                candidate,
+                sdpMid: mid,
+            });
+        });
+        pc.onDataChannel((dc) => {
+            if (this.destroyed)
+                return;
+            const label = dc.getLabel();
+            const bindInbound = () => {
+                dc.onMessage((msg) => {
+                    if (this.destroyed)
+                        return;
+                    let text;
+                    if (typeof msg === "string") {
+                        text = msg;
+                    }
+                    else if (Buffer.isBuffer(msg)) {
+                        text = msg.toString("utf8");
+                    }
+                    else {
+                        text = Buffer.from(new Uint8Array(msg)).toString("utf8");
+                    }
+                    opts.onInboundDcText(text);
+                });
+            };
+            if (label === "forge-rc") {
+                opts.setOutboundDc("main", dc);
+                dc.onOpen(() => {
+                    if (this.destroyed)
+                        return;
+                    opts.sendSignaling({
+                        type: "forge_rtc_agent_status",
+                        ok: true,
+                        datachannel: true,
+                    });
+                });
+                dc.onClosed(() => {
+                    opts.setOutboundDc("main", null);
+                    this.close();
+                    opts.onFatal();
+                });
+                dc.onError((_err) => {
+                    opts.setOutboundDc("main", null);
+                    this.close();
+                    opts.onFatal();
+                });
+                bindInbound();
+            }
+            else if (label === "forge-rc-input") {
+                opts.setOutboundDc("input", dc);
+                dc.onClosed(() => opts.setOutboundDc("input", null));
+                dc.onError((_err) => opts.setOutboundDc("input", null));
+                bindInbound();
+            }
+            else if (label === "forge-bulk") {
+                const api = {
+                    sendMessage: (s) => dc.sendMessage(s),
+                    sendMessageBinary: (b) => dc.sendMessageBinary(b),
+                    isOpen: () => dc.isOpen(),
+                };
+                opts.setOutboundDc("bulk", api);
+                dc.onClosed(() => opts.setOutboundDc("bulk", null));
+                dc.onError((_err) => opts.setOutboundDc("bulk", null));
+                dc.onMessage(() => {
+                    /* Viewer→agent bulk not used in v1 */
+                });
+            }
+            else {
+                try {
+                    dc.close();
+                }
+                catch {
+                    /* skip */
+                }
+            }
+        });
+        try {
+            pc.setRemoteDescription(opts.sdp, normalizeRemoteOfferType(opts.sdpType));
+        }
+        catch (e) {
+            if (!opts.quiet) {
+                console.warn(`[forge-agent] WebRTC setRemoteDescription failed: ${String(e)}`);
+            }
+            opts.sendSignaling({
+                type: "forge_rtc_agent_status",
+                ok: false,
+                datachannel: false,
+                detail: `setRemoteDescription: ${String(e)}`,
+            });
+            this.close();
+            throw e;
+        }
+    }
+    addRemoteIce(candidate, mid) {
+        if (this.destroyed || !String(candidate || "").trim())
+            return;
+        try {
+            this.pc.addRemoteCandidate(candidate, mid || "");
+        }
+        catch {
+            /* ignore malformed trickle ICE */
+        }
+    }
+    close() {
+        if (this.destroyed)
+            return;
+        this.destroyed = true;
+        try {
+            this.pc.close();
+        }
+        catch {
+            /* skip */
+        }
+    }
+}
+exports.ForgeRtcAgentSession = ForgeRtcAgentSession;
+function loadNodeDcPeerConnection() {
+    try {
+        require.resolve("node-datachannel");
+    }
+    catch {
+        return null;
+    }
+    try {
+        // Optional native dependency — may be absent on some installs.
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        const m = require("node-datachannel");
+        return m.PeerConnection;
+    }
+    catch {
+        return null;
+    }
+}

package/dist/fsProtocol.d.ts

@@ -5,6 +5,13 @@ export declare const MAX_LIST_ENTRIES = 1000000;
  * (~92 MiB raw → ~123 MiB base64 + JSON, under relay `maxPayload` 2**27).
  */
 export declare const MAX_READ_BYTES: number;
+/**
+ * True when the listing directory is a bare OS filesystem root (Windows `C:\\`, POSIX `/`).
+ * User-data search narrowing applies **only** here: searching from `C:\\Users\\me` must still walk
+ * Pictures, Videos, etc., not only Desktop/Documents/Downloads intersect roots.
+ */
+export declare function fsSearchListingIsFilesystemRoot(dirResolved: string): boolean;
+export declare function fsSearchWalkAllowsCurReal(curRealNorm: string, listingDirNorm: string, listingDirResolved: string, enforceUserScope: boolean, userSubtreeRoots: string[] | null): boolean;
 export declare function allowedFsRoots(): string[];
 export declare function resolveFsPath(pathStr: string, roots: string[]): {
     path: string;
@@ -82,11 +89,19 @@ type NormalizedScreenshotOptions = {
     maxWidth: number | null;
     includeCamera: boolean;
 };
+/** Encode strategy for shrinking toward a byte ceiling (Discord vs latency-first remote thumbnails). */
+type ShrinkEncodePrefs = {
+    /**
+     * When true, ffmpeg JPEG passes scan quality low→high and keep the **largest** output still ≤ cap
+     * so Discord uploads use the-policy byte budget (~10MiB) for maximum clarity.
+     */
+    preferQualityNearCap?: boolean;
+};
 /**
  * Shrink in-memory screenshot bytes (PNG/JPEG) to at most `cap` (e.g. Discord attachment limits).
  * Jimp first, then the same temp-file + ImageMagick/ffmpeg/GDI stack as {@link shrinkScreenshotFileToMaxBytes}.
  */
-export declare function shrinkScreenshotBufferToMaxBytes(buf: Buffer, cap: number): Promise<{
+export declare function shrinkScreenshotBufferToMaxBytes(buf: Buffer, cap: number, prefs?: ShrinkEncodePrefs): Promise<{
     buffer: Buffer;
     mime: string;
 } | null>;