claude-code-rust 0.9.0 → 0.11.0

package/agent-sdk/dist/bridge/mcp.js

@@ -1,6 +1,32 @@
 import { emitMcpOperationError, slashError, writeEvent } from "./events.js";
+import { bridgeLogger, LOG_TARGETS } from "./logger.js";
 export const MCP_STALE_STATUS_REVALIDATION_COOLDOWN_MS = 30_000;
 const knownConnectedMcpServers = new Set();
+function logMcpSuccess(eventName, message, sessionId, requestId, fields) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_MCP,
+        eventName,
+        message,
+        outcome: "success",
+        sessionId,
+        ...(requestId ? { requestId } : {}),
+        ...(fields ? { fields } : {}),
+    });
+}
+function logMcpFailure(eventName, message, sessionId, errorMessage, requestId, fields) {
+    bridgeLogger.warn({
+        target: LOG_TARGETS.BRIDGE_MCP,
+        eventName,
+        message,
+        outcome: "failure",
+        sessionId,
+        ...(requestId ? { requestId } : {}),
+        fields: {
+            ...(fields ?? {}),
+            error_message: errorMessage,
+        },
+    });
+}
 function queryWithMcpAuth(session) {
     return session.query;
 }
@@ -51,6 +77,9 @@ export async function emitMcpSnapshotEvent(session, requestId) {
     let mapped = servers.map(mapMcpServerStatus);
     mapped = await reconcileSuspiciousMcpStatuses(session, mapped);
     rememberKnownConnectedMcpServers(mapped);
+    logMcpSuccess("mcp_snapshot_emitted", "MCP snapshot emitted", session.sessionId, requestId, {
+        server_count: mapped.length,
+    });
     writeEvent({
         event: "mcp_snapshot",
         session_id: session.sessionId,
@@ -90,15 +119,36 @@ async function reconcileSuspiciousMcpStatuses(session, servers) {
     const now = Date.now();
     for (const serverName of candidates) {
         session.mcpStatusRevalidatedAt.set(serverName, now);
-        console.error(`[sdk mcp reconcile] session=${session.sessionId} server=${serverName} ` +
-            `status=needs-auth reason=previously-connected action=reconnect`);
+        bridgeLogger.info({
+            target: LOG_TARGETS.BRIDGE_MCP,
+            eventName: "mcp_auth_revalidation_started",
+            message: "revalidating stale MCP auth status",
+            outcome: "start",
+            sessionId: session.sessionId,
+            fields: {
+                server_name: serverName,
+                status: "needs-auth",
+                reason: "previously_connected",
+                action: "reconnect",
+            },
+        });
         try {
             await session.query.reconnectMcpServer(serverName);
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
-            console.error(`[sdk mcp reconcile] session=${session.sessionId} server=${serverName} ` +
-                `action=reconnect failed=${message}`);
+            bridgeLogger.warn({
+                target: LOG_TARGETS.BRIDGE_MCP,
+                eventName: "mcp_auth_revalidation_failed",
+                message: "failed to revalidate MCP auth status",
+                outcome: "failure",
+                sessionId: session.sessionId,
+                fields: {
+                    server_name: serverName,
+                    action: "reconnect",
+                    error_message: message,
+                },
+            });
         }
     }
     return (await session.query.mcpServerStatus()).map(mapMcpServerStatus);
@@ -137,6 +187,7 @@ export async function handleMcpStatusCommand(session, requestId) {
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        logMcpFailure("mcp_snapshot_failed", "failed to emit MCP snapshot", session.sessionId, message, requestId);
         writeEvent({
             event: "mcp_snapshot",
             session_id: session.sessionId,
@@ -148,27 +199,35 @@ export async function handleMcpStatusCommand(session, requestId) {
 export async function handleMcpReconnectCommand(session, command, requestId) {
     try {
         await session.query.reconnectMcpServer(command.server_name);
+        logMcpSuccess("mcp_reconnect_completed", "MCP reconnect completed", command.session_id, requestId, {
+            server_name: command.server_name,
+        });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        logMcpFailure("mcp_reconnect_failed", "MCP reconnect failed", command.session_id, message, requestId, { server_name: command.server_name });
         emitMcpCommandError(command.session_id, "reconnect", message, requestId, command.server_name);
     }
 }
 export async function handleMcpToggleCommand(session, command, requestId) {
     try {
         await session.query.toggleMcpServer(command.server_name, command.enabled);
+        logMcpSuccess("mcp_toggle_completed", "MCP server toggle completed", command.session_id, requestId, { server_name: command.server_name, enabled: command.enabled });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        logMcpFailure("mcp_toggle_failed", "MCP server toggle failed", command.session_id, message, requestId, { server_name: command.server_name, enabled: command.enabled });
         emitMcpCommandError(command.session_id, "toggle", message, requestId, command.server_name);
     }
 }
 export async function handleMcpSetServersCommand(session, command, requestId) {
     try {
         await session.query.setMcpServers(command.servers);
+        logMcpSuccess("mcp_servers_set_completed", "MCP server configuration updated", command.session_id, requestId, { server_count: Object.keys(command.servers).length });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        logMcpFailure("mcp_servers_set_failed", "failed to update MCP server configuration", command.session_id, message, requestId, { server_count: Object.keys(command.servers).length });
         slashError(command.session_id, `failed to set MCP servers: ${message}`, requestId);
     }
 }
@@ -177,16 +236,21 @@ export async function handleMcpAuthenticateCommand(session, command, requestId)
         const result = await callMcpAuthMethod(session, "mcpAuthenticate", [command.server_name]);
         const redirect = extractMcpAuthRedirect(command.server_name, result);
         if (redirect) {
+            logMcpSuccess("mcp_auth_redirect_emitted", "MCP auth redirect emitted", command.session_id, requestId, { server_name: command.server_name, requires_user_action: redirect.requires_user_action });
             writeEvent({
                 event: "mcp_auth_redirect",
                 session_id: command.session_id,
                 redirect,
-            });
+            }, requestId);
+        }
+        else {
+            logMcpSuccess("mcp_authenticate_completed", "MCP authentication command completed", command.session_id, requestId, { server_name: command.server_name });
         }
         scheduleMcpAuthSnapshotMonitor(session, command.server_name);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        logMcpFailure("mcp_authenticate_failed", "MCP authentication command failed", command.session_id, message, requestId, { server_name: command.server_name });
         emitMcpCommandError(command.session_id, "authenticate", message, requestId, command.server_name);
     }
 }
@@ -195,9 +259,13 @@ export async function handleMcpClearAuthCommand(session, command, requestId) {
         await callMcpAuthMethod(session, "mcpClearAuth", [command.server_name]);
         forgetKnownConnectedMcpServer(command.server_name);
         session.mcpStatusRevalidatedAt.delete(command.server_name);
+        logMcpSuccess("mcp_clear_auth_completed", "MCP auth cleared", command.session_id, requestId, {
+            server_name: command.server_name,
+        });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        logMcpFailure("mcp_clear_auth_failed", "failed to clear MCP auth", command.session_id, message, requestId, { server_name: command.server_name });
         emitMcpCommandError(command.session_id, "clear-auth", message, requestId, command.server_name);
     }
 }
@@ -207,9 +275,17 @@ export async function handleMcpOauthCallbackUrlCommand(session, command, request
             command.server_name,
             command.callback_url,
         ]);
+        logMcpSuccess("mcp_oauth_callback_completed", "MCP OAuth callback URL submitted", command.session_id, requestId, {
+            server_name: command.server_name,
+            callback_url_chars: command.callback_url.length,
+        });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        logMcpFailure("mcp_oauth_callback_failed", "failed to submit MCP OAuth callback URL", command.session_id, message, requestId, {
+            server_name: command.server_name,
+            callback_url_chars: command.callback_url.length,
+        });
         emitMcpCommandError(command.session_id, "submit-callback-url", message, requestId, command.server_name);
     }
 }