@evomap/evolver 1.89.17 → 1.89.19

package/src/proxy/server/http.js

@@ -3,6 +3,11 @@
 const crypto = require('crypto');
 const http = require('http');
 const { writeSettings, readSettings, clearSettings, clearIfStale } = require('./settings');
+const {
+  isValidReusableProxyToken,
+  readReusableClientProxyToken,
+  syncClaudeProxySettings,
+} = require('../clientSettings');
 
 const MAX_PORT_ATTEMPTS = 100;
 const DEFAULT_PORT = 19820;
@@ -93,13 +98,14 @@ function tryListen(server, port) {
 }
 
 class ProxyHttpServer {
-  constructor(routes, { port, logger } = {}) {
+  constructor(routes, { port, logger, clientSettings } = {}) {
     this.routes = routes;
     this.basePort = port || Number(process.env.EVOMAP_PROXY_PORT) || DEFAULT_PORT;
     this.actualPort = null;
     this.logger = logger || console;
     this.server = null;
     this.token = null;
+    this.clientSettings = clientSettings || null;
   }
 
   async start() {
@@ -109,16 +115,22 @@ class ProxyHttpServer {
     // already exported into long-lived shells (the .bashrc auto-source only
     // runs once per terminal).
     const priorProxy = readSettings().proxy || {};
-    const previous = typeof priorProxy.token === 'string' ? priorProxy.token : null;
+    const previous = isValidReusableProxyToken(priorProxy.token) ? priorProxy.token.trim() : null;
     // settings.json is operator-edited; previous_tokens may contain non-strings
     // (numbers, booleans, objects) that would later crash Buffer.from(cand, 'utf8')
     // in _handleRequest as ERR_INVALID_ARG_TYPE — an unhandled rejection that
     // takes the daemon down under default --unhandled-rejections=throw.
     const priorPreviousTokens = Array.isArray(priorProxy.previous_tokens)
-      ? priorProxy.previous_tokens.filter((t) => typeof t === 'string' && t.length > 0)
+      ? priorProxy.previous_tokens
+        .map((t) => (typeof t === 'string' ? t.trim() : ''))
+        .filter((t) => isValidReusableProxyToken(t))
       : [];
     clearIfStale();
-    this.token = previous || crypto.randomBytes(32).toString('hex');
+    const clientSettingsOpts = this.clientSettings || {};
+    const clientToken = this.clientSettings
+      ? readReusableClientProxyToken({ ...clientSettingsOpts, port: this.basePort })
+      : null;
+    this.token = previous || clientToken || crypto.randomBytes(32).toString('hex');
     this._priorPreviousTokens = priorPreviousTokens;
     this.server = http.createServer((req, res) => this._handleRequest(req, res));
 
@@ -138,6 +150,24 @@ class ProxyHttpServer {
           proxyBlock.previous_tokens = this._priorPreviousTokens;
         }
         writeSettings({ proxy: proxyBlock });
+        if (this.clientSettings) {
+          try {
+            const syncResult = syncClaudeProxySettings({
+              ...clientSettingsOpts,
+              url,
+              port: this.basePort,
+              token: this.token,
+              runtimeEnv: process.env,
+            });
+            if (syncResult.synced && syncResult.changed) {
+              this.logger.log(`[proxy] Synced Claude client settings at ${syncResult.file}`);
+            } else if (syncResult.reason === 'invalid_settings_json') {
+              this.logger.warn?.(`[proxy] Skipped Claude client settings sync because ${syncResult.file} is not valid JSON`);
+            }
+          } catch (err) {
+            this.logger.warn?.('[proxy] Claude client settings sync failed: ' + (err && err.message ? err.message : err));
+          }
+        }
         this.logger.log(`[proxy] HTTP server listening on ${url}`);
         return { port, url, token: this.token };
       }
@@ -171,9 +201,13 @@ class ProxyHttpServer {
     // and unhandled-reject through the auth path.
     const previous = readSettings().proxy?.previous_tokens;
     const extras = Array.isArray(previous)
-      ? previous.filter((t) => typeof t === 'string' && t.length > 0)
+      ? previous
+        .map((t) => (typeof t === 'string' ? t.trim() : ''))
+        .filter((t) => isValidReusableProxyToken(t))
       : [];
-    const candidates = [this.token, ...extras].filter((t) => typeof t === 'string' && t.length > 0);
+    const candidates = [this.token, ...extras]
+      .filter((t) => isValidReusableProxyToken(t))
+      .map((t) => t.trim());
     let valid = false;
     for (const cand of candidates) {
       const expBuf = Buffer.from(cand, 'utf8');

package/src/proxy/sync/inbound.js

@@ -16,6 +16,18 @@ const {
 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;
@@ -86,26 +98,33 @@ class InboundSync {
 
       const data = await readHubResponseJson(res);
       const messages = data.messages || [];
+      let stored = 0;
+      let dropped = 0;
 
       if (messages.length > 0) {
-        this.store.writeInboundBatch(
-          messages.map(m => ({
-            id: m.id,
-            type: m.type,
-            payload: m.payload,
-            channel,
-            priority: m.priority || 'normal',
-            refId: m.ref_id,
-            expiresAt: m.expires_at,
-          }))
-        );
+        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);
       }
 
-      return { received: messages.length, cursor: data.next_cursor || 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)) {

package/src/proxy/sync/outbound.js

@@ -12,9 +12,113 @@ const {
   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 };
+}
 
 class OutboundSync {
   constructor({ store, hubUrl, getHeaders, logger }) {
@@ -81,41 +185,75 @@ class OutboundSync {
       pending = pendingBatch.filter(m => !rejectedIds.has(m.id));
       if (pending.length === 0) return { sent: 0, dropped: rejectedTraceUploads.length };
     }
-    const dropped = rejectedTraceUploads.length;
-
-    const endpoint = `${this.hubUrl}/a2a/mailbox/outbound`;
+    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: JSON.stringify({
-          sender_id: senderId,
-          proxy_protocol_version: PROXY_PROTOCOL_VERSION,
-          messages: pending.map(m => ({
-            id: m.id,
-            type: m.type,
-            payload: m.payload,
-            priority: m.priority,
-            ref_id: m.ref_id,
-            created_at: m.created_at,
-          })),
-        }),
+        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 = await readHubResponseText(res).catch(() => 'unknown');
-        throw new AuthError(`Hub ${res.status}: ${sanitizeHubResponseForLog(errText)}`, res.status);
+        const errText = sanitizeHubErrorMessage(await readHubResponseText(res).catch(() => 'unknown'));
+        throw new AuthError(`Hub ${res.status}: ${errText}`, res.status);
       }
 
       if (!res.ok) {
-        const errText = await readHubResponseText(res).catch(() => 'unknown');
-        throw new Error(`Hub returned ${res.status}: ${sanitizeHubResponseForLog(errText)}`);
+        const errText = sanitizeHubErrorMessage(await readHubResponseText(res).catch(() => 'unknown'));
+        throw new Error(`Hub returned ${res.status}: ${errText}`);
       }
 
       const data = await readHubResponseJson(res);
@@ -129,10 +267,11 @@ class OutboundSync {
           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 || 'rejected by hub');
           if (msg && msg.retry_count < MAX_RETRIES) {
-            this.store.incrementRetry(r.id, r.error || 'rejected by hub');
+            this.store.incrementRetry(r.id, error);
           } else {
-            updates.push({ id: r.id, status: 'failed', error: r.error || 'max retries' });
+            updates.push({ id: r.id, status: 'failed', error: sanitizeHubErrorMessage(r.error || 'max retries') });
           }
         }
 
@@ -166,11 +305,12 @@ class OutboundSync {
         if (dropped > 0) result.dropped = dropped;
         return result;
       }
-      this.logger.error(`[outbound] flush failed: ${err.message}`);
+      const errMessage = sanitizeHubErrorMessage(err);
+      this.logger.error(`[outbound] flush failed: ${errMessage}`);
       for (const m of pending) {
-        this.store.incrementRetry(m.id, err.message);
+        this.store.incrementRetry(m.id, errMessage);
       }
-      const result = { sent: 0, error: err.message };
+      const result = { sent: 0, error: errMessage };
       if (dropped > 0) result.dropped = dropped;
       return result;
     }