@promptbook/cli 0.112.0-99 → 0.113.0-0

package/apps/agents-server/src/message-providers/email/sendgrid/verifySendgridInboundParseWebhook.ts

@@ -0,0 +1,345 @@
+import { createHmac, createPublicKey, createVerify, timingSafeEqual, type KeyObject } from 'crypto';
+import { spaceTrim } from 'spacetrim';
+import { EnvironmentMismatchError } from '../../../../../../src/errors/EnvironmentMismatchError';
+import { NotAllowed } from '../../../../../../src/errors/NotAllowed';
+import { normalizeServerDomain } from '../../../utils/serverRegistry';
+
+/**
+ * Header containing the SendGrid webhook signature.
+ */
+export const SENDGRID_INBOUND_PARSE_SIGNATURE_HEADER_NAME = 'x-twilio-email-event-webhook-signature';
+
+/**
+ * Header containing the SendGrid webhook timestamp.
+ */
+export const SENDGRID_INBOUND_PARSE_TIMESTAMP_HEADER_NAME = 'x-twilio-email-event-webhook-timestamp';
+
+/**
+ * Environment variable containing the SendGrid ECDSA public verification key.
+ */
+const SENDGRID_INBOUND_PARSE_PUBLIC_KEY_ENV_NAME = 'SENDGRID_INBOUND_PARSE_PUBLIC_KEY';
+
+/**
+ * Environment variable containing the HMAC shared secret for custom SendGrid webhook signing deployments.
+ */
+const SENDGRID_INBOUND_PARSE_WEBHOOK_SECRET_ENV_NAME = 'SENDGRID_INBOUND_PARSE_WEBHOOK_SECRET';
+
+/**
+ * Environment variable containing the comma-separated hosts allowed to receive SendGrid Inbound Parse callbacks.
+ */
+const SENDGRID_INBOUND_PARSE_HOSTS_ENV_NAME = 'SENDGRID_INBOUND_PARSE_HOSTS';
+
+/**
+ * Maximum accepted age or future skew for signed SendGrid Inbound Parse webhook requests.
+ */
+const SENDGRID_INBOUND_PARSE_REPLAY_WINDOW_SECONDS = 5 * 60;
+
+/**
+ * One resolved SendGrid Inbound Parse signing configuration.
+ */
+type SendgridInboundParseSigningConfiguration =
+    | {
+          /**
+           * Current SendGrid signature verification mode.
+           */
+          readonly type: 'ecdsa';
+
+          /**
+           * Public key configured in SendGrid for signed webhooks.
+           */
+          readonly publicKey: KeyObject;
+      }
+    | {
+          /**
+           * Current SendGrid signature verification mode.
+           */
+          readonly type: 'hmac';
+
+          /**
+           * Shared webhook secret used to verify the signature.
+           */
+          readonly secret: string;
+      };
+
+/**
+ * Verifies one SendGrid Inbound Parse webhook request before the multipart body is parsed.
+ *
+ * SendGrid signs the raw request body, so callers must pass the exact bytes
+ * received by the route. Parsing `multipart/form-data` before this check can
+ * normalize boundaries or file parts and break signature verification.
+ *
+ * @param headers - Incoming request headers.
+ * @param rawBody - Exact request body bytes.
+ * @param now - Current time used for timestamp replay-window checks.
+ * @throws {EnvironmentMismatchError} When required SendGrid security configuration is missing or invalid.
+ * @throws {NotAllowed} When the request host, timestamp, or signature is not accepted.
+ *
+ * @private internal utility of SendGrid inbound email provider
+ */
+export function verifySendgridInboundParseWebhook(headers: Headers, rawBody: Buffer, now = new Date()): void {
+    assertSendgridInboundParseHostAllowed(headers);
+
+    const timestamp = headers.get(SENDGRID_INBOUND_PARSE_TIMESTAMP_HEADER_NAME);
+    const signature = headers.get(SENDGRID_INBOUND_PARSE_SIGNATURE_HEADER_NAME);
+
+    if (!timestamp || !signature) {
+        throw new NotAllowed('Missing required SendGrid Inbound Parse webhook signature headers.');
+    }
+
+    assertSendgridInboundParseTimestampAllowed(timestamp, now);
+
+    const signingConfiguration = resolveSendgridInboundParseSigningConfiguration();
+    const isSignatureValid =
+        signingConfiguration.type === 'ecdsa'
+            ? verifySendgridInboundParseEcdsaSignature({
+                  publicKey: signingConfiguration.publicKey,
+                  rawBody,
+                  signature,
+                  timestamp,
+              })
+            : verifySendgridInboundParseHmacSignature({
+                  rawBody,
+                  secret: signingConfiguration.secret,
+                  signature,
+                  timestamp,
+              });
+
+    if (!isSignatureValid) {
+        throw new NotAllowed('SendGrid Inbound Parse webhook signature verification failed.');
+    }
+}
+
+/**
+ * Maps SendGrid webhook verification errors to HTTP statuses.
+ *
+ * @param error - Error thrown while processing the webhook.
+ * @returns HTTP status code.
+ *
+ * @private internal utility of SendGrid inbound email route
+ */
+export function resolveSendgridInboundParseWebhookErrorStatus(error: unknown): number {
+    if (error instanceof EnvironmentMismatchError) {
+        return 503;
+    }
+
+    if (error instanceof NotAllowed) {
+        return 403;
+    }
+
+    return 500;
+}
+
+/**
+ * Verifies an ECDSA signed SendGrid webhook payload.
+ */
+function verifySendgridInboundParseEcdsaSignature(options: {
+    readonly publicKey: KeyObject;
+    readonly rawBody: Buffer;
+    readonly signature: string;
+    readonly timestamp: string;
+}): boolean {
+    const signatureBuffer = decodeBase64Buffer(options.signature);
+    if (!signatureBuffer) {
+        return false;
+    }
+
+    const verifier = createVerify('sha256');
+    verifier.update(options.timestamp);
+    verifier.update(options.rawBody);
+    verifier.end();
+
+    return verifier.verify(options.publicKey, signatureBuffer);
+}
+
+/**
+ * Verifies a HMAC signed SendGrid webhook payload using constant-time comparison.
+ */
+function verifySendgridInboundParseHmacSignature(options: {
+    readonly rawBody: Buffer;
+    readonly secret: string;
+    readonly signature: string;
+    readonly timestamp: string;
+}): boolean {
+    const receivedSignature = decodeBase64Buffer(options.signature);
+    if (!receivedSignature) {
+        return false;
+    }
+
+    const expectedSignature = createHmac('sha256', options.secret)
+        .update(options.timestamp)
+        .update(options.rawBody)
+        .digest();
+
+    if (receivedSignature.length !== expectedSignature.length) {
+        return false;
+    }
+
+    return timingSafeEqual(receivedSignature, expectedSignature);
+}
+
+/**
+ * Resolves and validates the configured SendGrid webhook signing mode.
+ */
+function resolveSendgridInboundParseSigningConfiguration(): SendgridInboundParseSigningConfiguration {
+    const publicKey = process.env[SENDGRID_INBOUND_PARSE_PUBLIC_KEY_ENV_NAME]?.trim();
+    if (publicKey) {
+        return {
+            type: 'ecdsa',
+            publicKey: createSendgridInboundParsePublicKey(publicKey),
+        };
+    }
+
+    const secret = process.env[SENDGRID_INBOUND_PARSE_WEBHOOK_SECRET_ENV_NAME]?.trim();
+    if (secret) {
+        return {
+            type: 'hmac',
+            secret,
+        };
+    }
+
+    throw new EnvironmentMismatchError(
+        spaceTrim(`
+            Missing required SendGrid Inbound Parse webhook signing configuration.
+
+            The Agents Server verifies \`/api/emails/incoming/sendgrid\` before
+            parsing the multipart body or inserting an inbound \`EMAIL\` message.
+
+            **Fix:** set \`${SENDGRID_INBOUND_PARSE_PUBLIC_KEY_ENV_NAME}\` to the
+            public verification key from SendGrid Signed Webhook settings. If your
+            deployment uses a shared-secret HMAC variant, set
+            \`${SENDGRID_INBOUND_PARSE_WEBHOOK_SECRET_ENV_NAME}\` instead.
+        `),
+    );
+}
+
+/**
+ * Converts the SendGrid public key configuration into a Node.js public key.
+ */
+function createSendgridInboundParsePublicKey(publicKey: string): KeyObject {
+    const normalizedPublicKey = publicKey.replace(/\\n/gu, '\n').trim();
+
+    try {
+        if (normalizedPublicKey.includes('BEGIN PUBLIC KEY')) {
+            return createPublicKey(normalizedPublicKey);
+        }
+
+        return createPublicKey({
+            key: Buffer.from(normalizedPublicKey, 'base64'),
+            format: 'der',
+            type: 'spki',
+        });
+    } catch (error) {
+        throw new EnvironmentMismatchError(
+            spaceTrim(`
+                Invalid \`${SENDGRID_INBOUND_PARSE_PUBLIC_KEY_ENV_NAME}\` environment variable.
+
+                Expected the ECDSA public verification key copied from SendGrid
+                Signed Webhook settings, either as PEM or base64-encoded SPKI DER.
+
+                ${error instanceof Error ? error.message : String(error)}
+            `),
+        );
+    }
+}
+
+/**
+ * Rejects requests that were delivered through an unconfigured host.
+ */
+function assertSendgridInboundParseHostAllowed(headers: Headers): void {
+    const requestHost = resolveSendgridInboundParseRequestHost(headers);
+    const allowedHosts = resolveAllowedSendgridInboundParseHosts();
+
+    if (!requestHost || !allowedHosts.includes(requestHost)) {
+        throw new NotAllowed(
+            spaceTrim(`
+                SendGrid Inbound Parse webhook host is not allowed.
+
+                Expected one of \`${allowedHosts.join('`, `')}\`.
+            `),
+        );
+    }
+}
+
+/**
+ * Resolves configured SendGrid Inbound Parse hostnames.
+ */
+function resolveAllowedSendgridInboundParseHosts(): Array<string> {
+    const rawHosts = process.env[SENDGRID_INBOUND_PARSE_HOSTS_ENV_NAME]?.trim();
+    if (!rawHosts) {
+        throw new EnvironmentMismatchError(
+            spaceTrim(`
+                Missing required \`${SENDGRID_INBOUND_PARSE_HOSTS_ENV_NAME}\` environment variable.
+
+                Configure the hostnames that are allowed to receive SendGrid
+                Inbound Parse webhook callbacks, separated by commas.
+            `),
+        );
+    }
+
+    const allowedHosts = uniqueStrings(
+        rawHosts
+            .split(',')
+            .map((rawHost) => normalizeServerDomain(rawHost))
+            .filter((host): host is string => Boolean(host)),
+    );
+
+    if (allowedHosts.length === 0) {
+        throw new EnvironmentMismatchError(
+            spaceTrim(`
+                Environment variable \`${SENDGRID_INBOUND_PARSE_HOSTS_ENV_NAME}\`
+                does not contain any valid hostnames.
+            `),
+        );
+    }
+
+    return allowedHosts;
+}
+
+/**
+ * Resolves the externally visible request host from trusted proxy headers.
+ */
+function resolveSendgridInboundParseRequestHost(headers: Headers): string | null {
+    const forwardedHost = headers.get('x-forwarded-host')?.split(',')[0]?.trim();
+    const host = forwardedHost || headers.get('host') || '';
+
+    return normalizeServerDomain(host);
+}
+
+/**
+ * Rejects stale or far-future webhook timestamps to reduce replay risk.
+ */
+function assertSendgridInboundParseTimestampAllowed(timestamp: string, now: Date): void {
+    if (!/^\d+$/u.test(timestamp)) {
+        throw new NotAllowed('SendGrid Inbound Parse webhook timestamp is invalid.');
+    }
+
+    const timestampSeconds = Number(timestamp);
+    if (!Number.isSafeInteger(timestampSeconds)) {
+        throw new NotAllowed('SendGrid Inbound Parse webhook timestamp is invalid.');
+    }
+
+    const nowSeconds = Math.floor(now.getTime() / 1000);
+    const ageSeconds = Math.abs(nowSeconds - timestampSeconds);
+    if (ageSeconds > SENDGRID_INBOUND_PARSE_REPLAY_WINDOW_SECONDS) {
+        throw new NotAllowed('SendGrid Inbound Parse webhook timestamp is outside the accepted replay window.');
+    }
+}
+
+/**
+ * Decodes a strict base64 value into bytes.
+ */
+function decodeBase64Buffer(value: string): Buffer | null {
+    const normalizedValue = value.trim();
+    if (!/^[A-Za-z0-9+/]+={0,2}$/u.test(normalizedValue) || normalizedValue.length % 4 !== 0) {
+        return null;
+    }
+
+    return Buffer.from(normalizedValue, 'base64');
+}
+
+/**
+ * Returns unique strings while preserving input order.
+ */
+function uniqueStrings(values: ReadonlyArray<string>): Array<string> {
+    return [...new Set(values)];
+}

package/apps/agents-server/src/middleware/applyEmbeddingHeader.ts

@@ -21,13 +21,15 @@ export function applyEmbeddingHeader(response: NextResponse, url: URL, isAllowed
         return;
     }
 
+    // Note: The base strict CSP (script-src with nonce) is preserved by appending a separate
+    //       Content-Security-Policy header that only carries the `frame-ancestors` directive.
     if (isAllowed) {
-        response.headers.set('Content-Security-Policy', 'frame-ancestors https: http:');
+        response.headers.append('Content-Security-Policy', 'frame-ancestors https: http:');
         response.headers.delete('X-Frame-Options');
         return;
     }
 
-    response.headers.set('Content-Security-Policy', "frame-ancestors 'none'");
+    response.headers.append('Content-Security-Policy', "frame-ancestors 'none'");
     response.headers.set('X-Frame-Options', 'DENY');
 }
 

package/apps/agents-server/src/middleware/contentSecurityPolicy.ts

@@ -0,0 +1,97 @@
+import type { NextResponse } from 'next/server';
+
+/**
+ * Name of the request header that carries the per-request CSP nonce to server components.
+ *
+ * Server components read it via `next/headers` and must pass it to every inline `<script>` tag so
+ * the browser executes only scripts explicitly rendered by the server.
+ *
+ * @private function of middleware
+ */
+export const CONTENT_SECURITY_POLICY_NONCE_REQUEST_HEADER = 'x-csp-nonce';
+
+/**
+ * Length (in bytes) of the random material used to derive each per-request CSP nonce.
+ *
+ * 16 bytes (128 bits) is the value recommended by the W3C CSP3 specification — large enough to
+ * make guessing infeasible while keeping the base64 representation short.
+ *
+ * @private function of middleware
+ */
+const CONTENT_SECURITY_POLICY_NONCE_BYTE_LENGTH = 16;
+
+/**
+ * Generates a fresh, single-use CSP nonce encoded as base64.
+ *
+ * @returns Cryptographically random nonce safe to inline into a CSP header.
+ *
+ * @private function of middleware
+ */
+export function generateContentSecurityPolicyNonce(): string {
+    const randomBytes = new Uint8Array(CONTENT_SECURITY_POLICY_NONCE_BYTE_LENGTH);
+    crypto.getRandomValues(randomBytes);
+
+    let binaryString = '';
+    for (const byte of randomBytes) {
+        binaryString += String.fromCharCode(byte);
+    }
+
+    // Note: `btoa` is available in the Next.js Edge runtime where this middleware executes.
+    return btoa(binaryString);
+}
+
+/**
+ * Builds the strict Content Security Policy header value for the given nonce.
+ *
+ * The policy locks down `script-src` to nonced inline scripts and scripts loaded by them
+ * (`'strict-dynamic'`). The legacy fallbacks (`'unsafe-inline'`, `http:`, `https:`) are ignored
+ * by modern browsers that honor the nonce, but keep the page functional in older browsers
+ * without weakening security in modern ones.
+ *
+ * @param nonce - Per-request CSP nonce.
+ * @returns Serialized CSP header value.
+ *
+ * @private function of middleware
+ */
+function buildContentSecurityPolicyHeaderValue(nonce: string): string {
+    const directives = [
+        `script-src 'nonce-${nonce}' 'strict-dynamic' 'unsafe-inline' 'unsafe-eval' https: http:`,
+        `object-src 'none'`,
+        `base-uri 'self'`,
+    ];
+
+    return directives.join('; ');
+}
+
+/**
+ * Adds the CSP nonce headers to the forwarded request so server components and the Next.js
+ * runtime can detect the nonce and apply it to their own inline scripts.
+ *
+ * @param requestHeaders - Mutable headers object that is forwarded to the route handler.
+ * @param nonce - Per-request CSP nonce.
+ *
+ * @private function of middleware
+ */
+export function applyContentSecurityPolicyToRequestHeaders(requestHeaders: Headers, nonce: string): void {
+    requestHeaders.set(CONTENT_SECURITY_POLICY_NONCE_REQUEST_HEADER, nonce);
+
+    // Note: Next.js detects the nonce automatically when the CSP is also present on the
+    //       forwarded request headers — see https://nextjs.org/docs/app/guides/content-security-policy
+    requestHeaders.set('Content-Security-Policy', buildContentSecurityPolicyHeaderValue(nonce));
+}
+
+/**
+ * Adds the strict CSP response header so the browser enforces the nonced script policy.
+ *
+ * Helpers that add narrower directives (e.g. `applyEmbeddingHeader` with `frame-ancestors`)
+ * must `append` a separate CSP header rather than `set` so the strict `script-src` policy is
+ * preserved.
+ *
+ * @param response - Outgoing response.
+ * @param nonce - Per-request CSP nonce.
+ *
+ * @private function of middleware
+ */
+export function applyContentSecurityPolicyHeader(response: NextResponse, nonce: string): void {
+    response.headers.set('Content-Security-Policy', buildContentSecurityPolicyHeaderValue(nonce));
+}

package/apps/agents-server/src/middleware/resolveAccessControlResponse.ts

@@ -19,6 +19,7 @@ export async function resolveAccessControlResponse(options: {
     readonly request: NextRequest;
     readonly isAccessRestricted: boolean;
     readonly applyResponseHeaders: ApplyResponseHeaders;
+    readonly requestHeaders: Headers;
 }): Promise<NextResponse | null> {
     if (options.request.method === 'OPTIONS') {
         return createOptionsResponse();
@@ -31,7 +32,7 @@ export async function resolveAccessControlResponse(options: {
     const path = options.request.nextUrl.pathname;
 
     if (isAllowedPathWhileRestricted(path)) {
-        const response = NextResponse.next();
+        const response = NextResponse.next({ request: { headers: options.requestHeaders } });
         await options.applyResponseHeaders(response);
         return response;
     }
@@ -39,7 +40,7 @@ export async function resolveAccessControlResponse(options: {
     if (options.request.headers.get('accept')?.includes('text/html')) {
         const restrictedUrl = options.request.nextUrl.clone();
         restrictedUrl.pathname = '/restricted';
-        const response = NextResponse.rewrite(restrictedUrl);
+        const response = NextResponse.rewrite(restrictedUrl, { request: { headers: options.requestHeaders } });
         await options.applyResponseHeaders(response);
         return response;
     }

package/apps/agents-server/src/middleware/resolveMiddlewareResponse.ts

@@ -23,6 +23,7 @@ export async function resolveMiddlewareResponse(options: {
     readonly customDomainResolution: CustomDomainResolution | null;
     readonly isEmbeddingAllowed: boolean;
     readonly applyResponseHeaders: ApplyResponseHeaders;
+    readonly requestHeaders: Headers;
 }): Promise<NextResponse> {
     const rootAgentRedirectResponse = createRootAgentRedirectResponse(options.request);
     if (rootAgentRedirectResponse) {
@@ -33,15 +34,18 @@ export async function resolveMiddlewareResponse(options: {
     const customDomainRewriteResponse = createCustomDomainRewriteResponse(
         options.request,
         options.customDomainResolution,
+        options.requestHeaders,
     );
     if (customDomainRewriteResponse) {
         await options.applyResponseHeaders(customDomainRewriteResponse);
         return customDomainRewriteResponse;
     }
 
-    const response = NextResponse.next();
-    applyEmbeddingHeader(response, options.request.nextUrl, options.isEmbeddingAllowed);
+    const response = NextResponse.next({ request: { headers: options.requestHeaders } });
+    // Note: The base Content Security Policy is applied first so the embedding header can append its
+    //       own `frame-ancestors` directive without dropping the strict `script-src` policy.
     await options.applyResponseHeaders(response);
+    applyEmbeddingHeader(response, options.request.nextUrl, options.isEmbeddingAllowed);
     return response;
 }
 
@@ -78,6 +82,7 @@ function createRootAgentRedirectResponse(request: NextRequest): NextResponse | n
  *
  * @param request - Incoming middleware request.
  * @param customDomainResolution - Resolved custom-domain mapping.
+ * @param requestHeaders - Forwarded request headers already carrying the per-request CSP nonce.
  * @returns Rewrite response, or `null` when no custom-domain mapping exists.
  *
  * @private function of resolveMiddlewareResponse
@@ -85,6 +90,7 @@ function createRootAgentRedirectResponse(request: NextRequest): NextResponse | n
 function createCustomDomainRewriteResponse(
     request: NextRequest,
     customDomainResolution: CustomDomainResolution | null,
+    requestHeaders: Headers,
 ): NextResponse | null {
     if (!customDomainResolution) {
         return null;
@@ -93,7 +99,6 @@ function createCustomDomainRewriteResponse(
     const rewriteUrl = request.nextUrl.clone();
     rewriteUrl.pathname = `/${customDomainResolution.agentName}`;
 
-    const requestHeaders = new Headers(request.headers);
     requestHeaders.set('x-promptbook-server', customDomainResolution.server.domain);
 
     return NextResponse.rewrite(rewriteUrl, {

package/apps/agents-server/src/middleware.ts

@@ -1,9 +1,13 @@
 import { NextRequest, NextResponse } from 'next/server';
 import { applyVisibilityHeaders } from './middleware/applyVisibilityHeaders';
+import {
+    applyContentSecurityPolicyHeader,
+    applyContentSecurityPolicyToRequestHeaders,
+    generateContentSecurityPolicyNonce,
+} from './middleware/contentSecurityPolicy';
 import { createMiddlewareRequestContext } from './middleware/createMiddlewareRequestContext';
 import { resolveAccessControlResponse } from './middleware/resolveAccessControlResponse';
 import { resolveMiddlewareResponse } from './middleware/resolveMiddlewareResponse';
-import { writeShibbolethAuthenticationLog } from './utils/shibboleth/writeShibbolethAuthenticationLog';
 
 /**
  * Main Next.js middleware coordinating request context loading, access control,
@@ -13,17 +17,15 @@ import { writeShibbolethAuthenticationLog } from './utils/shibboleth/writeShibbo
  * @returns Middleware response.
  */
 export async function middleware(request: NextRequest): Promise<NextResponse> {
-    if (shouldLogShibbolethRequestFromMiddleware(request)) {
-        writeShibbolethAuthenticationLog(request.headers, {
-            event: 'middleware-request',
-            pathname: request.nextUrl.pathname,
-            method: request.method,
-            hasSessionCookie: request.cookies.has('sessionToken'),
-        });
-    }
+    // Note: A fresh, single-use nonce is issued per request so that only inline scripts explicitly
+    //       rendered by the server (theme bootstrap, custom JavaScript, analytics) are allowed to run.
+    const contentSecurityPolicyNonce = generateContentSecurityPolicyNonce();
+    const requestHeaders = new Headers(request.headers);
+    applyContentSecurityPolicyToRequestHeaders(requestHeaders, contentSecurityPolicyNonce);
 
     const middlewareRequestContext = await createMiddlewareRequestContext(request);
     const applyResponseHeaders = async (response: NextResponse): Promise<void> => {
+        applyContentSecurityPolicyHeader(response, contentSecurityPolicyNonce);
         await applyVisibilityHeaders({
             canQueryServerTables: middlewareRequestContext.canQueryServerTables,
             request,
@@ -37,6 +39,7 @@ export async function middleware(request: NextRequest): Promise<NextResponse> {
         applyResponseHeaders,
         isAccessRestricted: middlewareRequestContext.isAccessRestricted,
         request,
+        requestHeaders,
     });
 
     if (accessControlResponse) {
@@ -48,6 +51,7 @@ export async function middleware(request: NextRequest): Promise<NextResponse> {
         customDomainResolution: middlewareRequestContext.customDomainResolution,
         isEmbeddingAllowed: middlewareRequestContext.isEmbeddingAllowed,
         request,
+        requestHeaders,
     });
 }
 
@@ -63,30 +67,9 @@ export const config = {
          * - favicon.ico (favicon file)
          * - robots.txt (should not block on middleware DB lookups)
          * - public folder
+         * - api/health (standalone VPS readiness probe)
          * - api/internal (worker/cron routes are authorized separately)
          */
-        '/((?!_next/static|_next/image|favicon.ico|logo-|fonts/|robots.txt|api/internal).*)',
+        '/((?!_next/static|_next/image|favicon.ico|logo-|fonts/|robots.txt|api/health|api/internal).*)',
     ],
 };
-
-/**
- * Decides whether the current middleware request should emit Shibboleth diagnostics.
- *
- * We log the first anonymous request plus explicit auth/SAML routes so standalone VPS
- * pm2 logs show the incoming Shibboleth attributes without flooding every authenticated
- * page load once the browser already carries a session cookie.
- *
- * @param request - Incoming middleware request.
- * @returns `true` when the request is useful for Shibboleth diagnostics.
- */
-function shouldLogShibbolethRequestFromMiddleware(request: NextRequest): boolean {
-    const pathname = request.nextUrl.pathname.toLowerCase();
-    const isAuthenticationPath = pathname.startsWith('/api/auth');
-    const isShibbolethPath = pathname.includes('shibboleth') || pathname.includes('saml');
-
-    if (isAuthenticationPath || isShibbolethPath) {
-        return true;
-    }
-
-    return !request.cookies.has('sessionToken');
-}

package/apps/agents-server/src/search/createDefaultServerSearchProviders/createFederatedAgentsSearchProvider.ts

@@ -30,7 +30,7 @@ export function createFederatedAgentsSearchProvider(): ServerSearchProvider {
 
             let federatedServers: string[] = [];
             try {
-                federatedServers = await getFederatedServers({ excludeHiddenCoreServer: true });
+                federatedServers = await getFederatedServers();
             } catch (error) {
                 console.error('[search] Failed to load federated servers:', error);
                 return [];

package/apps/agents-server/src/sentry.edge.config.ts

@@ -0,0 +1,18 @@
+import * as Sentry from '@sentry/nextjs';
+import {
+    createSentrySdkTags,
+    resolveBrowserSentryDsn,
+    resolveSentrySdkEnvironment,
+    resolveSentrySdkRelease,
+    SENTRY_TRACES_SAMPLE_RATE,
+} from './utils/errorReporting/sentrySdkConfig';
+
+Sentry.init({
+    dsn: resolveBrowserSentryDsn(),
+    tracesSampleRate: SENTRY_TRACES_SAMPLE_RATE,
+    environment: resolveSentrySdkEnvironment(),
+    release: resolveSentrySdkRelease(),
+    initialScope: {
+        tags: createSentrySdkTags(),
+    },
+});

package/apps/agents-server/src/sentry.server.config.ts

@@ -0,0 +1,19 @@
+import * as Sentry from '@sentry/nextjs';
+import { createAgentsServerSentryContext } from './utils/errorReporting/agentsServerSentryContext';
+import { resolveServerSentryDsn, SENTRY_TRACES_SAMPLE_RATE } from './utils/errorReporting/sentrySdkConfig';
+
+/**
+ * Shared diagnostic context applied to server-side SDK events at initialization time.
+ */
+const agentsServerSentryContext = createAgentsServerSentryContext();
+
+Sentry.init({
+    dsn: resolveServerSentryDsn(),
+    tracesSampleRate: SENTRY_TRACES_SAMPLE_RATE,
+    environment: agentsServerSentryContext.environment,
+    release: agentsServerSentryContext.release,
+    initialScope: {
+        tags: agentsServerSentryContext.tags,
+        extra: agentsServerSentryContext.extra,
+    },
+});