Register default Copilot user in Java e2e harness to fix MCP tests

CLI 1.0.64-1 gates MCP enablement on the /copilot_internal/user response.
Commit 9d696d2 routed that call directly to the replay proxy via
COPILOT_DEBUG_GITHUB_API_URL, but the Java harness never registered a
default user for the CLI's default token, so the proxy returned 401 'Bad
credentials'. With no user, the third-party MCP policy resolver could not
early-return allow-all and the MCP servers never reached CONNECTED, timing
out McpAndAgentsTest after 60s.

Register a default 'individual_pro' user at E2ETestContext.create(), matching
the Go, Node, Python, and .NET harnesses. The proxy adds is_mcp_enabled:true
(the global gate) and the snake_case copilot_plan makes the resolver
early-return allow-all for non-org plans, avoiding a /copilot/mcp_registry
call the proxy does not serve.

Add a raw-map setCopilotUserByToken overload to CapiProxy so the registered
user uses the same snake_case field shape the CLI reads; the existing 6-arg
camelCase overload (used by per-session auth tests) is unchanged.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: stephentoub

java/src/test/java/com/github/copilot/CapiProxy.java

@@ -290,6 +290,53 @@ public void setCopilotUserByToken(String token, String login, String copilotPlan
         }
     }
 
+    /**
+     * Registers a raw Copilot user response for a given token on the
+     * {@code /copilot_internal/user} endpoint.
+     *
+     * <p>
+     * Unlike
+     * {@link #setCopilotUserByToken(String, String, String, String, String, String)},
+     * this posts the response object verbatim, so callers control the exact field
+     * names the proxy returns to the CLI. This matters because the CLI reads
+     * snake_case fields (e.g. {@code copilot_plan}, {@code is_mcp_enabled}) from
+     * the raw user JSON to gate MCP enablement. Use this to register the default
+     * e2e user with the same snake_case shape the Go, Node, Python, and .NET
+     * harnesses post, keeping MCP behavior hermetic and consistent across SDKs.
+     * </p>
+     *
+     * @param token
+     *            the GitHub token to configure
+     * @param response
+     *            the raw user response object to return for the token (field names
+     *            are sent verbatim)
+     * @throws IOException
+     *             if the request fails
+     * @throws InterruptedException
+     *             if the request is interrupted
+     */
+    public void setCopilotUserByToken(String token, Map<String, Object> response)
+            throws IOException, InterruptedException {
+        if (proxyUrl == null) {
+            throw new IllegalStateException("Proxy not started");
+        }
+
+        Map<String, Object> payload = new java.util.HashMap<>();
+        payload.put("token", token);
+        payload.put("response", response);
+
+        String body = MAPPER.writeValueAsString(payload);
+
+        HttpRequest request = HttpRequest.newBuilder().uri(URI.create(proxyUrl + "/copilot-user-config"))
+                .header("Content-Type", "application/json").POST(HttpRequest.BodyPublishers.ofString(body)).build();
+
+        HttpResponse<String> response2 = httpClient.send(request, HttpResponse.BodyHandlers.ofString());
+        if (response2.statusCode() != 200) {
+            throw new IOException(
+                    "Failed to set copilot user config: " + response2.statusCode() + ": " + response2.body());
+        }
+    }
+
     /**
      * Stops the proxy server gracefully.
      *

java/src/test/java/com/github/copilot/E2ETestContext.java

@@ -55,6 +55,12 @@
 public class E2ETestContext implements AutoCloseable {
 
     private static final Logger LOG = Logger.getLogger(E2ETestContext.class.getName());
+
+    /**
+     * The default GitHub token used by the CLI in e2e tests. The proxy resolves
+     * this token to the default Copilot user registered at context creation.
+     */
+    private static final String DEFAULT_GITHUB_TOKEN = "fake-token-for-e2e-tests";
     private static final Pattern SNAKE_CASE = Pattern.compile("[^a-zA-Z0-9]");
     private static final Pattern USER_CONTENT_PATTERN = Pattern
             .compile("^\\s+-\\s+role:\\s+user\\s*$\\s+content:\\s*(.+?)$", Pattern.MULTILINE);
@@ -97,6 +103,23 @@ public static E2ETestContext create() throws IOException, InterruptedException {
         CapiProxy proxy = new CapiProxy();
         String proxyUrl = proxy.start();
 
+        // Register a default Copilot user for the CLI's default token so the proxy's
+        // /copilot_internal/user endpoint returns a valid user (HTTP 200) instead of
+        // 401 "Bad credentials". CLI 1.0.64-1 gates MCP enablement on this user:
+        // `is_mcp_enabled` (added by the proxy) is the global gate, and snake_case
+        // `copilot_plan` makes the third-party MCP policy resolver early-return
+        // allow-all for non-org plans (anything other than business/enterprise),
+        // avoiding a /copilot/mcp_registry network call the proxy does not serve.
+        // Without this, MCP servers never reach CONNECTED. This mirrors the Go,
+        // Node, Python, and .NET harnesses, which all register the same default
+        // individual_pro user at context creation.
+        Map<String, Object> defaultUser = new HashMap<>();
+        defaultUser.put("login", "e2e-test-user");
+        defaultUser.put("copilot_plan", "individual_pro");
+        defaultUser.put("endpoints", Map.of("api", proxyUrl, "telemetry", "https://localhost:1/telemetry"));
+        defaultUser.put("analytics_tracking_id", "e2e-test-tracking-id");
+        proxy.setCopilotUserByToken(DEFAULT_GITHUB_TOKEN, defaultUser);
+
         return new E2ETestContext(cliPath, homeDir, workDir, proxyUrl, proxy, repoRoot);
     }
 
@@ -282,8 +305,8 @@ public Map<String, String> getEnvironment() {
             env.put("REQUESTS_CA_BUNDLE", caFile);
             env.put("CURL_CA_BUNDLE", caFile);
             env.put("GIT_SSL_CAINFO", caFile);
-            env.put("GH_TOKEN", "fake-token-for-e2e-tests");
-            env.put("GITHUB_TOKEN", "fake-token-for-e2e-tests");
+            env.put("GH_TOKEN", DEFAULT_GITHUB_TOKEN);
+            env.put("GITHUB_TOKEN", DEFAULT_GITHUB_TOKEN);
             env.put("GH_ENTERPRISE_TOKEN", "");
             env.put("GITHUB_ENTERPRISE_TOKEN", "");
         }
@@ -298,7 +321,7 @@ public Map<String, String> getEnvironment() {
      */
     public CopilotClient createClient() {
         CopilotClientOptions options = new CopilotClientOptions().setCliPath(cliPath).setCwd(workDir.toString())
-                .setEnvironment(getEnvironment()).setGitHubToken("fake-token-for-e2e-tests");
+                .setEnvironment(getEnvironment()).setGitHubToken(DEFAULT_GITHUB_TOKEN);
 
         return new CopilotClient(options);
     }
@@ -323,7 +346,7 @@ public CopilotClient createClient(CopilotClientOptions options) {
             options.setEnvironment(getEnvironment());
         }
         if (options.getGitHubToken() == null) {
-            options.setGitHubToken("fake-token-for-e2e-tests");
+            options.setGitHubToken(DEFAULT_GITHUB_TOKEN);
         }
 
         return new CopilotClient(options);