@evomap/evolver 1.90.0 → 2.0.0-beta.0

package/src/proxy/sync/outbound.js

@@ -1,361 +0,0 @@
-'use strict';
-
-const { PROXY_PROTOCOL_VERSION } = require('../mailbox/store');
-const { AuthError } = require('../lifecycle/manager');
-const { isProxyTraceUploadPayloadAllowed, resolveTraceMode } = require('../trace/extractor');
-const {
-  hubFetch,
-  hubUnreachableBackoffMs,
-  isHubUnreachableError,
-  readHubResponseJson,
-  readHubResponseText,
-  sanitizeHubResponseForLog,
-  throwIfHubUnreachableResponse,
-} = require('../../gep/hubFetch');
-const { redactString } = require('../../gep/sanitize');
-
-const MAX_BATCH = 50;
-const MAX_RETRIES = 10;
-const DEFAULT_MAX_OUTBOUND_BODY_BYTES = 4 * 1024 * 1024;
-const MIN_ADAPTIVE_OUTBOUND_BODY_BYTES = 16 * 1024;
-const OUTBOUND_BODY_BYTES_STATE_KEY = 'outbound_sync_max_body_bytes';
-
-function sanitizeHubErrorMessage(value) {
-  if (typeof sanitizeHubResponseForLog === 'function') {
-    return sanitizeHubResponseForLog(value);
-  }
-
-  let text;
-  if (typeof value === 'string') {
-    text = value;
-  } else if (value && typeof value.message === 'string') {
-    text = value.message;
-  } else {
-    try { text = JSON.stringify(value); } catch { text = String(value || ''); }
-  }
-  return redactString(String(text || ''));
-}
-
-function resolveHardOutboundBodyBytes(env = process.env) {
-  const raw = Number(env.EVOMAP_OUTBOUND_SYNC_MAX_BODY_BYTES || env.EVOMAP_MAILBOX_OUTBOUND_MAX_BODY_BYTES);
-  const max = Number.isFinite(raw) && raw > 0
-    ? Math.floor(raw)
-    : DEFAULT_MAX_OUTBOUND_BODY_BYTES;
-  return Math.max(1, max);
-}
-
-function resolveMaxOutboundBodyBytes(env = process.env, store = null) {
-  let max = resolveHardOutboundBodyBytes(env);
-  try {
-    const adaptive = Number(store && typeof store.getState === 'function'
-      ? store.getState(OUTBOUND_BODY_BYTES_STATE_KEY)
-      : null);
-    if (Number.isFinite(adaptive) && adaptive > 0) max = Math.min(max, Math.floor(adaptive));
-  } catch { /* adaptive state is best-effort */ }
-  return Math.max(1, max);
-}
-
-function hubMessage(m) {
-  return {
-    id: m.id,
-    type: m.type,
-    payload: m.payload,
-    priority: m.priority,
-    ref_id: m.ref_id,
-    created_at: m.created_at,
-  };
-}
-
-function serializeOutboundBody(senderId, messages) {
-  return JSON.stringify({
-    sender_id: senderId,
-    proxy_protocol_version: PROXY_PROTOCOL_VERSION,
-    messages: messages.map(hubMessage),
-  });
-}
-
-function outboundEndpoint(hubUrl, senderId) {
-  const endpoint = new URL(`${String(hubUrl || '').replace(/\/+$/, '')}/a2a/mailbox/outbound`);
-  if (senderId) endpoint.searchParams.set('sender_id', senderId);
-  return endpoint.toString();
-}
-
-function outboundBodyBytes(senderId, messages) {
-  return Buffer.byteLength(serializeOutboundBody(senderId, messages), 'utf8');
-}
-
-function buildSizedOutboundBatch(senderId, messages, maxBodyBytes, hardMaxBodyBytes = maxBodyBytes) {
-  const selected = [];
-  const rejected = [];
-  let body = serializeOutboundBody(senderId, selected);
-  let bodyBytes = Buffer.byteLength(body, 'utf8');
-
-  for (const m of messages) {
-    const singleBytes = outboundBodyBytes(senderId, [m]);
-    if (singleBytes > hardMaxBodyBytes) {
-      rejected.push({
-        id: m.id,
-        status: 'rejected',
-        error: `outbound message exceeds max body bytes (${singleBytes} > ${hardMaxBodyBytes})`,
-      });
-      continue;
-    }
-    if (selected.length === 0 && singleBytes > maxBodyBytes) {
-      selected.push(m);
-      body = serializeOutboundBody(senderId, selected);
-      bodyBytes = Buffer.byteLength(body, 'utf8');
-      break;
-    }
-
-    const candidate = selected.concat(m);
-    const candidateBody = serializeOutboundBody(senderId, candidate);
-    const candidateBytes = Buffer.byteLength(candidateBody, 'utf8');
-    if (candidateBytes > maxBodyBytes) break;
-
-    selected.push(m);
-    body = candidateBody;
-    bodyBytes = candidateBytes;
-  }
-
-  return { selected, rejected, body, bodyBytes, maxBodyBytes };
-}
-
-function numberField(row, keys) {
-  for (const key of keys) {
-    if (!row || row[key] === undefined || row[key] === null || row[key] === '') continue;
-    const n = Number(row[key]);
-    if (Number.isFinite(n)) return n;
-  }
-  return null;
-}
-
-function resultRetryAfterMs(row) {
-  const ms = numberField(row, ['retryAfterMs', 'retry_after_ms']);
-  if (ms !== null) return Math.max(1_000, ms);
-  const seconds = numberField(row, ['retryAfter', 'retry_after']);
-  return seconds !== null ? Math.max(1_000, seconds * 1000) : null;
-}
-
-function resultIsRetryable(row) {
-  return row && (row.retryable === true || row.retryable === 'true' || row.terminal === false || row.terminal === 'false');
-}
-
-function resultIsTerminal(row) {
-  return row && (row.terminal === true || row.terminal === 'true');
-}
-
-class OutboundSync {
-  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?.(
-      `[outbound] Hub unreachable; backing off for ${Math.ceil(retryAfterMs / 1000)}s: ` +
-        `${err && err.message || err}`
-    );
-    return retryAfterMs;
-  }
-
-  async flush(channel = 'evomap-hub') {
-    const waitMs = this._hubUnreachableWaitMs();
-    if (waitMs > 0) {
-      return {
-        sent: 0,
-        error: 'hub_unreachable_backoff',
-        hubUnreachable: true,
-        retryAfterMs: waitMs,
-      };
-    }
-
-    const pendingBatch = this.store.pollOutbound({ channel, limit: MAX_BATCH });
-    if (pendingBatch.length === 0) return { sent: 0 };
-
-    let pending = pendingBatch;
-    const rejectedTraceUploads = [];
-    const traceUploadEnabled = resolveTraceMode(process.env, { store: this.store });
-    for (const m of pendingBatch) {
-      if (m.type !== 'proxy_trace') continue;
-      if (!traceUploadEnabled) {
-        rejectedTraceUploads.push({ id: m.id, error: 'proxy trace upload disabled' });
-      } else if (!isProxyTraceUploadPayloadAllowed(m.payload, process.env, { store: this.store })) {
-        rejectedTraceUploads.push({ id: m.id, error: 'proxy trace payload rejected' });
-      }
-    }
-    if (rejectedTraceUploads.length > 0) {
-      this.store.updateStatusBatch(rejectedTraceUploads.map(m => ({
-        id: m.id,
-        status: 'rejected',
-        error: m.error,
-      })));
-      const rejectedIds = new Set(rejectedTraceUploads.map(m => m.id));
-      pending = pendingBatch.filter(m => !rejectedIds.has(m.id));
-      if (pending.length === 0) return { sent: 0, dropped: rejectedTraceUploads.length };
-    }
-    let dropped = rejectedTraceUploads.length;
-
-    try {
-      const senderId = this.store.getState('node_id');
-      const endpoint = outboundEndpoint(this.hubUrl, senderId);
-      const prepared = buildSizedOutboundBatch(
-        senderId,
-        pending,
-        resolveMaxOutboundBodyBytes(process.env, this.store),
-        resolveHardOutboundBodyBytes(process.env)
-      );
-      if (prepared.rejected.length > 0) {
-        this.store.updateStatusBatch(prepared.rejected);
-        dropped += prepared.rejected.length;
-      }
-      pending = prepared.selected;
-      if (pending.length === 0) return { sent: 0, dropped };
-
-      const res = await hubFetch(endpoint, {
-        method: 'POST',
-        headers: this.getHeaders(),
-        body: prepared.body,
-        signal: AbortSignal.timeout(30_000),
-      });
-
-      if (res.status === 413) {
-        const errText = sanitizeHubErrorMessage(
-          await readHubResponseText(res).catch(() => 'request entity too large')
-        );
-        const error = `Hub 413 outbound payload too large: ${errText}`;
-        if (pending.length <= 1) {
-          this.store.updateStatusBatch(pending.map(m => ({
-            id: m.id,
-            status: 'rejected',
-            error,
-          })));
-          const result = {
-            sent: 0,
-            error: 'hub_payload_too_large',
-            payloadTooLarge: true,
-            dropped: dropped + pending.length,
-          };
-          return result;
-        }
-        const currentCeiling = Math.min(prepared.maxBodyBytes, Math.max(1, prepared.bodyBytes - 1));
-        const nextMax = currentCeiling > MIN_ADAPTIVE_OUTBOUND_BODY_BYTES
-          ? Math.max(MIN_ADAPTIVE_OUTBOUND_BODY_BYTES, Math.floor(currentCeiling / 2))
-          : Math.max(1, Math.floor(currentCeiling / 2));
-        try { this.store.setState(OUTBOUND_BODY_BYTES_STATE_KEY, nextMax); } catch { /* best effort */ }
-        this.logger.warn?.(
-          `[outbound] Hub 413 for ${pending.length} messages (${prepared.bodyBytes} bytes); ` +
-            `reducing outbound batch budget to ${nextMax} bytes`
-        );
-        const result = { sent: 0, error: 'hub_payload_too_large', payloadTooLarge: true };
-        if (dropped > 0) result.dropped = dropped;
-        return result;
-      }
-
-      await throwIfHubUnreachableResponse(res, 'outbound flush');
-      this._recordHubReachable();
-
-      if (res.status === 403 || res.status === 401) {
-        const errText = sanitizeHubErrorMessage(await readHubResponseText(res).catch(() => 'unknown'));
-        throw new AuthError(`Hub ${res.status}: ${errText}`, res.status);
-      }
-
-      if (!res.ok) {
-        const errText = sanitizeHubErrorMessage(await readHubResponseText(res).catch(() => 'unknown'));
-        throw new Error(`Hub returned ${res.status}: ${errText}`);
-      }
-
-      const data = await readHubResponseJson(res);
-      const results = data.results || [];
-
-      const updates = [];
-      const inboundMessages = [];
-      let deferred = 0;
-
-      for (const r of results) {
-        if (r.status === 'accepted' || r.status === 'ok') {
-          updates.push({ id: r.id, status: 'synced' });
-        } else if (r.status === 'failed' || r.status === 'rejected') {
-          const msg = pending.find(m => m.id === r.id);
-          const error = sanitizeHubErrorMessage(r.error || r.reason || 'rejected by hub');
-          const retryAfterMs = resultRetryAfterMs(r);
-          // A `terminal: true` hint from the Hub means "final, do not retry"
-          // and must win even when the same result also carries retryAfterMs
-          // or retryable (a contradictory but possible payload). Guard the
-          // defer branch with !resultIsTerminal so a terminal message is
-          // finalized as failed instead of being parked for retry and resent.
-          if (msg && !resultIsTerminal(r) && (retryAfterMs !== null || resultIsRetryable(r))) {
-            this.store.deferRetry(r.id, error, retryAfterMs || 60_000);
-            deferred++;
-          } else if (msg && !resultIsTerminal(r) && msg.retry_count < MAX_RETRIES) {
-            this.store.incrementRetry(r.id, error);
-          } else {
-            // Reuse the already-sanitized `error` (r.error / r.reason, else
-            // 'rejected by hub'). Only label 'max retries' for the genuine
-            // retry-exhaustion path (non-terminal, no explicit Hub error) so a
-            // terminal rejection without an error/reason is not mislabeled as
-            // retry exhaustion (Bugbot PR #301 Low).
-            const exhausted = !resultIsTerminal(r) && !(r.error || r.reason);
-            updates.push({ id: r.id, status: 'failed', error: exhausted ? sanitizeHubErrorMessage('max retries') : error });
-          }
-        }
-
-        if (r.response) {
-          inboundMessages.push({
-            type: `${r.original_type || 'unknown'}_result`,
-            payload: r.response,
-            refId: r.id,
-            channel,
-          });
-        }
-      }
-
-      if (updates.length > 0) this.store.updateStatusBatch(updates);
-      if (inboundMessages.length > 0) this.store.writeInboundBatch(inboundMessages);
-
-      this.store.setState('last_sync_at', new Date().toISOString());
-      const result = { sent: pending.length, synced: updates.length, responses: inboundMessages.length };
-      if (deferred > 0) result.deferred = deferred;
-      if (dropped > 0) result.dropped = dropped;
-      return result;
-    } catch (err) {
-      if (err instanceof AuthError) throw err;
-      if (isHubUnreachableError(err)) {
-        const retryAfterMs = this._recordHubUnreachable(err);
-        const result = {
-          sent: 0,
-          error: 'hub_unreachable',
-          hubUnreachable: true,
-          retryAfterMs,
-        };
-        if (dropped > 0) result.dropped = dropped;
-        return result;
-      }
-      const errMessage = sanitizeHubErrorMessage(err);
-      this.logger.error(`[outbound] flush failed: ${errMessage}`);
-      for (const m of pending) {
-        this.store.incrementRetry(m.id, errMessage);
-      }
-      const result = { sent: 0, error: errMessage };
-      if (dropped > 0) result.dropped = dropped;
-      return result;
-    }
-  }
-}
-
-module.exports = { OutboundSync, MAX_BATCH, MAX_RETRIES };

package/src/proxy/task/monitor.js

@@ -1,131 +0,0 @@
-'use strict';
-
-class TaskMonitor {
-  constructor({ store, logger } = {}) {
-    this.store = store;
-    this.logger = logger || console;
-    this._stats = {
-      tasks_received: 0,
-      tasks_claimed: 0,
-      tasks_completed: 0,
-      tasks_failed: 0,
-      last_claim_at: null,
-      last_complete_at: null,
-      avg_completion_ms: 0,
-      _completion_times: [],
-    };
-    this._restoreStats();
-  }
-
-  _restoreStats() {
-    const raw = this.store.getState('task_monitor_stats');
-    if (!raw) return;
-    try {
-      const saved = typeof raw === 'string' ? JSON.parse(raw) : raw;
-      if (saved.tasks_claimed) this._stats.tasks_claimed = saved.tasks_claimed;
-      if (saved.tasks_completed) this._stats.tasks_completed = saved.tasks_completed;
-      if (saved.tasks_failed) this._stats.tasks_failed = saved.tasks_failed;
-      if (saved.tasks_received) this._stats.tasks_received = saved.tasks_received;
-      if (saved.last_claim_at) this._stats.last_claim_at = saved.last_claim_at;
-      if (saved.last_complete_at) this._stats.last_complete_at = saved.last_complete_at;
-      if (saved.avg_completion_ms) this._stats.avg_completion_ms = saved.avg_completion_ms;
-    } catch { /* ignore corrupt state */ }
-  }
-
-  get subscribed() {
-    const raw = this.store.getState('task_subscription');
-    if (!raw) return false;
-    try {
-      const parsed = typeof raw === 'string' ? JSON.parse(raw) : raw;
-      return !!parsed.enabled;
-    } catch {
-      return false;
-    }
-  }
-
-  subscribe(filters = []) {
-    this.store.setState('task_subscription', JSON.stringify({
-      enabled: true,
-      filters,
-      subscribed_at: new Date().toISOString(),
-    }));
-    const result = this.store.send({
-      type: 'task_subscribe',
-      payload: { capability_filter: filters },
-    });
-    return result;
-  }
-
-  unsubscribe() {
-    this.store.setState('task_subscription', JSON.stringify({
-      enabled: false,
-      unsubscribed_at: new Date().toISOString(),
-    }));
-    const result = this.store.send({
-      type: 'task_unsubscribe',
-      payload: {},
-    });
-    return result;
-  }
-
-  recordClaim(taskId) {
-    this._stats.tasks_claimed++;
-    this._stats.last_claim_at = Date.now();
-    this.store.setState('task_monitor_stats', JSON.stringify(this.getMetrics()));
-  }
-
-  recordComplete(taskId, startedAt) {
-    this._stats.tasks_completed++;
-    this._stats.last_complete_at = Date.now();
-    if (startedAt) {
-      const duration = Date.now() - startedAt;
-      this._stats._completion_times.push(duration);
-      if (this._stats._completion_times.length > 100) {
-        this._stats._completion_times.shift();
-      }
-      const sum = this._stats._completion_times.reduce((a, b) => a + b, 0);
-      this._stats.avg_completion_ms = Math.round(sum / this._stats._completion_times.length);
-    }
-    this.store.setState('task_monitor_stats', JSON.stringify(this.getMetrics()));
-  }
-
-  recordFailed(taskId) {
-    this._stats.tasks_failed++;
-    this.store.setState('task_monitor_stats', JSON.stringify(this.getMetrics()));
-  }
-
-  recordTaskReceived(count = 1) {
-    this._stats.tasks_received += count;
-  }
-
-  getMetrics() {
-    const pendingTasks = this.store.countPending({ direction: 'inbound' });
-    return {
-      subscribed: this.subscribed,
-      tasks_received: this._stats.tasks_received,
-      tasks_claimed: this._stats.tasks_claimed,
-      tasks_completed: this._stats.tasks_completed,
-      tasks_failed: this._stats.tasks_failed,
-      tasks_pending: pendingTasks,
-      last_claim_at: this._stats.last_claim_at,
-      last_complete_at: this._stats.last_complete_at,
-      avg_completion_ms: this._stats.avg_completion_ms,
-    };
-  }
-
-  getHeartbeatMeta() {
-    const pendingTasks = this.store.countPending({ direction: 'inbound' });
-    return {
-      task_subscription: this.subscribed,
-      task_metrics: {
-        pending: pendingTasks,
-        claimed: this._stats.tasks_claimed,
-        completed: this._stats.tasks_completed,
-        failed: this._stats.tasks_failed,
-        avg_completion_ms: this._stats.avg_completion_ms,
-      },
-    };
-  }
-}
-
-module.exports = { TaskMonitor };