@dollhousemcp/mcp-server
Version:
DollhouseMCP - A Model Context Protocol (MCP) server that enables dynamic AI persona management from markdown files, allowing Claude and other compatible AI assistants to activate and switch between different behavioral personas.
260 lines • 31.9 kB
JavaScript
/**
* Forwarding sinks for follower MCP servers.
*
* When a server becomes a follower in the unified console election, it
* registers these sinks with its LogManager and MetricsManager. Instead
* of broadcasting to local SSE clients, entries are batch-POSTed to
* the leader's ingestion endpoints.
*
* Features:
* - Batch buffering (50 entries or 1s flush, whichever comes first)
* - In-memory buffer up to 10,000 entries on leader failure
* - Exponential backoff on POST failure (1s → 2s → 4s, max 30s)
* - Automatic drain on leader recovery
*
* @since v2.1.0 — Issue #1700
*/
import { UnicodeValidator } from '../../security/validators/unicodeValidator.js';
import { PACKAGE_VERSION } from '../../generated/version.js';
import { logger } from '../../utils/logger.js';
import { env } from '../../config/env.js';
import { CONSOLE_PROTOCOL_VERSION } from './LeaderElection.js';
import { detectSessionClientPlatformId, } from './sessionClientPlatform.js';
/** Maximum entries to buffer when leader is unreachable */
const MAX_BUFFER_SIZE = 10_000;
/** Batch size before flushing */
const BATCH_SIZE = 50;
/** Time-based flush interval (ms) */
const FLUSH_INTERVAL_MS = 1_000;
/** Initial backoff delay on failure (ms) */
const INITIAL_BACKOFF_MS = 1_000;
/** Maximum backoff delay (ms) */
const MAX_BACKOFF_MS = 30_000;
/** Give up forwarding after this many consecutive failures (#1850: configurable via env) */
const MAX_CONSECUTIVE_FAILURES = env.DOLLHOUSE_CONSOLE_MAX_FORWARD_FAILURES;
/** HTTP request timeout (ms) */
const REQUEST_TIMEOUT_MS = 5_000;
/**
* Build the HTTP headers for ingest POSTs, including the console auth token
* if one was provided (#1780). Followers read the token from the shared token
* file on startup and pass it to each sink; when the leader has auth disabled
* or the token file is missing, this is a no-op that sends only Content-Type.
*/
function buildIngestHeaders(token) {
const headers = { 'Content-Type': 'application/json' };
if (token) {
headers['Authorization'] = `Bearer ${token}`;
}
return headers;
}
/**
* ILogSink that batch-POSTs entries to the leader's /api/ingest/logs.
*/
export class LeaderForwardingLogSink {
leaderUrl;
sessionId;
authToken;
onLeaderDeath;
buffer = [];
flushTimer = null;
backoffMs = INITIAL_BACKOFF_MS;
flushing = false;
consecutiveFailures = 0;
gaveUp = false;
constructor(leaderUrl, sessionId,
/** Optional console auth token (#1780). Included as Bearer header on ingest POSTs. */
authToken = null,
/** Callback invoked when the leader is presumed dead after MAX_CONSECUTIVE_FAILURES (#1850). */
onLeaderDeath) {
this.leaderUrl = leaderUrl;
this.sessionId = sessionId;
this.authToken = authToken;
this.onLeaderDeath = onLeaderDeath;
this.sessionId = UnicodeValidator.normalize(sessionId).normalizedContent;
this.flushTimer = setInterval(() => this.flushBuffer(), FLUSH_INTERVAL_MS);
this.flushTimer.unref();
}
write(entry) {
// Stamp session ID before buffering
const stamped = {
...entry,
data: { ...entry.data, _sessionId: this.sessionId },
};
if (this.buffer.length >= MAX_BUFFER_SIZE) {
// Evict oldest entry (FIFO)
this.buffer.shift();
}
this.buffer.push(stamped);
if (this.buffer.length >= BATCH_SIZE) {
this.flushBuffer();
}
}
async flush() {
await this.flushBuffer();
}
async close() {
if (this.flushTimer) {
clearInterval(this.flushTimer);
this.flushTimer = null;
}
await this.flushBuffer();
}
async flushBuffer() {
if (this.flushing || this.buffer.length === 0 || this.gaveUp)
return;
this.flushing = true;
const batch = this.buffer.splice(0, BATCH_SIZE);
try {
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
const response = await fetch(`${this.leaderUrl}/api/ingest/logs`, {
method: 'POST',
headers: buildIngestHeaders(this.authToken),
body: JSON.stringify({ sessionId: this.sessionId, entries: batch }),
signal: controller.signal,
});
clearTimeout(timeout);
if (response.ok) {
this.backoffMs = INITIAL_BACKOFF_MS;
this.consecutiveFailures = 0;
}
else {
this.requeueBatch(batch);
this.handleFailure();
}
}
catch {
this.requeueBatch(batch);
this.handleFailure();
}
finally {
this.flushing = false;
}
}
requeueBatch(batch) {
const spaceAvailable = MAX_BUFFER_SIZE - this.buffer.length;
if (spaceAvailable > 0) {
const toRequeue = batch.slice(0, spaceAvailable);
this.buffer.unshift(...toRequeue);
}
else {
logger.warn(`[ForwardingSink] Buffer full (${MAX_BUFFER_SIZE}), dropping ${batch.length} entries`);
}
}
handleFailure() {
this.consecutiveFailures++;
if (this.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
if (!this.gaveUp) {
this.gaveUp = true;
logger.info(`[ForwardingSink] Leader not running web console — log forwarding disabled after ${this.consecutiveFailures} failed attempts. Buffered ${this.buffer.length} entries discarded.`);
this.buffer.length = 0;
if (this.flushTimer) {
clearInterval(this.flushTimer);
this.flushTimer = null;
}
// Notify the orchestrator so it can attempt follower-to-leader promotion (#1850).
// Fired asynchronously so handleFailure completes cleanly before promotion runs.
if (this.onLeaderDeath) {
queueMicrotask(() => this.onLeaderDeath());
}
}
return;
}
logger.debug(`[ForwardingSink] Leader unreachable, backoff ${this.backoffMs}ms (attempt ${this.consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}, buffered: ${this.buffer.length})`);
this.backoffMs = Math.min(this.backoffMs * 2, MAX_BACKOFF_MS);
}
}
/**
* Forwards metric snapshots to the leader's /api/ingest/metrics.
*/
export class LeaderForwardingMetricsSink {
leaderUrl;
sessionId;
authToken;
constructor(leaderUrl, sessionId,
/** Optional console auth token (#1780). Included as Bearer header on ingest POSTs. */
authToken = null) {
this.leaderUrl = leaderUrl;
this.sessionId = sessionId;
this.authToken = authToken;
}
async onSnapshot(snapshot) {
try {
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
await fetch(`${this.leaderUrl}/api/ingest/metrics`, {
method: 'POST',
headers: buildIngestHeaders(this.authToken),
body: JSON.stringify({ sessionId: this.sessionId, snapshot }),
signal: controller.signal,
});
clearTimeout(timeout);
}
catch {
logger.debug('[ForwardingSink] Failed to forward metrics snapshot');
}
}
}
/**
* Sends session lifecycle events to the leader.
*/
export class SessionHeartbeat {
leaderUrl;
sessionId;
pid;
authToken;
clientPlatform;
heartbeatTimer = null;
constructor(leaderUrl, sessionId, pid,
/** Optional console auth token (#1780). Included as Bearer header on ingest POSTs. */
authToken = null,
/** Explicit MCP host platform metadata for this runtime. */
clientPlatform = detectSessionClientPlatformId()) {
this.leaderUrl = leaderUrl;
this.sessionId = sessionId;
this.pid = pid;
this.authToken = authToken;
this.clientPlatform = clientPlatform;
}
/** Notify the leader that this session has started */
async start() {
await this.sendEvent('started');
this.heartbeatTimer = setInterval(() => {
this.sendEvent('heartbeat').catch(() => { });
}, 10_000);
this.heartbeatTimer.unref();
}
/** Notify the leader that this session is stopping */
async stop() {
if (this.heartbeatTimer) {
clearInterval(this.heartbeatTimer);
this.heartbeatTimer = null;
}
await this.sendEvent('stopped');
}
async sendEvent(event) {
try {
const controller = new AbortController();
const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);
await fetch(`${this.leaderUrl}/api/ingest/session`, {
method: 'POST',
headers: buildIngestHeaders(this.authToken),
body: JSON.stringify({
sessionId: this.sessionId,
event,
pid: this.pid,
startedAt: new Date().toISOString(),
serverVersion: PACKAGE_VERSION,
consoleProtocolVersion: CONSOLE_PROTOCOL_VERSION,
clientPlatform: this.clientPlatform ?? undefined,
}),
signal: controller.signal,
});
clearTimeout(timeout);
}
catch {
logger.debug(`[SessionHeartbeat] Failed to send ${event} event`);
}
}
}
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"LeaderForwardingSink.js","sourceRoot":"","sources":["../../../src/web/console/LeaderForwardingSink.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Forwarding sinks for follower MCP servers.\n *\n * When a server becomes a follower in the unified console election, it\n * registers these sinks with its LogManager and MetricsManager. Instead\n * of broadcasting to local SSE clients, entries are batch-POSTed to\n * the leader's ingestion endpoints.\n *\n * Features:\n * - Batch buffering (50 entries or 1s flush, whichever comes first)\n * - In-memory buffer up to 10,000 entries on leader failure\n * - Exponential backoff on POST failure (1s → 2s → 4s, max 30s)\n * - Automatic drain on leader recovery\n *\n * @since v2.1.0 — Issue #1700\n */\n\nimport type { ILogSink, UnifiedLogEntry } from '../../logging/types.js';\nimport type { MetricSnapshot } from '../../metrics/types.js';\nimport { UnicodeValidator } from '../../security/validators/unicodeValidator.js';\nimport { PACKAGE_VERSION } from '../../generated/version.js';\nimport { logger } from '../../utils/logger.js';\nimport { env } from '../../config/env.js';\nimport { CONSOLE_PROTOCOL_VERSION } from './LeaderElection.js';\nimport {\n  detectSessionClientPlatformId,\n  type SessionClientPlatformId,\n} from './sessionClientPlatform.js';\n\n/** Maximum entries to buffer when leader is unreachable */\nconst MAX_BUFFER_SIZE = 10_000;\n\n/** Batch size before flushing */\nconst BATCH_SIZE = 50;\n\n/** Time-based flush interval (ms) */\nconst FLUSH_INTERVAL_MS = 1_000;\n\n/** Initial backoff delay on failure (ms) */\nconst INITIAL_BACKOFF_MS = 1_000;\n\n/** Maximum backoff delay (ms) */\nconst MAX_BACKOFF_MS = 30_000;\n\n/** Give up forwarding after this many consecutive failures (#1850: configurable via env) */\nconst MAX_CONSECUTIVE_FAILURES = env.DOLLHOUSE_CONSOLE_MAX_FORWARD_FAILURES;\n\n/** HTTP request timeout (ms) */\nconst REQUEST_TIMEOUT_MS = 5_000;\n\n/**\n * Build the HTTP headers for ingest POSTs, including the console auth token\n * if one was provided (#1780). Followers read the token from the shared token\n * file on startup and pass it to each sink; when the leader has auth disabled\n * or the token file is missing, this is a no-op that sends only Content-Type.\n */\nfunction buildIngestHeaders(token: string | null): Record<string, string> {\n  const headers: Record<string, string> = { 'Content-Type': 'application/json' };\n  if (token) {\n    headers['Authorization'] = `Bearer ${token}`;\n  }\n  return headers;\n}\n\n/**\n * ILogSink that batch-POSTs entries to the leader's /api/ingest/logs.\n */\nexport class LeaderForwardingLogSink implements ILogSink {\n  private readonly buffer: UnifiedLogEntry[] = [];\n  private flushTimer: ReturnType<typeof setInterval> | null = null;\n  private backoffMs = INITIAL_BACKOFF_MS;\n  private flushing = false;\n  private consecutiveFailures = 0;\n  private gaveUp = false;\n\n  constructor(\n    private readonly leaderUrl: string,\n    private readonly sessionId: string,\n    /** Optional console auth token (#1780). Included as Bearer header on ingest POSTs. */\n    private readonly authToken: string | null = null,\n    /** Callback invoked when the leader is presumed dead after MAX_CONSECUTIVE_FAILURES (#1850). */\n    private readonly onLeaderDeath?: () => void,\n  ) {\n    this.sessionId = UnicodeValidator.normalize(sessionId).normalizedContent;\n    this.flushTimer = setInterval(() => this.flushBuffer(), FLUSH_INTERVAL_MS);\n    this.flushTimer.unref();\n  }\n\n  write(entry: UnifiedLogEntry): void {\n    // Stamp session ID before buffering\n    const stamped: UnifiedLogEntry = {\n      ...entry,\n      data: { ...entry.data, _sessionId: this.sessionId },\n    };\n\n    if (this.buffer.length >= MAX_BUFFER_SIZE) {\n      // Evict oldest entry (FIFO)\n      this.buffer.shift();\n    }\n    this.buffer.push(stamped);\n\n    if (this.buffer.length >= BATCH_SIZE) {\n      this.flushBuffer();\n    }\n  }\n\n  async flush(): Promise<void> {\n    await this.flushBuffer();\n  }\n\n  async close(): Promise<void> {\n    if (this.flushTimer) {\n      clearInterval(this.flushTimer);\n      this.flushTimer = null;\n    }\n    await this.flushBuffer();\n  }\n\n  private async flushBuffer(): Promise<void> {\n    if (this.flushing || this.buffer.length === 0 || this.gaveUp) return;\n    this.flushing = true;\n\n    const batch = this.buffer.splice(0, BATCH_SIZE);\n    try {\n      const controller = new AbortController();\n      const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);\n\n      const response = await fetch(`${this.leaderUrl}/api/ingest/logs`, {\n        method: 'POST',\n        headers: buildIngestHeaders(this.authToken),\n        body: JSON.stringify({ sessionId: this.sessionId, entries: batch }),\n        signal: controller.signal,\n      });\n      clearTimeout(timeout);\n\n      if (response.ok) {\n        this.backoffMs = INITIAL_BACKOFF_MS;\n        this.consecutiveFailures = 0;\n      } else {\n        this.requeueBatch(batch);\n        this.handleFailure();\n      }\n    } catch {\n      this.requeueBatch(batch);\n      this.handleFailure();\n    } finally {\n      this.flushing = false;\n    }\n  }\n\n  private requeueBatch(batch: UnifiedLogEntry[]): void {\n    const spaceAvailable = MAX_BUFFER_SIZE - this.buffer.length;\n    if (spaceAvailable > 0) {\n      const toRequeue = batch.slice(0, spaceAvailable);\n      this.buffer.unshift(...toRequeue);\n    } else {\n      logger.warn(`[ForwardingSink] Buffer full (${MAX_BUFFER_SIZE}), dropping ${batch.length} entries`);\n    }\n  }\n\n  private handleFailure(): void {\n    this.consecutiveFailures++;\n\n    if (this.consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {\n      if (!this.gaveUp) {\n        this.gaveUp = true;\n        logger.info(`[ForwardingSink] Leader not running web console — log forwarding disabled after ${this.consecutiveFailures} failed attempts. Buffered ${this.buffer.length} entries discarded.`);\n        this.buffer.length = 0;\n        if (this.flushTimer) {\n          clearInterval(this.flushTimer);\n          this.flushTimer = null;\n        }\n        // Notify the orchestrator so it can attempt follower-to-leader promotion (#1850).\n        // Fired asynchronously so handleFailure completes cleanly before promotion runs.\n        if (this.onLeaderDeath) {\n          queueMicrotask(() => this.onLeaderDeath!());\n        }\n      }\n      return;\n    }\n\n    logger.debug(`[ForwardingSink] Leader unreachable, backoff ${this.backoffMs}ms (attempt ${this.consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}, buffered: ${this.buffer.length})`);\n    this.backoffMs = Math.min(this.backoffMs * 2, MAX_BACKOFF_MS);\n  }\n}\n\n/**\n * Forwards metric snapshots to the leader's /api/ingest/metrics.\n */\nexport class LeaderForwardingMetricsSink {\n  constructor(\n    private readonly leaderUrl: string,\n    private readonly sessionId: string,\n    /** Optional console auth token (#1780). Included as Bearer header on ingest POSTs. */\n    private readonly authToken: string | null = null,\n  ) {}\n\n  async onSnapshot(snapshot: MetricSnapshot): Promise<void> {\n    try {\n      const controller = new AbortController();\n      const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);\n\n      await fetch(`${this.leaderUrl}/api/ingest/metrics`, {\n        method: 'POST',\n        headers: buildIngestHeaders(this.authToken),\n        body: JSON.stringify({ sessionId: this.sessionId, snapshot }),\n        signal: controller.signal,\n      });\n      clearTimeout(timeout);\n    } catch {\n      logger.debug('[ForwardingSink] Failed to forward metrics snapshot');\n    }\n  }\n}\n\n/**\n * Sends session lifecycle events to the leader.\n */\nexport class SessionHeartbeat {\n  private heartbeatTimer: ReturnType<typeof setInterval> | null = null;\n\n  constructor(\n    private readonly leaderUrl: string,\n    private readonly sessionId: string,\n    private readonly pid: number,\n    /** Optional console auth token (#1780). Included as Bearer header on ingest POSTs. */\n    private readonly authToken: string | null = null,\n    /** Explicit MCP host platform metadata for this runtime. */\n    private readonly clientPlatform: SessionClientPlatformId | null = detectSessionClientPlatformId(),\n  ) {}\n\n  /** Notify the leader that this session has started */\n  async start(): Promise<void> {\n    await this.sendEvent('started');\n\n    this.heartbeatTimer = setInterval(() => {\n      this.sendEvent('heartbeat').catch(() => {});\n    }, 10_000);\n    this.heartbeatTimer.unref();\n  }\n\n  /** Notify the leader that this session is stopping */\n  async stop(): Promise<void> {\n    if (this.heartbeatTimer) {\n      clearInterval(this.heartbeatTimer);\n      this.heartbeatTimer = null;\n    }\n    await this.sendEvent('stopped');\n  }\n\n  private async sendEvent(event: 'started' | 'stopped' | 'heartbeat'): Promise<void> {\n    try {\n      const controller = new AbortController();\n      const timeout = setTimeout(() => controller.abort(), REQUEST_TIMEOUT_MS);\n\n      await fetch(`${this.leaderUrl}/api/ingest/session`, {\n        method: 'POST',\n        headers: buildIngestHeaders(this.authToken),\n        body: JSON.stringify({\n          sessionId: this.sessionId,\n          event,\n          pid: this.pid,\n          startedAt: new Date().toISOString(),\n          serverVersion: PACKAGE_VERSION,\n          consoleProtocolVersion: CONSOLE_PROTOCOL_VERSION,\n          clientPlatform: this.clientPlatform ?? undefined,\n        }),\n        signal: controller.signal,\n      });\n      clearTimeout(timeout);\n    } catch {\n      logger.debug(`[SessionHeartbeat] Failed to send ${event} event`);\n    }\n  }\n}\n"]}