fix(node): suppress OTA activity while the node is offline

[Apollon77]

Minor hardening in SoftwareUpdateManager.

The update paths guarded only against disposal (internal.closed), so a node that had gone offline but was not yet disposed kept doing update work: collecting per-peer update info, downloading images, walking the consent list, firing queued updates, and reacting to OTA status changes.

The guard now covers both states — raised on lifecycle.goingOffline, lowered again on lifecycle.online so a node that comes back resumes normally. internal.closed is renamed to internal.suppressUpdates since it no longer means "disposed"; [Symbol.asyncDispose] still raises it, so the previous behavior is a subset.

Two gaps found in review and fixed on top:

• The flag started out lowered, so update work could still run between initialize() and the first online transition — the very window it exists to cover. It now starts raised.
• Going offline left the OtaAnnouncements instance alive. It runs its own timers and writes to peers, so it kept announcing while offline regardless of the flag. It is now closed on goingOffline along with the update-check timer; #nodeOnline already installs a fresh instance.

The queue timer is deliberately left running: #triggerQueuedUpdate returns immediately while suppressed and re-arms itself only when there is queue work, so stopping it would gain nothing and could delay a resumed queue.

Also tightens one == undefined to === undefined.

Checklist

• npm test passes (full suite, all packages)
• npm run format-verify and npm run lint pass
• npm run build -- --clean passes
• Tests added or updated — none; no new externally observable behavior beyond the lifecycle guard, and SoftwareUpdateManager has no existing unit-test harness for lifecycle transitions
• CHANGELOG updated — not applicable, internal hardening with no API change

No log file attached: this is not an issue-driven fix but a proactive hardening of the offline path.

🤖 Generated with Claude Code

[Copilot]

Pull request overview

This PR hardens the node-side OTA provider logic by suppressing SoftwareUpdateManager activity while a ServerNode is offline, resuming when it comes back online, and by clarifying intent via a rename from internal.closed to internal.suppressUpdates.

Changes:

• Add lifecycle handling for goingOffline/online to toggle OTA suppression.
• Replace internal.closed guards with internal.suppressUpdates in update paths and status handling.
• Tighten one undefined check from == undefined to === undefined.

[Copilot]

Pull request overview

Copilot reviewed 1 out of 1 changed files in this pull request and generated no new comments.

Comments suppressed due to low confidence (2)

packages/node/src/behavior/system/software-update/SoftwareUpdateManager.ts:216

• #nodeGoingOffline is a reactor on NodeLifecycle.goingOffline (an AsyncObservable awaited by Node.stop()), but it awaits announcements.close(). OtaAnnouncements.close() awaits any in-flight announcement promise, which can block the node’s offline transition until network timeouts complete. Since close() already stops timers before its internal await, you can fire-and-forget the close here (with a .catch) to stop future announcements without delaying the lifecycle transition.

        // Announcements run on their own timers and write to peers, so the suppression flag alone does not stop them.
        // #nodeOnline installs a fresh instance.
        await this.internal.announcements?.close();
        this.internal.announcements = undefined;

packages/node/src/behavior/system/software-update/SoftwareUpdateManager.ts:212

• suppressUpdates is raised on goingOffline, and queryUpdates() now returns early when suppressed, but checkForUpdates() still unconditionally runs #cleanupObsoleteUpdates() afterward (see checkForUpdates around line ~401). This means storage scans/deletions can still run while the node is offline/suppressed (e.g. if checkForUpdates() is invoked directly, or if an in-flight timer callback continues after checkForUpdateTimer.stop()). Consider adding an early if (this.internal.suppressUpdates) return; guard in checkForUpdates() (and/or at the top of #cleanupObsoleteUpdates()).

    async #nodeGoingOffline() {
        this.internal.suppressUpdates = true;
        this.internal.checkForUpdateTimer?.stop();

[mergify]

Tick the box to add this pull request to the merge queue (same as @mergifyio queue).

• Queue this pull request