@evomap/evolver 1.90.0 → 2.0.0-beta.1

package/src/proxy/sync/engine.js

@@ -1,179 +0,0 @@
-'use strict';
-
-const { OutboundSync } = require('./outbound');
-const { InboundSync, DEFAULT_POLL_INTERVAL_ACTIVE, DEFAULT_POLL_INTERVAL_IDLE } = require('./inbound');
-const { AuthError } = require('../lifecycle/manager');
-
-const DEFAULT_OUTBOUND_INTERVAL = 5_000;
-const IDLE_THRESHOLD = 5 * 60_000;
-
-class SyncEngine {
-  constructor({ store, hubUrl, getHeaders, logger, onInboundReceived, onAuthError, onOutboundFlushed }) {
-    this.store = store;
-    this.hubUrl = hubUrl;
-    this.logger = logger || console;
-    this.getHeaders = getHeaders;
-    this.onInboundReceived = onInboundReceived || null;
-    this.onAuthError = onAuthError || null;
-    this.onOutboundFlushed = onOutboundFlushed || null;
-
-    this.outbound = new OutboundSync({ store, hubUrl, getHeaders, logger });
-    this.inbound = new InboundSync({ store, hubUrl, getHeaders, logger });
-
-    this._outTimer = null;
-    this._inTimer = null;
-    this._running = false;
-    this._lastActivity = Date.now();
-  }
-
-  start() {
-    if (this._running) return;
-    this._running = true;
-    this._lastActivity = Date.now();
-    this._scheduleOutbound(500);
-    this._scheduleInbound(1_000);
-    this.logger.log('[sync] engine started');
-  }
-
-  stop() {
-    this._running = false;
-    if (this._outTimer) { clearTimeout(this._outTimer); this._outTimer = null; }
-    if (this._inTimer) { clearTimeout(this._inTimer); this._inTimer = null; }
-    this.logger.log('[sync] engine stopped');
-  }
-
-  notifyNewOutbound() {
-    this._lastActivity = Date.now();
-    if (this._running && !this._outPending) {
-      if (this._outTimer) clearTimeout(this._outTimer);
-      this._scheduleOutbound(100);
-    }
-  }
-
-  _isIdle() {
-    return (Date.now() - this._lastActivity) > IDLE_THRESHOLD;
-  }
-
-  async _handleAuthError(source) {
-    this.logger.error(`[sync] auth error from ${source}, triggering re-authentication`);
-    if (typeof this.onAuthError === 'function') {
-      try { await this.onAuthError(); } catch (e) {
-        this.logger.error(`[sync] onAuthError callback failed: ${e.message}`);
-      }
-    }
-  }
-
-  _scheduleOutbound(delayMs) {
-    if (!this._running) return;
-    this._outTimer = setTimeout(async () => {
-      // Defence-in-depth: a throw from this.outbound.flush(),
-      // this.store.countPending(), or any post-flush bookkeeping used
-      // to escape the setTimeout callback. Node logs the unhandled
-      // rejection and the next setTimeout was never armed — the
-      // outbound sync loop silently died until the process restarted,
-      // while `_running` stayed true (no signal to the caller).
-      //
-      // Mirrors the heartbeat-loop fix in PR #147 (issue #544): wrap
-      // the whole tick, schedule the next iteration in `finally` so a
-      // surprise throw cannot park the loop.
-      let nextDelay = DEFAULT_OUTBOUND_INTERVAL;
-      let hubRetryAfterMs = 0;
-      try {
-        if (!this._running) return;
-        this._outPending = true;
-        try {
-          const result = await this.outbound.flush();
-          if (result.sent > 0) this._lastActivity = Date.now();
-          if (result.retryAfterMs > 0) hubRetryAfterMs = result.retryAfterMs;
-          if ((result.sent > 0 || result.dropped > 0) && typeof this.onOutboundFlushed === 'function') {
-            try { this.onOutboundFlushed(result); } catch (e) {
-              this.logger.warn?.('[sync] onOutboundFlushed callback failed:', e.message);
-            }
-          }
-        } catch (err) {
-          if (err instanceof AuthError) {
-            await this._handleAuthError('outbound');
-          } else {
-            this.logger.error(`[sync] outbound error: ${err.message}`);
-          }
-        }
-        this._outPending = false;
-        if (hubRetryAfterMs > 0) {
-          nextDelay = Math.max(1_000, hubRetryAfterMs);
-        } else {
-          try {
-            const pending = this.store.countPending({ direction: 'outbound' });
-            if (pending > 0) nextDelay = 1_000;
-          } catch (err) {
-            // countPending threw (corrupt store, FS hiccup): keep the
-            // default cadence rather than parking the loop.
-            this.logger.error(`[sync] countPending threw (non-fatal): ${err && err.message}`);
-          }
-        }
-      } catch (err) {
-        // Anything that escaped the inner blocks above. Log and let
-        // finally re-arm the timer.
-        this.logger.error(`[sync] outbound tick threw (non-fatal): ${err && err.message}`);
-        this._outPending = false;
-      } finally {
-        if (this._running) this._scheduleOutbound(nextDelay);
-      }
-    }, delayMs);
-    if (this._outTimer.unref) this._outTimer.unref();
-  }
-
-  _scheduleInbound(delayMs) {
-    if (!this._running) return;
-    this._inTimer = setTimeout(async () => {
-      // Same defence-in-depth pattern as _scheduleOutbound: a throw
-      // from inbound.pull / ackDelivered / _isIdle used to escape the
-      // setTimeout callback and silently park the inbound loop.
-      let nextDelay = DEFAULT_POLL_INTERVAL_ACTIVE;
-      let hubRetryAfterMs = 0;
-      try {
-        if (!this._running) return;
-        try {
-          const result = await this.inbound.pull();
-          if (result.retryAfterMs > 0) {
-            hubRetryAfterMs = result.retryAfterMs;
-          } else if (result.received > 0) {
-            this._lastActivity = Date.now();
-            if (typeof this.onInboundReceived === 'function') {
-              try { this.onInboundReceived(result.received); } catch (e) {
-                this.logger.warn?.('[sync] onInboundReceived callback failed:', e.message);
-              }
-            }
-          }
-          if (!hubRetryAfterMs) {
-            const ack = await this.inbound.ackDelivered();
-            if (ack.retryAfterMs > 0) hubRetryAfterMs = ack.retryAfterMs;
-          }
-        } catch (err) {
-          if (err instanceof AuthError) {
-            await this._handleAuthError('inbound');
-          } else {
-            this.logger.error(`[sync] inbound error: ${err.message}`);
-          }
-        }
-        if (hubRetryAfterMs > 0) {
-          nextDelay = Math.max(1_000, hubRetryAfterMs);
-        } else {
-          try {
-            nextDelay = this._isIdle()
-              ? DEFAULT_POLL_INTERVAL_IDLE
-              : DEFAULT_POLL_INTERVAL_ACTIVE;
-          } catch (err) {
-            this.logger.error(`[sync] _isIdle threw (non-fatal): ${err && err.message}`);
-          }
-        }
-      } catch (err) {
-        this.logger.error(`[sync] inbound tick threw (non-fatal): ${err && err.message}`);
-      } finally {
-        if (this._running) this._scheduleInbound(nextDelay);
-      }
-    }, delayMs);
-    if (this._inTimer.unref) this._inTimer.unref();
-  }
-}
-
-module.exports = { SyncEngine, DEFAULT_OUTBOUND_INTERVAL };

package/src/proxy/sync/inbound.js

@@ -1,211 +0,0 @@
-'use strict';
-
-const { PROXY_PROTOCOL_VERSION } = require('../mailbox/store');
-const { AuthError } = require('../lifecycle/manager');
-const {
-  drainHubResponse,
-  hubFetch,
-  hubUnreachableBackoffMs,
-  isHubUnreachableError,
-  readHubResponseJson,
-  readHubResponseText,
-  sanitizeHubResponseForLog,
-  throwIfHubUnreachableResponse,
-} = require('../../gep/hubFetch');
-
-const DEFAULT_POLL_INTERVAL_ACTIVE = 10_000;
-const DEFAULT_POLL_INTERVAL_IDLE = 60_000;
-
-function toInboundStoreMessage(m, channel) {
-  return {
-    id: m.id,
-    type: m.type,
-    payload: m.payload,
-    channel,
-    priority: m.priority || 'normal',
-    refId: m.ref_id,
-    expiresAt: m.expires_at,
-  };
-}
-
-class InboundSync {
-  constructor({ store, hubUrl, getHeaders, logger }) {
-    this.store = store;
-    this.hubUrl = hubUrl;
-    this.logger = logger || console;
-    this.getHeaders = getHeaders;
-    this._hubUnreachableFailures = 0;
-    this._hubUnreachableUntil = 0;
-  }
-
-  _hubUnreachableWaitMs() {
-    return Math.max(0, this._hubUnreachableUntil - Date.now());
-  }
-
-  _recordHubReachable() {
-    this._hubUnreachableFailures = 0;
-    this._hubUnreachableUntil = 0;
-  }
-
-  _recordHubUnreachable(err) {
-    this._hubUnreachableFailures += 1;
-    const retryAfterMs = hubUnreachableBackoffMs(this._hubUnreachableFailures);
-    this._hubUnreachableUntil = Date.now() + retryAfterMs;
-    this.logger.warn?.(
-      `[inbound] Hub unreachable; backing off for ${Math.ceil(retryAfterMs / 1000)}s: ` +
-        `${err && err.message || err}`
-    );
-    return retryAfterMs;
-  }
-
-  async pull(channel = 'evomap-hub', limit = 50) {
-    const waitMs = this._hubUnreachableWaitMs();
-    if (waitMs > 0) {
-      return {
-        received: 0,
-        error: 'hub_unreachable_backoff',
-        hubUnreachable: true,
-        retryAfterMs: waitMs,
-      };
-    }
-
-    const cursorKey = `${channel}:inbound_cursor`;
-    const cursor = this.store.getCursor(cursorKey);
-
-    const endpoint = `${this.hubUrl}/a2a/mailbox/inbound`;
-
-    try {
-      const senderId = this.store.getState('node_id');
-      const res = await hubFetch(endpoint, {
-        method: 'POST',
-        headers: this.getHeaders(),
-        body: JSON.stringify({ sender_id: senderId, proxy_protocol_version: PROXY_PROTOCOL_VERSION, cursor, limit }),
-        signal: AbortSignal.timeout(35_000),
-      });
-
-      await throwIfHubUnreachableResponse(res, 'inbound pull');
-      this._recordHubReachable();
-
-      if (res.status === 403 || res.status === 401) {
-        const errText = await readHubResponseText(res).catch(() => 'unknown');
-        throw new AuthError(`Hub ${res.status}: ${sanitizeHubResponseForLog(errText)}`, res.status);
-      }
-
-      if (!res.ok) {
-        const errText = await readHubResponseText(res).catch(() => 'unknown');
-        throw new Error(`Hub returned ${res.status}: ${sanitizeHubResponseForLog(errText)}`);
-      }
-
-      const data = await readHubResponseJson(res);
-      const messages = data.messages || [];
-      let stored = 0;
-      let dropped = 0;
-
-      if (messages.length > 0) {
-        for (const m of messages) {
-          try {
-            this.store.writeInbound(toInboundStoreMessage(m, channel));
-            stored++;
-          } catch (err) {
-            if (err && err.code === 'MAILBOX_JSONL_LINE_TOO_LARGE') {
-              dropped++;
-              const msgId = m && m.id ? String(m.id) : '(missing id)';
-              this.logger.warn?.(`[inbound] dropped oversized inbound message ${msgId}: ${err.message}`);
-              continue;
-            }
-            throw err;
-          }
-        }
-      }
-
-      if (data.next_cursor) {
-        this.store.setCursor(cursorKey, data.next_cursor);
-      }
-
-      const result = { received: stored, cursor: data.next_cursor || cursor };
-      if (dropped > 0) result.dropped = dropped;
-      return result;
-    } catch (err) {
-      if (err instanceof AuthError) throw err;
-      if (isHubUnreachableError(err)) {
-        const retryAfterMs = this._recordHubUnreachable(err);
-        return {
-          received: 0,
-          error: 'hub_unreachable',
-          hubUnreachable: true,
-          retryAfterMs,
-        };
-      }
-      this.logger.error(`[inbound] pull failed: ${err.message}`);
-      return { received: 0, error: err.message };
-    }
-  }
-
-  async ackDelivered(channel = 'evomap-hub') {
-    const waitMs = this._hubUnreachableWaitMs();
-    if (waitMs > 0) {
-      return {
-        acked: 0,
-        error: 'hub_unreachable_backoff',
-        hubUnreachable: true,
-        retryAfterMs: waitMs,
-      };
-    }
-
-    const delivered = this.store.list({
-      type: '%',
-      direction: 'inbound',
-      status: 'delivered',
-      limit: 100,
-    }).filter(m => m.channel === channel);
-
-    if (delivered.length === 0) return { acked: 0 };
-
-    const endpoint = `${this.hubUrl}/a2a/mailbox/ack`;
-
-    try {
-      const senderId = this.store.getState('node_id');
-      // Round-8 (§21.5): drain the response body so the undici long-poll
-      // dispatcher pool is not leaked one socket per ack. ackDelivered
-      // is called every inbound poll cycle (default 1-10s); the
-      // pre-round-8 code captured no reference to res and never called
-      // .json()/.text()/body.cancel(), so each ack pinned a socket
-      // until GC. After a few minutes of activity the strict-pool was
-      // exhausted and proxy-mode heartbeats hung on next acquire --
-      // matches the "alive once then dead" user symptom in proxy mode.
-      const res = await hubFetch(endpoint, {
-        method: 'POST',
-        headers: this.getHeaders(),
-        body: JSON.stringify({ sender_id: senderId, message_ids: delivered.map(m => m.id) }),
-        signal: AbortSignal.timeout(10_000),
-      });
-      await throwIfHubUnreachableResponse(res, 'inbound ack');
-      this._recordHubReachable();
-      if (res.status === 403 || res.status === 401) {
-        const errText = await readHubResponseText(res).catch(() => 'unknown');
-        throw new AuthError(`Hub ${res.status}: ${sanitizeHubResponseForLog(errText)}`, res.status);
-      }
-      if (!res.ok) {
-        const errText = await readHubResponseText(res).catch(() => 'unknown');
-        throw new Error(`Hub returned ${res.status}: ${sanitizeHubResponseForLog(errText)}`);
-      }
-      await drainHubResponse(res);
-      return { acked: delivered.length };
-    } catch (err) {
-      if (err instanceof AuthError) throw err;
-      if (isHubUnreachableError(err)) {
-        const retryAfterMs = this._recordHubUnreachable(err);
-        return {
-          acked: 0,
-          error: 'hub_unreachable',
-          hubUnreachable: true,
-          retryAfterMs,
-        };
-      }
-      this.logger.error(`[inbound] ack failed: ${err.message}`);
-      return { acked: 0, error: err.message };
-    }
-  }
-}
-
-module.exports = { InboundSync, DEFAULT_POLL_INTERVAL_ACTIVE, DEFAULT_POLL_INTERVAL_IDLE };