vskill 0.5.142 → 0.5.143

package/agents.json

@@ -1,6 +1,6 @@
 {
   "version": 1,
-  "generatedAt": "2026-04-26T20:37:24.647Z",
+  "generatedAt": "2026-04-26T21:22:47.298Z",
   "agentPrefixes": [
     ".adal",
     ".agent",

package/dist/eval-server/api-routes.d.ts

@@ -43,6 +43,24 @@ export interface AgentsResponse {
         consumers: string[];
     }>;
 }
+export interface PlatformHealth {
+    degraded: boolean;
+    reason: string | null;
+    statsAgeMs: number;
+    oldestActiveAgeMs: number;
+}
+/** Test hook — clear the 60 s cache so the next computePlatformHealth re-fetches. */
+export declare function resetPlatformHealthCache(): void;
+/**
+ * 0778 — Compute platform health by probing two upstream verified-skill.com
+ * endpoints. Bounded by a 1500 ms timeout. Errors of any kind return the
+ * safe fallback so the studio never amber-flashes on user wifi blips.
+ */
+export declare function computePlatformHealth(opts?: {
+    fetchImpl?: typeof fetch;
+    /** Test-only: bypass the in-memory cache. */
+    skipCache?: boolean;
+}): Promise<PlatformHealth>;
 /** Test hook — clear the 30 s cache so the next buildAgentsResponse() re-scans. */
 export declare function resetAgentPresenceCache(): void;
 interface BuildAgentsOptions {

package/dist/eval-server/api-routes.js

@@ -66,6 +66,81 @@ export function buildInstalledAgentsResponse(detectedAgents) {
 }
 let agentPresenceCache = null;
 const AGENT_PRESENCE_CACHE_TTL = 30_000;
+const PLATFORM_HEALTH_CACHE_TTL = 60_000;
+const PLATFORM_HEALTH_TIMEOUT_MS = 1500;
+const PLATFORM_HEARTBEAT_STALE_MS = 30 * 60 * 1000;
+const PLATFORM_OLDEST_ACTIVE_STALE_MS = 24 * 60 * 60 * 1000;
+let platformHealthCache = null;
+/** Test hook — clear the 60 s cache so the next computePlatformHealth re-fetches. */
+export function resetPlatformHealthCache() {
+    platformHealthCache = null;
+}
+function formatDuration(ms) {
+    if (ms < 60_000)
+        return `${Math.round(ms / 1000)}s`;
+    if (ms < 3_600_000)
+        return `${Math.round(ms / 60_000)}m`;
+    if (ms < 86_400_000) {
+        const h = Math.floor(ms / 3_600_000);
+        const m = Math.round((ms % 3_600_000) / 60_000);
+        return m > 0 ? `${h}h ${m}m` : `${h}h`;
+    }
+    return `${Math.round(ms / 86_400_000)}d`;
+}
+const SAFE_FALLBACK = {
+    degraded: false,
+    reason: "platform-unreachable",
+    statsAgeMs: 0,
+    oldestActiveAgeMs: 0,
+};
+/**
+ * 0778 — Compute platform health by probing two upstream verified-skill.com
+ * endpoints. Bounded by a 1500 ms timeout. Errors of any kind return the
+ * safe fallback so the studio never amber-flashes on user wifi blips.
+ */
+export async function computePlatformHealth(opts = {}) {
+    const f = opts.fetchImpl ?? fetch;
+    const now = Date.now();
+    if (!opts.skipCache &&
+        platformHealthCache &&
+        now - platformHealthCache.ts < PLATFORM_HEALTH_CACHE_TTL) {
+        return platformHealthCache.data;
+    }
+    let result;
+    try {
+        const signal = AbortSignal.timeout(PLATFORM_HEALTH_TIMEOUT_MS);
+        const [statsRes, queueRes] = await Promise.all([
+            f("https://verified-skill.com/api/v1/submissions/stats", { signal }),
+            f("https://verified-skill.com/api/v1/queue/health", { signal }),
+        ]);
+        if (!statsRes.ok || !queueRes.ok)
+            throw new Error("upstream non-2xx");
+        const stats = (await statsRes.json());
+        const queue = (await queueRes.json());
+        const statsAgeMs = Number(queue.statsAge?.ageMs ?? 0);
+        const oldestActiveAgeMs = Number(queue.oldestActive?.ageMs ?? 0);
+        const reasons = [];
+        if (stats.degraded === true)
+            reasons.push("platform reports degraded");
+        if (statsAgeMs > PLATFORM_HEARTBEAT_STALE_MS) {
+            reasons.push(`heartbeat stale ${formatDuration(statsAgeMs)}`);
+        }
+        if (oldestActiveAgeMs > PLATFORM_OLDEST_ACTIVE_STALE_MS) {
+            reasons.push(`oldest active submission ${formatDuration(oldestActiveAgeMs)}`);
+        }
+        result = {
+            degraded: reasons.length > 0,
+            reason: reasons.length > 0 ? reasons.join("; ") : null,
+            statsAgeMs,
+            oldestActiveAgeMs,
+        };
+    }
+    catch {
+        result = { ...SAFE_FALLBACK };
+    }
+    platformHealthCache = { data: result, ts: now };
+    return result;
+}
 /** Test hook — clear the 30 s cache so the next buildAgentsResponse() re-scans. */
 export function resetAgentPresenceCache() {
     agentPresenceCache = null;
@@ -1654,6 +1729,17 @@ export function registerRoutes(router, root, projectName) {
     // `localSkill` so the Studio's bell dropdown can render tooltips and route
     // smart clicks via `revealSkill` instead of guessing local fs identifiers
     // from the canonical platform name.
+    // 0778 — Platform health proxy. Returns a small JSON shape the bell uses
+    // to surface upstream-degraded state. NEVER throws; failure → safe fallback.
+    router.get("/api/platform/health", async (req, res) => {
+        try {
+            const data = await computePlatformHealth();
+            sendJson(res, data, 200, req);
+        }
+        catch {
+            sendJson(res, { ...SAFE_FALLBACK }, 200, req);
+        }
+    });
     router.get("/api/skills/updates", async (req, res) => {
         try {
             const { getOutdatedJson } = await import("../commands/outdated.js");