@newhomestar/sdk 0.7.8 → 0.7.10

package/dist/events.js

@@ -31,6 +31,7 @@
 //  NOVA_SERVICE_SLUG        — Stamped as source_service on every event
 // =====================================================================
 import dotenv from 'dotenv';
+import { Agent as UndiciAgent } from 'undici';
 // Load .env.local in dev if NOVA_EVENTS_SERVICE_URL not already set
 if (!process.env.NOVA_EVENTS_SERVICE_URL) {
     dotenv.config({ path: '.env.local', override: false });
@@ -655,6 +656,14 @@ export function startInboundConsumer(db, options) {
     }
     const abort = new AbortController();
     let reconnectAttempt = 0;
+    /** Log nested error causes for rich diagnostics (undici stores ECONNREFUSED etc. in err.cause) */
+    function _logErrorCause(err, depth = 0) {
+        if (!err?.cause || depth > 3)
+            return;
+        const indent = '   ' + ' └─'.repeat(depth + 1) + ' ';
+        console.error(`[nova/events] ${indent}cause: ${String(err.cause).slice(0, 500)}`);
+        _logErrorCause(err.cause, depth + 1);
+    }
     /** Derive the event topic from a raw PGMQ message payload */
     function _deriveEventType(payload) {
         if (typeof payload.topic === 'string')
@@ -774,24 +783,45 @@ export function startInboundConsumer(db, options) {
             reader.releaseLock();
         }
     }
+    // Dedicated undici Agent for SSE connections.
+    // Node.js's built-in fetch (undici) has a default bodyTimeout of 300s (5 minutes)
+    // which kills long-lived SSE streams as if the response body "stalled".
+    // Setting bodyTimeout: 0 disables this limit for the stream connection.
+    // headersTimeout: 120_000 guards against slow initial connections (was 30s — too short
+    // for containers that may take time to establish TCP to the Events Service).
+    const sseAgent = new UndiciAgent({
+        bodyTimeout: 0,
+        headersTimeout: 120_000,
+        keepAliveTimeout: 120_000,
+        keepAliveMaxTimeout: 600_000,
+    });
     /** Main loop: connect, consume, reconnect */
     async function _connect() {
+        // Log config once on startup so container logs show what we're connecting to
+        const tokenSuffix = serviceToken ? `***${serviceToken.slice(-4)}` : 'MISSING';
+        console.log(`[nova/events] SSE consumer starting — url=${eventsUrl} ` +
+            `token=${tokenSuffix} queue=${queueName} vt=${vt}s headersTimeout=120s`);
         while (!abort.signal.aborted) {
             const streamUrl = `${eventsUrl}/events/queue/stream?queue=${encodeURIComponent(queueName)}&vt=${vt}`;
+            const connectStart = Date.now();
             try {
-                console.log(`[nova/events] Connecting to SSE queue "${queueName}" ` +
-                    `(attempt ${reconnectAttempt + 1})…`);
+                console.log(`[nova/events] Connecting to SSE stream (attempt ${reconnectAttempt + 1}): ${streamUrl}`);
                 const response = await fetch(streamUrl, {
                     headers: { 'Authorization': `Bearer ${serviceToken}`, 'Accept': 'text/event-stream' },
                     signal: abort.signal,
+                    // @ts-ignore — undici-specific dispatcher: disables the 5-minute bodyTimeout
+                    // that kills SSE streams. Standard fetch API does not expose this option,
+                    // but Node.js's undici-powered fetch accepts it.
+                    dispatcher: sseAgent,
                 });
                 if (!response.ok) {
                     const text = await response.text().catch(() => '');
                     throw new Error(`SSE connect failed: HTTP ${response.status} — ${text.slice(0, 200)}`);
                 }
                 // Successfully connected — reset reconnect counter
+                const ttfb = Date.now() - connectStart;
                 reconnectAttempt = 0;
-                console.log(`[nova/events] SSE consumer connected to queue "${queueName}"`);
+                console.log(`[nova/events] SSE consumer connected to queue "${queueName}" (TTFB: ${ttfb}ms)`);
                 // Consume the stream; catch stream-level errors separately from
                 // connection-level errors so they don't trigger exponential backoff.
                 // A stream dying mid-flight (e.g. proxy timeout) is a normal lifecycle
@@ -805,7 +835,9 @@ export function startInboundConsumer(db, options) {
                     const isAbortError = streamErr?.name === 'AbortError' || streamErr?.code === 20;
                     if (isAbortError)
                         return;
-                    console.error(`[nova/events] SSE stream error for queue "${queueName}":`, String(streamErr).slice(0, 300));
+                    const elapsed = Date.now() - connectStart;
+                    console.error(`[nova/events] SSE stream error for queue "${queueName}" (after ${elapsed}ms):`, String(streamErr).slice(0, 500));
+                    _logErrorCause(streamErr);
                 }
                 if (abort.signal.aborted) {
                     console.log(`[nova/events] SSE consumer for queue "${queueName}" shut down gracefully`);
@@ -813,7 +845,9 @@ export function startInboundConsumer(db, options) {
                 }
                 // Stream ended (normal close OR proxy timeout). The connection WAS
                 // established, so no exponential backoff — reconnect in a fixed 1s.
-                console.log(`[nova/events] SSE stream for queue "${queueName}" closed — reconnecting in 1000ms…`);
+                const totalDuration = Date.now() - connectStart;
+                console.log(`[nova/events] SSE stream for queue "${queueName}" closed after ${totalDuration}ms — ` +
+                    `reconnecting in 1000ms…`);
                 await new Promise((resolve) => {
                     const t = setTimeout(resolve, 1_000);
                     abort.signal.addEventListener('abort', () => { clearTimeout(t); resolve(); }, { once: true });
@@ -828,7 +862,9 @@ export function startInboundConsumer(db, options) {
                 const isAbortError = err?.name === 'AbortError' || err?.code === 20;
                 if (isAbortError)
                     return;
-                console.error(`[nova/events] SSE connection error for queue "${queueName}":`, String(err).slice(0, 300));
+                const elapsed = Date.now() - connectStart;
+                console.error(`[nova/events] SSE connection error for queue "${queueName}" (failed after ${elapsed}ms):`, String(err).slice(0, 500));
+                _logErrorCause(err);
             }
             // Exponential backoff only for connection-level failures (fetch threw or
             // server returned non-200). Stream-level drops use the fixed 1s above.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@newhomestar/sdk",
-  "version": "0.7.8",
+  "version": "0.7.10",
   "description": "Type-safe SDK for building Nova pipelines (workers & functions)",
   "homepage": "https://github.com/newhomestar/nova-node-sdk#readme",
   "bugs": {
@@ -44,6 +44,7 @@
     "dotenv": "^16.4.3",
     "express": "^4.18.2",
     "express-oauth2-jwt-bearer": "^1.7.4",
+    "undici": "^7.24.4",
     "yaml": "^2.7.1"
   },
   "peerDependencies": {