@marsnme/mcp-gateway 0.3.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@marsnme/mcp-gateway",
-  "version": "0.3.0",
+  "version": "0.3.1",
   "mcpName": "io.github.Marsmanleo/marsnme",
   "private": false,
   "description": "Agent-agnostic, LLM-agnostic memory backend for MCP-compatible tools",
@@ -49,4 +49,4 @@
   "engines": {
     "node": ">=20"
   }
-}
+}

package/scripts/tests/test_auth_guard.mjs

@@ -0,0 +1,74 @@
+// MARS-422: bearer bypass guard (RED first — see scripts/tests/test_auth_guard.mjs)
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { shouldRequireBearer } from '../../lib/auth-guard.mjs';
+
+const base = { requireBearer: true, bypassForPrivate: true };
+
+test('public request via Cloudflare edge must require bearer even with private X-Forwarded-Host', () => {
+  const headers = {
+    'cf-ray': '8b1f9c2d4e5f-HKG',
+    'cf-connecting-ip': '203.0.113.7',
+    'x-forwarded-host': '127.0.0.1',
+    host: 'coco-mcp.marsgroup.asia',
+  };
+  assert.equal(
+    shouldRequireBearer({ ...base, headers, remoteAddress: '127.0.0.1' }),
+    true,
+    'spoofed X-Forwarded-Host from the internet must NOT bypass auth'
+  );
+});
+
+test('edge request from a LAN socket peer still requires bearer', () => {
+  const headers = { 'cf-ray': 'x', 'x-forwarded-host': '192.168.100.102' };
+  assert.equal(shouldRequireBearer({ ...base, headers, remoteAddress: '192.168.100.102' }), true);
+});
+
+test('request with cf-connecting-ip only (no cf-ray) is also treated as edge', () => {
+  const headers = { 'cf-connecting-ip': '203.0.113.7', 'x-forwarded-host': '10.0.0.5' };
+  assert.equal(shouldRequireBearer({ ...base, headers, remoteAddress: '127.0.0.1' }), true);
+});
+
+test('loopback caller without edge headers keeps the private bypass', () => {
+  assert.equal(
+    shouldRequireBearer({ ...base, headers: { host: '127.0.0.1:18790' }, remoteAddress: '127.0.0.1' }),
+    false
+  );
+});
+
+test('LAN caller without edge headers keeps the private bypass (SSH tunnel case)', () => {
+  // Pi's coco-memory-local reaches the CT as 192.168.100.x over ssh -L.
+  const headers = { host: '192.168.100.102:18790', 'x-forwarded-host': '127.0.0.1' };
+  assert.equal(shouldRequireBearer({ ...base, headers, remoteAddress: '192.168.100.102' }), false);
+  assert.equal(shouldRequireBearer({ ...base, headers, remoteAddress: '10.4.5.6' }), false);
+  assert.equal(shouldRequireBearer({ ...base, headers, remoteAddress: '172.20.1.9' }), false);
+});
+
+test('public peer without edge headers must NOT bypass', () => {
+  const headers = { 'x-forwarded-host': '127.0.0.1', host: '127.0.0.1:18790' };
+  assert.equal(
+    shouldRequireBearer({ ...base, headers, remoteAddress: '203.0.113.7' }),
+    true,
+    'a public client reaching the port directly must not be trusted'
+  );
+});
+
+test('requireBearer=false disables auth entirely (unchanged behaviour)', () => {
+  const headers = { 'cf-ray': 'x', 'x-forwarded-host': '127.0.0.1' };
+  assert.equal(
+    shouldRequireBearer({ requireBearer: false, bypassForPrivate: true, headers, remoteAddress: '127.0.0.1' }),
+    false
+  );
+});
+
+test('bypassForPrivate=false always requires bearer', () => {
+  assert.equal(
+    shouldRequireBearer({
+      requireBearer: true,
+      bypassForPrivate: false,
+      headers: { host: '127.0.0.1:18790' },
+      remoteAddress: '127.0.0.1',
+    }),
+    true
+  );
+});

package/server.mjs

@@ -5,6 +5,7 @@ import { execFileSync } from 'node:child_process';
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { shouldRequireBearer as guardShouldRequireBearer } from './lib/auth-guard.mjs';
 
 const PROFILE_CONFIGS = {
   coco: {
@@ -13,7 +14,7 @@ const PROFILE_CONFIGS = {
     defaultPort: 18790,
     gatewayDir: 'coco-mcp-gateway',
     publicHostSuffix: 'coco-mcp.marsgroup.asia',
-    sourceWhitelist: ['perplexity', 'cursor', 'warp', 'openclaw', 'hermes', 'draft', 'grok'],
+    sourceWhitelist: ['perplexity', 'cursor', 'warp', 'openclaw', 'hermes', 'draft', 'grok', 'omp'],
     recallBodyEnum: ['coco', 'toto', 'system'],
     digestDefaultOrigin: 'hermes-coco-digest',
     memoryIngestToolName: 'memory_ingest',
@@ -24,6 +25,7 @@ const PROFILE_CONFIGS = {
       'perplexity-coco',
       'cursor-coco',
       'warp-coco',
+      'omp-coco',
       'leo-manual',
       'hermes-coco-digest'
     ],
@@ -261,7 +263,8 @@ const SOURCE_TO_AGENT_BODY_MAP = new Map([
   ['warp', 'warp'],
   ['openclaw', 'desktop'],
   ['hermes', 'desktop'],
-  ['draft', 'desktop']
+  ['draft', 'desktop'],
+  ['omp', 'omp']
 ]);
 const DEFAULT_AGENT_BODY = String(process.env.MCP_AGENT_BODY || '')
   .trim()
@@ -613,7 +616,7 @@ function buildTools() {
     {
       name: 'session_close',
       description:
-        `Save a ${PROFILE.displayName} session close summary before ending a conversation. The summary is stored as a short-term memory with 7-day retention, providing context for the next session boot. After saving, automatically promotes up to 5 soon-expiring short-term memories to long-term storage (alert window 48h); promote failures never fail the close. Include what was accomplished, what is still pending, and any important context for continuity.`,
+        `Save a ${PROFILE.displayName} session close summary before ending a conversation. The summary is stored as a short-term memory with 7-day retention, providing context for the next session boot. After saving, automatically promotes up to 5 soon-expiring short-term memories to long-term storage (alert window 48h); promote failures never fail the close. Also auto-posts a session-close broadcast to the CoCo family board (board_posts) so other bodies see what was accomplished/pending on next session_boot; board post failures never fail the close. Include what was accomplished, what is still pending, and any important context for continuity.`,
       inputSchema: {
         type: 'object',
         properties: {
@@ -638,6 +641,26 @@ function buildTools() {
           note: {
             type: 'string',
             description: 'Short context handoff for the recipient body (used with `to`)'
+          },
+          body_name: {
+            type: 'string',
+            description: 'Optional posting body name for the auto board_post (e.g. "四哥", "三哥"). Defaults to profile name.'
+          },
+          auto_board_post: {
+            type: 'boolean',
+            default: true,
+            description: 'When true (default), auto-post a session-close broadcast to the family board. Set false to skip.'
+          },
+          board_type: {
+            type: 'string',
+            enum: ['stuck', 'turn', 'collide', 'gate'],
+            default: 'turn',
+            description: 'Board post type for the auto broadcast (default "turn")'
+          },
+          board_topic: {
+            type: 'string',
+            default: 'session-close',
+            description: 'Board topic tag for the auto broadcast (default "session-close")'
           }
         },
         required: ['source', 'summary'],
@@ -816,6 +839,80 @@ function buildTools() {
         },
         additionalProperties: false
       }
+    },
+    // ── MARS-318: Board v0 ─────────────────────────────────────
+    {
+      name: 'board_read',
+      description: 'Read unread board posts (the CoCo family wall). Returns posts not yet acknowledged by the calling body. Called automatically by session_boot, but can also be called manually.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          body: { type: 'string', description: 'The body name reading the board (e.g. "三哥", "四哥", "大家姐", "leo")' },
+          limit: { type: 'number', minimum: 1, maximum: 50, default: 10, description: 'Maximum posts to return' },
+          topic: { type: 'string', description: 'Optional topic filter' },
+          include_acked: { type: 'boolean', default: false, description: 'Include already-acknowledged posts' }
+        },
+        required: ['body'],
+        additionalProperties: false
+      }
+    },
+    {
+      name: 'board_post',
+      description: 'Post a message to the CoCo family board (wall). to="all" broadcasts to the wall; to="<body>" is a private note.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          from_source: { type: 'string', description: 'Source platform (warp / cursor / perplexity / grok / hermes / draft)' },
+          from_body: { type: 'string', description: 'Posting body name (e.g. "三哥", "leo")' },
+          to: { type: 'string', default: 'all', description: '"all" for wall broadcast; specific body name for private note' },
+          topic: { type: 'string', description: 'Topic tag (e.g. "board-v0", "egress")' },
+          type: { type: 'string', enum: ['stuck', 'turn', 'collide', 'gate'], default: 'turn', description: 'Post type' },
+          text: { type: 'string', description: 'Post content (max 2000 chars)' },
+          expires_at: { type: 'string', description: 'Optional expiry in ISO 8601. null = permanent.' }
+        },
+        required: ['from_source', 'from_body', 'text'],
+        additionalProperties: false
+      }
+    },
+    {
+      name: 'board_ack',
+      description: 'Acknowledge (mark as read) one or more board posts for a specific body.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          body: { type: 'string', description: 'The body acknowledging (e.g. "三哥")' },
+          ids: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 50, description: 'Board post UUIDs to acknowledge' }
+        },
+        required: ['body', 'ids'],
+        additionalProperties: false
+      }
+    },
+    // MARS-327: board_get_full — retrieve full text of a single board post
+    {
+      name: 'board_get_full',
+      description: 'Get the full untruncated text of a single board post. Use when board_read or session_boot shows truncated=true and you need the complete content.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          id: { type: 'string', description: 'Board post UUID' }
+        },
+        required: ['id'],
+        additionalProperties: false
+      }
+    },
+    // board_resolve — mark posts as globally resolved
+    {
+      name: 'board_resolve',
+      description: 'Resolve one or more board posts globally. Resolved posts are hidden from board_read and session_boot for ALL bodies (unlike ack which is per-body). Use to close out stuck/gate posts that have been addressed.',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          body: { type: 'string', description: 'The body resolving (e.g. "三哥")' },
+          ids: { type: 'array', items: { type: 'string' }, minItems: 1, maxItems: 50, description: 'Board post UUIDs to resolve' }
+        },
+        required: ['body', 'ids'],
+        additionalProperties: false
+      }
     }
   ];
 }
@@ -1609,6 +1706,8 @@ function estimateToolUsageTokens(toolName, args = {}) {
       appendTokenCharCount(safeArgs.summary, state);
       appendTokenCharCount(safeArgs.topics, state);
       appendTokenCharCount(safeArgs.mood, state);
+      appendTokenCharCount(safeArgs.body_name, state);
+      appendTokenCharCount(safeArgs.board_topic, state);
       break;
     case 'session_boot':
       appendTokenCharCount(safeArgs.topic, state);
@@ -2440,6 +2539,54 @@ async function runDailyBoot(args = {}) {
     }
   }
 
+  // MARS-318: Board v0 — auto-fetch unread wall posts for this body
+  let boardUnread = [];
+  const boardBody = bodyName || inferAgentBodyFromSource(source) || DB_PROFILE;
+  try {
+    const bQuery = new URLSearchParams();
+    bQuery.set('select', 'id,from_source,from_body,to,topic,type,text,acked_by,created_at');
+    bQuery.set('order', 'created_at.desc');
+    bQuery.set('limit', '5');
+    bQuery.set('archived_at', 'is.null');
+    bQuery.set('resolved_at', 'is.null');
+    bQuery.set('or', `(to.eq.all,to.eq.${boardBody})`);
+    const bResult = await supabaseRequest(`/rest/v1/board_posts?${bQuery.toString()}`, { profile: DB_PROFILE });
+    const bPosts = Array.isArray(bResult) ? bResult : [];
+    const BOOT_BOARD_PREVIEW_MAX = 160;
+    // MARS-328: priority types surface first
+    const BOARD_PRIORITY_TYPES = new Set(['gate', 'stuck']);
+    boardUnread = bPosts
+      .filter(p => {
+        const ab = p.acked_by && typeof p.acked_by === 'object' ? p.acked_by : {};
+        return !ab[boardBody];
+      })
+      .map(p => {
+        const fullText = p.text || '';
+        const preview = fullText.slice(0, BOOT_BOARD_PREVIEW_MAX);
+        return {
+          id: p.id,
+          from: `${p.from_body}@${p.from_source}`,
+          to: p.to,
+          topic: p.topic || null,
+          type: p.type,
+          text: preview,
+          truncated: fullText.length > BOOT_BOARD_PREVIEW_MAX,
+          full_length: fullText.length,
+          preview_length: preview.length,
+          created_at: p.created_at
+        };
+      })
+      .sort((a, b) => {
+        const aPri = BOARD_PRIORITY_TYPES.has(a.type) ? 0 : 1;
+        const bPri = BOARD_PRIORITY_TYPES.has(b.type) ? 0 : 1;
+        if (aPri !== bPri) return aPri - bPri;
+        return new Date(b.created_at).getTime() - new Date(a.created_at).getTime();
+      });
+  } catch {
+    // board_posts table may not exist yet — degrade gracefully
+    boardUnread = [];
+  }
+
   return {
     ok: true,
     profile: DB_PROFILE,
@@ -2447,6 +2594,9 @@ async function runDailyBoot(args = {}) {
     source,
     date: dateKey,
     notes,
+    board_unread: boardUnread,
+    // MARS-328: remind body to post stuck/gate when blocked mid-session
+    board_reminder: '中途卡住請用 board_post type=stuck 上牆，唔好等到 session_close。',
     heartbeat_id: savedHeartbeat?.id || null,
     agent_name: queries.agent_name,
     last_topic: previousTopic || null,
@@ -2580,6 +2730,51 @@ async function runDailyClose(args = {}) {
     }
   }
 
+  // Auto-post a session-close broadcast to the CoCo family board.
+  // Mirrors board_post insert; failures never break session_close (summary already stored).
+  let boardPostResult = null;
+  const autoBoardPost = args.auto_board_post !== false;
+  if (autoBoardPost) {
+    try {
+      const boardFromSource = source;
+      const boardFromBody = normalizeOptionalText(args.body_name, 60) || DB_PROFILE;
+      const boardTo = 'all';
+      const boardType = ['stuck', 'turn', 'collide', 'gate'].includes(args.board_type)
+        ? args.board_type
+        : 'turn';
+      const boardTopic = normalizeOptionalText(args.board_topic, 60) || 'session-close';
+      const boardText = String(summary || '').slice(0, 2000);
+      if (boardText) {
+        const boardPayload = {
+          from_source: boardFromSource,
+          from_body: boardFromBody,
+          to: boardTo,
+          topic: boardTopic,
+          type: boardType,
+          text: boardText
+        };
+        const boardInserted = await supabaseRequest(
+          '/rest/v1/board_posts?select=id,from_source,from_body,to,topic,type,text,created_at',
+          {
+            method: 'POST',
+            profile: DB_PROFILE,
+            prefer: 'return=representation',
+            body: [boardPayload]
+          }
+        );
+        boardPostResult = { posted: true, id: boardInserted?.[0]?.id || null };
+      } else {
+        boardPostResult = { posted: false, reason: 'empty summary' };
+      }
+    } catch (error) {
+      // board_posts table may not exist yet, or insert failed — degrade gracefully.
+      console.warn(`[session_close] auto board_post failed: ${String(error?.message || error)}`);
+      boardPostResult = { posted: false, error: String(error?.message || error) };
+    }
+  } else {
+    boardPostResult = { posted: false, skipped: true };
+  }
+
   return {
     ok: true,
     profile: DB_PROFILE,
@@ -2591,6 +2786,7 @@ async function runDailyClose(args = {}) {
     mood: mood || null,
     tool_usage_daily_summary: toolUsageDailySummary,
     note: noteResult,
+    board_post: boardPostResult,
     promoted_count: promotedCount,
     expiry_alert: {
       soon_expiring_count: soonExpiringCount,
@@ -2660,6 +2856,15 @@ function evaluatePromotionCandidate(memory, nowTs, longTermTagSet) {
       reason: '已 promoted'
     };
   }
+  // Heartbeat / session_close lifecycle memories should never be promoted —
+  // they contain query strings that pollute recall results with high similarity.
+  if (isLifecycleMemoryRow(memory)) {
+    return {
+      recommend: 'N',
+      score: 0,
+      reason: 'lifecycle memory (heartbeat/session_close) 唔應升級'
+    };
+  }
   const reasons = [];
   let score = 0;
 
@@ -4258,6 +4463,204 @@ async function callTool(name, args = {}) {
       };
     }
 
+    // ── MARS-318: Board v0 handlers ──────────────────────────
+    if (toolName === 'board_read') {
+      const body = String(args.body || '').trim();
+      if (!body) throw new Error('body is required');
+      const limitRaw = Number(args.limit ?? 10);
+      const limit = Number.isFinite(limitRaw) ? Math.max(1, Math.min(50, Math.trunc(limitRaw))) : 10;
+      const includeAcked = Boolean(args.include_acked);
+      const topic = args.topic ? String(args.topic).trim() : '';
+
+      const query = new URLSearchParams();
+      query.set('select', 'id,from_source,from_body,to,topic,type,text,acked_by,expires_at,archived_at,created_at');
+      query.set('order', 'created_at.desc');
+      query.set('limit', String(limit));
+      query.set('archived_at', 'is.null');
+      query.set('resolved_at', 'is.null');
+      // Wall posts (to=all) + posts addressed to this body
+      query.set('or', `(to.eq.all,to.eq.${body})`);
+      if (topic) query.set('topic', `eq.${topic}`);
+      // Exclude expired
+      query.set('or', `(expires_at.is.null,expires_at.gt.${new Date().toISOString()})`);
+
+      const result = await supabaseRequest(`/rest/v1/board_posts?${query.toString()}`, { profile: DB_PROFILE });
+      const posts = Array.isArray(result) ? result : [];
+
+      // Filter out already-acked posts unless include_acked
+      const filtered = includeAcked
+        ? posts
+        : posts.filter(p => {
+            const ackedBy = p.acked_by && typeof p.acked_by === 'object' ? p.acked_by : {};
+            return !ackedBy[body];
+          });
+
+      const BOARD_PREVIEW_MAX = 160;
+      // MARS-328: gate/stuck surface first
+      const BOARD_READ_PRIORITY_TYPES = new Set(['gate', 'stuck']);
+      const mapped = filtered.map(p => {
+        const fullText = p.text || '';
+        const preview = fullText.slice(0, BOARD_PREVIEW_MAX);
+        return {
+          id: p.id,
+          from: `${p.from_body}@${p.from_source}`,
+          to: p.to,
+          topic: p.topic || null,
+          type: p.type,
+          text: preview,
+          truncated: fullText.length > BOARD_PREVIEW_MAX,
+          full_length: fullText.length,
+          preview_length: preview.length,
+          created_at: p.created_at,
+          acked: !!(p.acked_by && p.acked_by[body])
+        };
+      }).sort((a, b) => {
+        const aPri = BOARD_READ_PRIORITY_TYPES.has(a.type) ? 0 : 1;
+        const bPri = BOARD_READ_PRIORITY_TYPES.has(b.type) ? 0 : 1;
+        if (aPri !== bPri) return aPri - bPri;
+        return new Date(b.created_at).getTime() - new Date(a.created_at).getTime();
+      });
+      return {
+        ok: true,
+        count: mapped.length,
+        body,
+        posts: mapped
+      };
+    }
+
+    if (toolName === 'board_post') {
+      const fromSource = String(args.from_source || '').trim();
+      const fromBody = String(args.from_body || '').trim();
+      const to = String(args.to || 'all').trim();
+      const topic = args.topic ? String(args.topic).trim() : null;
+      const type = args.type || 'turn';
+      const text = String(args.text || '').trim();
+      const expiresAt = args.expires_at ? String(args.expires_at).trim() : null;
+
+      if (!fromSource) throw new Error('from_source is required');
+      if (!fromBody) throw new Error('from_body is required');
+      if (!text) throw new Error('text is required');
+      if (text.length > 2000) throw new Error('text too long (max 2000 chars)');
+
+      const payload = {
+        from_source: fromSource,
+        from_body: fromBody,
+        to,
+        topic,
+        type,
+        text
+      };
+      if (expiresAt) payload.expires_at = expiresAt;
+
+      const result = await supabaseRequest(
+        '/rest/v1/board_posts?select=id,from_source,from_body,to,topic,type,text,created_at',
+        {
+          method: 'POST',
+          profile: DB_PROFILE,
+          prefer: 'return=representation',
+          body: [payload]
+        }
+      );
+      const inserted = result?.[0] ?? null;
+      return {
+        ok: true,
+        inserted,
+        text_length: text.length
+      };
+    }
+
+    if (toolName === 'board_ack') {
+      const body = String(args.body || '').trim();
+      const ids = Array.isArray(args.ids) ? args.ids.map(id => String(id).trim()).filter(Boolean) : [];
+      if (!body) throw new Error('body is required');
+      if (!ids.length) throw new Error('ids is required (at least 1)');
+
+      const now = new Date().toISOString();
+      let acked = 0;
+      const notFoundIds = [];
+      for (const id of ids) {
+        // Read current acked_by, merge, write back
+        const rows = await supabaseRequest(
+          `/rest/v1/board_posts?id=eq.${id}&select=id,acked_by`,
+          { profile: DB_PROFILE }
+        );
+        const row = rows?.[0];
+        if (!row) { notFoundIds.push(id); continue; }
+        const ackedBy = row.acked_by && typeof row.acked_by === 'object' ? { ...row.acked_by } : {};
+        ackedBy[body] = now;
+        await supabaseRequest(
+          `/rest/v1/board_posts?id=eq.${id}`,
+          {
+            method: 'PATCH',
+            profile: DB_PROFILE,
+            prefer: 'return=minimal',
+            body: { acked_by: ackedBy }
+          }
+        );
+        acked++;
+      }
+      return { ok: true, acked, body, not_found_ids: notFoundIds };
+    }
+
+    // board_resolve — mark posts as globally resolved (hidden for all bodies)
+    if (toolName === 'board_resolve') {
+      const body = String(args.body || '').trim();
+      const ids = Array.isArray(args.ids) ? args.ids.map(id => String(id).trim()).filter(Boolean) : [];
+      if (!body) throw new Error('body is required');
+      if (!ids.length) throw new Error('ids is required (at least 1)');
+
+      const now = new Date().toISOString();
+      let resolved = 0;
+      const notFoundIds = [];
+      for (const id of ids) {
+        const rows = await supabaseRequest(
+          `/rest/v1/board_posts?id=eq.${id}&select=id,resolved_at`,
+          { profile: DB_PROFILE }
+        );
+        const row = rows?.[0];
+        if (!row) { notFoundIds.push(id); continue; }
+        if (row.resolved_at) continue; // already resolved
+        await supabaseRequest(
+          `/rest/v1/board_posts?id=eq.${id}`,
+          {
+            method: 'PATCH',
+            profile: DB_PROFILE,
+            prefer: 'return=minimal',
+            body: { resolved_at: now }
+          }
+        );
+        resolved++;
+      }
+      return { ok: true, resolved, body, not_found_ids: notFoundIds };
+    }
+
+    // MARS-327: board_get_full — single post full text retrieval
+    if (toolName === 'board_get_full') {
+      const id = String(args.id || '').trim();
+      if (!id) throw new Error('id is required');
+
+      const query = new URLSearchParams();
+      query.set('id', `eq.${id}`);
+      query.set('select', 'id,from_source,from_body,to,topic,type,text,acked_by,expires_at,archived_at,created_at');
+      const rows = await supabaseRequest(`/rest/v1/board_posts?${query.toString()}`, { profile: DB_PROFILE });
+      const post = rows?.[0];
+      if (!post) throw new Error(`board post not found: ${id}`);
+
+      return {
+        ok: true,
+        post: {
+          id: post.id,
+          from: `${post.from_body}@${post.from_source}`,
+          to: post.to,
+          topic: post.topic || null,
+          type: post.type,
+          text: post.text || '',
+          full_length: (post.text || '').length,
+          created_at: post.created_at
+        }
+      };
+    }
+
     throw new Error(`Unknown tool: ${name}`);
   } finally {
     await writeToolUsageTelemetry({
@@ -4319,15 +4722,14 @@ function isPublicHost(host) {
 }
 
 function shouldRequireBearer(req) {
-  if (!REQUIRE_BEARER) return false;
-  const host = extractRequestHost(req);
-  if (BYPASS_BEARER_FOR_PRIVATE && isPrivateHost(host)) {
-    return false;
-  }
-  if (isPublicHost(host)) {
-    return true;
-  }
-  return true;
+  // MARS-422: never trust client-supplied X-Forwarded-Host on edge traffic.
+  // See lib/auth-guard.mjs and scripts/tests/test_auth_guard.mjs.
+  return guardShouldRequireBearer({
+    headers: req.headers,
+    remoteAddress: req.socket?.remoteAddress,
+    requireBearer: REQUIRE_BEARER,
+    bypassForPrivate: BYPASS_BEARER_FOR_PRIVATE
+  });
 }
 
 function oauthProtectedResourceMetadata(baseUrl) {