test(upstream-auth): add tests for effective upstream auth handling and bearer auth without value_from_env

Author: David Ruzicka

src/mcp/mcp-server.test.ts

@@ -4837,6 +4837,106 @@ paths:
       });
     });
 
+    // -------------------------------------------------------------------------
+    describe('getEffectiveUpstreamAuth', () => {
+      it('skips oauth and returns bearer when interceptors.auth = [oauth, bearer]', async () => {
+        const provider = { ...upstreamProvider }; // no provider.auth
+        (upstreamServer as any).profile.interceptors = {
+          auth: [
+            { type: 'oauth' },
+            { type: 'bearer', value_from_env: 'BEARER_TOKEN' },
+          ],
+        };
+        (upstreamServer as any).httpTransport = {
+          ...(upstreamServer as any).httpTransport,
+          getUpstreamMcpConfig: () => provider,
+          getSessionToken: () => 'client-token',
+        };
+        try {
+          await (upstreamServer as any).handleOtherRequest(
+            { jsonrpc: '2.0', id: '1', method: 'tools/list', params: {} },
+            'session-123',
+            'upstream-profile',
+          );
+          // effectiveAuth should be bearer; effectiveProvider passed to client should have auth.type === 'bearer'
+          expect(mockGetUpstreamClient).toHaveBeenCalledWith(
+            'session-123',
+            expect.objectContaining({ auth: expect.objectContaining({ type: 'bearer' }) }),
+            'client-token',
+          );
+        } finally {
+          delete (upstreamServer as any).profile.interceptors;
+        }
+      });
+
+      it('returns undefined when interceptors.auth = [session-cookie] only', () => {
+        const server = new MCPServer();
+        (server as any).profile = {
+          profile_name: 'p',
+          tools: [],
+          interceptors: { auth: [{ type: 'session-cookie' }] },
+        };
+        const result = (server as any).getEffectiveUpstreamAuth({ name: 'x', transport: { type: 'http-streamable', url: 'https://example.com' } });
+        expect(result).toBeUndefined();
+      });
+
+      it('priority sort: lower priority value wins — query(priority:1) before bearer(priority:5)', () => {
+        const server = new MCPServer();
+        (server as any).profile = {
+          profile_name: 'p',
+          tools: [],
+          interceptors: {
+            auth: [
+              { type: 'bearer', value_from_env: 'T', priority: 5 },
+              { type: 'query', value_from_env: 'T', query_param: 'token', priority: 1 },
+            ],
+          },
+        };
+        const result = (server as any).getEffectiveUpstreamAuth({ name: 'x', transport: { type: 'http-streamable', url: 'https://example.com' } });
+        expect(result?.type).toBe('query');
+      });
+
+      it('uses provider.auth directly and ignores interceptors.auth when provider.auth set', () => {
+        const server = new MCPServer();
+        (server as any).profile = {
+          profile_name: 'p',
+          tools: [],
+          interceptors: { auth: [{ type: 'bearer', value_from_env: 'INTERCEPTOR_TOKEN' }] },
+        };
+        const providerAuth = { type: 'bearer' as const, value_from_env: 'PROVIDER_TOKEN' };
+        const result = (server as any).getEffectiveUpstreamAuth({
+          name: 'x',
+          transport: { type: 'http-streamable', url: 'https://example.com' },
+          auth: providerAuth,
+        });
+        expect(result).toBe(providerAuth);
+      });
+
+      it('blocks anonymous HTTP session when interceptors.auth contains only oauth (gate bypass fix)', async () => {
+        const provider = { ...upstreamProvider }; // no provider.auth
+        (upstreamServer as any).profile.interceptors = {
+          auth: [{ type: 'oauth' }],
+        };
+        (upstreamServer as any).httpTransport = {
+          ...(upstreamServer as any).httpTransport,
+          getUpstreamMcpConfig: () => provider,
+          getSessionToken: () => undefined, // anonymous HTTP session
+        };
+        try {
+          const response = await (upstreamServer as any).handleOtherRequest(
+            { jsonrpc: '2.0', id: '1', method: 'tools/list', params: {} },
+            'session-123',
+            'upstream-profile',
+          ) as any;
+          expect(mockGetUpstreamClient).not.toHaveBeenCalled();
+          expect(response.error).toBeDefined();
+          expect(response.error.code).toBe(-32603);
+        } finally {
+          delete (upstreamServer as any).profile.interceptors;
+        }
+      });
+    });
+
     // -------------------------------------------------------------------------
     describe('tool_prefix warning', () => {
       it('emits a warning when tool_prefix is configured', async () => {

src/mcp/mcp-server.ts

@@ -1848,8 +1848,8 @@ export class MCPServer {
     if (!raw) return undefined;
     const configs = Array.isArray(raw) ? raw : [raw];
     const sorted = [...configs].sort((a, b) => (a.priority ?? 0) - (b.priority ?? 0));
-    const selected = sorted.find(c => !['oauth', 'session-cookie'].includes(c.type)) ?? sorted[0];
-    if (!selected || !['bearer', 'query', 'custom-header'].includes(selected.type)) return undefined;
+    const selected = sorted.find(c => ['bearer', 'query', 'custom-header'].includes(c.type));
+    if (!selected) return undefined;
     return {
       type: selected.type as UpstreamMcpAuthConfig['type'],
       header_name: selected.header_name,
@@ -1877,8 +1877,14 @@ export class MCPServer {
     if (this.httpTransport && sessionId && profileId) {
       const sessionToken = this.httpTransport.getSessionToken(profileId, sessionId);
       if (sessionToken) return sessionToken;
-      // Reject anonymous HTTP sessions when auth is configured (directly or inherited)
-      if (effectiveAuth) {
+      // Reject anonymous HTTP sessions when ANY auth is configured (directly or inherited).
+      // effectiveAuth is undefined for oauth/session-cookie-only interceptors (those types can't
+      // be forwarded), but the presence of auth config still signals the endpoint must be protected.
+      const interceptorsAuth = this.profile?.interceptors?.auth;
+      const hasAnyInterceptorsAuth = Array.isArray(interceptorsAuth)
+        ? interceptorsAuth.length > 0
+        : !!interceptorsAuth;
+      if (provider.auth || hasAnyInterceptorsAuth) {
         throw new UpstreamConnectionError(
           'upstream_mcp proxy requires an authenticated HTTP session — ' +
           'the inbound client must supply a verified token.',

src/profile/upstream-mcp-config.test.ts

@@ -98,6 +98,15 @@ describe('resolveUpstreamMcpConfig – validator error branches', () => {
     expect(() => resolveUpstreamMcpConfig(profile)).toThrow(/value_from_env must not be empty/);
   });
 
+  it('accepts bearer auth without value_from_env (HTTP session-passthrough)', () => {
+    const profile = makeProfile({
+      name: 'p1',
+      transport: { type: 'http-streamable', url: 'https://example.com/mcp' },
+      auth: { type: 'bearer' },
+    });
+    expect(() => resolveUpstreamMcpConfig(profile)).not.toThrow();
+  });
+
   it('rejects custom-header auth with unsafe header_name', () => {
     const profile = makeProfile({
       name: 'p1',