@camstack/server 1.2.665 → 1.2.667

package/CHANGELOG.md

@@ -7,11 +7,24 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [1.2.667] - 2026-10-28
+
+### Changed
+
+- Rebuilt against updated dependencies.
+
+## [1.2.666] - 2026-10-28
+
+### Changed
+
+- The hub raises a critical alert when npm or Hugging Face stays unreachable, and resolves it on the next success
+
 ## [1.2.665] - 2026-10-28
 
 ### Changed
 
 - A shared events link can open a track's detail page, and shared links now use the operator's colour palette
+- The hub raises a critical alert when npm cannot be reached (addon and server updates are paused) and resolves it when the registry answers again
 
 ## [1.2.664] - 2026-10-27
 

package/dist/core/addon/addon-package.service.js

@@ -213,6 +213,7 @@ class AddonPackageService {
      * the scheduler's dependencies back.
      */
     updateCheckRescheduler = null;
+    npmReachability = null;
     // -- Timing constants -----------------------------------------------------
     // Short TTL — operators expect to see freshly-published versions
     // within minutes of `npm publish`, not hours. The Addons page kicks
@@ -1439,6 +1440,10 @@ class AddonPackageService {
     // =========================================================================
     // Auto-update settings
     // =========================================================================
+    /** The hub's npm sweep reports whether the registry answered at all (alert on an outage). */
+    setNpmReachabilityObserver(observer) {
+        this.npmReachability = observer;
+    }
     /**
      * Register the availability poller's re-arm hook. Called once at boot so a
      * `setAutoUpdateSettings` write takes effect without a restart.
@@ -1695,8 +1700,11 @@ class AddonPackageService {
         const addonsDir = this.resolveAddonsDir();
         const updates = [];
         let failures = 0;
+        let lookups = 0;
+        let reached = 0;
+        let lastLookupError = '';
         if (!fs.existsSync(addonsDir))
-            return { updates, failures };
+            return { updates, failures, lookups, reached };
         // Collect all package.json paths -- handles both flat and scoped layouts
         const pkgJsonPaths = [];
         const topDirs = fs
@@ -1743,6 +1751,11 @@ class AddonPackageService {
                         continue;
                 }
                 const lookup = await this.lookupLatestVersion(name);
+                lookups += 1;
+                if (lookup.ok)
+                    reached += 1;
+                else
+                    lastLookupError = lookup.error;
                 if (!lookup.ok) {
                     failures += 1;
                     this.logger.warn('Registry lookup failed for installed addon package', {
@@ -1772,7 +1785,21 @@ class AddonPackageService {
                 });
             }
         }
-        return { updates, failures };
+        this.reportNpmReachability(lookups, reached, lastLookupError);
+        return { updates, failures, lookups, reached };
+    }
+    /**
+     * One sweep is one probe: npm is unreachable only when lookups were made and
+     * NONE got an answer. A sweep with no lookups says nothing either way.
+     */
+    reportNpmReachability(lookups, reached, lastError) {
+        const observer = this.npmReachability;
+        if (observer === null || lookups === 0)
+            return;
+        const report = reached > 0 ? observer.reached() : observer.failed(lastError);
+        void report.catch((error) => {
+            this.logger.warn('npm reachability report failed', { meta: { error: (0, types_2.errMsg)(error) } });
+        });
     }
     // =========================================================================
     // Private: npm registry helpers

package/dist/core/updates/registry-reachability.js

@@ -0,0 +1,144 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistryReachabilityTracker = exports.REGISTRY_UNREACHABLE_CATEGORY = exports.REGISTRY_UNREACHABLE_MIN_FAILURE_MS = exports.REGISTRY_UNREACHABLE_MIN_FAILURES = void 0;
+exports.registryUnreachableAlertId = registryUnreachableAlertId;
+exports.buildRegistryUnreachableAlert = buildRegistryUnreachableAlert;
+const types_1 = require("@camstack/types");
+/** Consecutive failed probes before an episode may open. */
+exports.REGISTRY_UNREACHABLE_MIN_FAILURES = 2;
+/** The first failure must be at least this old when the threshold is met. */
+exports.REGISTRY_UNREACHABLE_MIN_FAILURE_MS = 10 * 60_000;
+exports.REGISTRY_UNREACHABLE_CATEGORY = 'registry.unreachable';
+const EPISODE_KEY = 'registry-unreachable';
+function registryUnreachableAlertId(registry) {
+    return `registry-unreachable:${registry}`;
+}
+const WORDS = {
+    npm: {
+        name: 'npm',
+        impact: 'Addon and server updates are paused',
+    },
+    huggingface: {
+        name: 'Hugging Face',
+        impact: 'Model downloads are failing',
+    },
+};
+function buildRegistryUnreachableAlert(registry, reason, now) {
+    const words = WORDS[registry];
+    return {
+        id: registryUnreachableAlertId(registry),
+        category: exports.REGISTRY_UNREACHABLE_CATEGORY,
+        severity: 'critical',
+        title: `${words.name} cannot be reached`,
+        message: `CamStack cannot reach ${words.name}. ${words.impact} until the connection is back (${reason}). Check the hub's internet access, DNS and proxy.`,
+        status: 'active',
+        read: false,
+        createdAt: now,
+        updatedAt: now,
+        source: { type: 'registry', id: registry },
+        metadata: { episodeKey: EPISODE_KEY, registry },
+    };
+}
+class RegistryReachabilityTracker {
+    #logger;
+    #getAlerts;
+    #now;
+    #state = new Map();
+    constructor(options) {
+        this.#logger = options.logger;
+        this.#getAlerts = options.getAlerts;
+        this.#now = options.now ?? Date.now;
+    }
+    /** A probe could not reach the registry. Idempotent per call: it only counts. */
+    async failed(registry, reason) {
+        const now = this.#now();
+        const state = this.#stateOf(registry);
+        if (state.failures === 0)
+            state.firstFailureAt = now;
+        state.failures += 1;
+        this.#logger.warn(`${WORDS[registry].name} unreachable`, {
+            meta: { registry, consecutiveFailures: state.failures, reason },
+        });
+        if (state.alerted)
+            return;
+        if (state.failures < exports.REGISTRY_UNREACHABLE_MIN_FAILURES)
+            return;
+        if (now - state.firstFailureAt < exports.REGISTRY_UNREACHABLE_MIN_FAILURE_MS)
+            return;
+        await this.#open(registry, state, reason, now);
+    }
+    /** A probe reached the registry (any answer below 5xx). Resolves an open episode. */
+    async reached(registry) {
+        const state = this.#stateOf(registry);
+        const wasAlerted = state.alerted;
+        const firstSuccess = !state.reconciled;
+        state.failures = 0;
+        state.firstFailureAt = 0;
+        state.alerted = false;
+        state.reconciled = true;
+        // First success after boot also closes an episode a previous run left open
+        // (resolving one that is not there is a no-op in the alert centre).
+        if (!wasAlerted && !firstSuccess)
+            return;
+        await this.#resolve(registry, wasAlerted ? 'registry reachable again' : 'startup reconcile');
+    }
+    #stateOf(registry) {
+        const existing = this.#state.get(registry);
+        if (existing !== undefined)
+            return existing;
+        const created = {
+            failures: 0,
+            firstFailureAt: 0,
+            alerted: false,
+            reconciled: false,
+        };
+        this.#state.set(registry, created);
+        return created;
+    }
+    async #open(registry, state, reason, now) {
+        const alerts = this.#getAlerts();
+        if (alerts === undefined) {
+            this.#logger.warn('Registry unreachable alert skipped — alerts capability missing', {
+                meta: { registry },
+            });
+            return;
+        }
+        try {
+            await alerts.emit(buildRegistryUnreachableAlert(registry, reason, now));
+            state.alerted = true;
+            this.#logger.warn(`${WORDS[registry].name} unreachable — alert raised`, {
+                meta: { registry, consecutiveFailures: state.failures },
+            });
+        }
+        catch (error) {
+            // Not alerted: the next failed probe tries again.
+            this.#logger.warn('Registry unreachable alert emit failed', {
+                meta: { registry, error: (0, types_1.errMsg)(error) },
+            });
+        }
+    }
+    async #resolve(registry, why) {
+        const alerts = this.#getAlerts();
+        if (alerts === undefined) {
+            this.#logger.debug('Registry alert not resolved — alerts capability missing', {
+                meta: { registry, why },
+            });
+            return;
+        }
+        try {
+            await alerts.update({
+                alertId: registryUnreachableAlertId(registry),
+                patch: { status: 'completed', read: true },
+            });
+            this.#logger.info(`${WORDS[registry].name} reachable — alert resolved`, {
+                meta: { registry, why },
+            });
+        }
+        catch (error) {
+            this.#logger.debug('Registry alert resolve skipped', {
+                meta: { registry, why, error: (0, types_1.errMsg)(error) },
+            });
+        }
+    }
+}
+exports.RegistryReachabilityTracker = RegistryReachabilityTracker;

package/dist/manual-boot.js

@@ -82,6 +82,7 @@ const topology_emitter_service_1 = require("./core/topology/topology-emitter.ser
 const update_availability_emitter_js_1 = require("./core/update-availability-emitter.js");
 const update_availability_store_js_1 = require("./core/update-availability-store.js");
 const agent_installed_packages_js_1 = require("./core/updates/agent-installed-packages.js");
+const registry_reachability_js_1 = require("./core/updates/registry-reachability.js");
 const update_check_scheduler_js_1 = require("./core/updates/update-check-scheduler.js");
 const wrapper_update_checker_js_1 = require("./core/updates/wrapper-update-checker.js");
 // ---------------------------------------------------------------------------
@@ -319,6 +320,23 @@ async function bootManual(opts) {
             return types_1.ServerPackageStatusSchema.parse(status);
         },
     });
+    // npm / Hugging Face unreachable → one critical alert episode. No clock of
+    // its own: npm is heard from the sweep below, Hugging Face from the model
+    // downloads this process makes anyway.
+    const registryReachability = new registry_reachability_js_1.RegistryReachabilityTracker({
+        logger: updateCheckLogger,
+        getAlerts: () => addonRegistryService.getCapabilityRegistry().getSingleton('alerts') ??
+            undefined,
+    });
+    addonPackageService.setNpmReachabilityObserver({
+        reached: () => registryReachability.reached('npm'),
+        failed: (reason) => registryReachability.failed('npm', reason),
+    });
+    (0, system_1.setHuggingFaceReachabilityObserver)((outcome) => {
+        void (outcome.reached
+            ? registryReachability.reached('huggingface')
+            : registryReachability.failed('huggingface', outcome.detail));
+    });
     const updateCheckScheduler = new update_check_scheduler_js_1.UpdateCheckScheduler({
         logger: updateCheckLogger,
         getIntervalSeconds: () => addonPackageService.getAutoUpdateSettings().updateCheckIntervalSeconds,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@camstack/server",
-  "version": "1.2.665",
+  "version": "1.2.667",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -49,19 +49,19 @@
     ]
   },
   "dependencies": {
-    "@camstack/addon-admin-ui": "1.2.498",
+    "@camstack/addon-admin-ui": "1.2.500",
     "@camstack/addon-agent-ui": "1.2.283",
     "@camstack/addon-auth": "1.2.170",
     "@camstack/addon-benchmark": "1.2.284",
     "@camstack/addon-decoder-nodeav": "1.2.144",
     "@camstack/addon-notifiers": "1.2.623",
     "@camstack/addon-pipeline": "1.2.631",
-    "@camstack/addon-pipeline-orchestrator": "1.2.633",
-    "@camstack/addon-post-analysis": "1.2.645",
+    "@camstack/addon-pipeline-orchestrator": "1.2.634",
+    "@camstack/addon-post-analysis": "1.2.646",
     "@camstack/develop": "0.1.38",
     "@camstack/sdk": "1.2.154",
-    "@camstack/system": "1.2.502",
-    "@camstack/types": "1.2.432",
+    "@camstack/system": "1.2.503",
+    "@camstack/types": "1.2.433",
     "@camstack/ui-library": "1.2.341",
     "@fastify/compress": "^9.0.0",
     "@fastify/cookie": "^11.0.2",