claude-code-rust 0.9.0 → 0.10.0

package/README.md

@@ -68,8 +68,14 @@ This project is pre-1.0 and under active development. See [CONTRIBUTING.md](CONT
 This project is licensed under the [Apache License 2.0](LICENSE).
 Apache-2.0 was chosen to keep usage and redistribution straightforward for individual users, downstream packagers, and commercial adopters.
 
-## Disclaimer
+## Disclaimer and Legal Notice
+
+This project is not affiliated with, endorsed by, or supported by Anthropic.
+
+A quick note on where this project stands, since I know people worry about this kind of thing: claude-code-rust is a terminal UI that I wrote from scratch in Rust. It is not a fork, copy or port of the latest Claude Code source leak -- it talks to Anthropic's official [Agent SDK](https://docs.anthropic.com/en/docs/agents-and-tools/claude-code/agent-sdk) as a runtime dependency instead, the same way any other third-party tool would. No Anthropic source code was read or used as reference at any point during development.
+
+The project uses your existing Claude Code subscription via the Agent SDK and the Agent SDK's terms allow building on top of it. Other community projects do the same. As far as I can tell, using this project is fine -- but I am a single maintainer, not a lawyer. If anything changes on Anthropic's end, I will update this section and adjust the project accordingly.
+
+This project's source code is licensed under [Apache-2.0](LICENSE). The Agent SDK itself is proprietary and governed by [Anthropic's Commercial Terms of Service](https://www.anthropic.com/legal/commercial-terms).
 
-This project is an unofficial terminal UI for Claude Code and is not affiliated with, endorsed by, or supported by Anthropic.
-Use it at your own risk.
 For official Claude documentation, see [https://claude.ai/docs](https://claude.ai/docs).

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

@@ -1,6 +1,7 @@
 import { listSessions } from "@anthropic-ai/claude-agent-sdk";
 import { buildModeState } from "./commands.js";
 import { mapSdkSessions } from "./history.js";
+import { bridgeLogger, LOG_TARGETS, logBridgeEventSent } from "./logger.js";
 const SESSION_LIST_LIMIT = 50;
 let sessionListingDir;
 export function buildSessionListOptions(dir, limit = SESSION_LIST_LIMIT) {
@@ -17,7 +18,9 @@ export function writeEvent(event, requestId) {
         ...(requestId ? { request_id: requestId } : {}),
         ...event,
     };
-    process.stdout.write(`${JSON.stringify(envelope)}\n`);
+    const serialized = JSON.stringify(envelope);
+    logBridgeEventSent(event, requestId, Buffer.byteLength(serialized) + 1);
+    process.stdout.write(`${serialized}\n`);
 }
 export function failConnection(message, requestId) {
     writeEvent({ event: "connection_failed", message }, requestId);
@@ -31,9 +34,60 @@ export function emitMcpOperationError(sessionId, error, requestId) {
 export function emitSessionUpdate(sessionId, update) {
     writeEvent({ event: "session_update", session_id: sessionId, update });
 }
-export function emitConnectEvent(session) {
+export function emitPermissionRequestEvent(sessionId, request) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "permission_request_emitted",
+        message: "permission request emitted",
+        outcome: "success",
+        sessionId,
+        toolCallId: request.tool_call.tool_call_id,
+        count: request.options.length,
+        fields: {
+            option_count: request.options.length,
+            tool_title: request.tool_call.title,
+        },
+    });
+    writeEvent({ event: "permission_request", session_id: sessionId, request });
+}
+export function emitQuestionRequestEvent(sessionId, request) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "question_request_emitted",
+        message: "question request emitted",
+        outcome: "success",
+        sessionId,
+        toolCallId: request.tool_call.tool_call_id,
+        count: request.prompt.options.length,
+        fields: {
+            question_index: request.question_index,
+            total_questions: request.total_questions,
+            option_count: request.prompt.options.length,
+            header: request.prompt.header,
+        },
+    });
+    writeEvent({ event: "question_request", session_id: sessionId, request });
+}
+export function emitElicitationRequestEvent(sessionId, request) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "elicitation_request_emitted",
+        message: "elicitation request emitted",
+        outcome: "success",
+        sessionId,
+        requestId: request.request_id,
+        fields: {
+            server_name: request.server_name,
+            mode: request.mode,
+            has_url: request.url !== undefined,
+            has_requested_schema: request.requested_schema !== undefined,
+        },
+    });
+    writeEvent({ event: "elicitation_request", session_id: sessionId, request });
+}
+function buildConnectBridgeEvent(session, eventName) {
     const historyUpdates = session.resumeUpdates;
-    const connectEvent = session.connectEvent === "session_replaced"
+    return eventName === "session_replaced"
         ? {
             event: "session_replaced",
             session_id: session.sessionId,
@@ -52,7 +106,26 @@ export function emitConnectEvent(session) {
             mode: session.mode ? buildModeState(session.mode) : null,
             ...(historyUpdates && historyUpdates.length > 0 ? { history_updates: historyUpdates } : {}),
         };
-    writeEvent(connectEvent, session.connectRequestId);
+}
+function logConnectEventEmission(session, eventName, requestId) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: eventName === "session_replaced" ? "session_replaced_emitted" : "session_connected_emitted",
+        message: eventName === "session_replaced" ? "session replaced event emitted" : "session connected event emitted",
+        outcome: "success",
+        ...(requestId ? { requestId } : {}),
+        sessionId: session.sessionId,
+        fields: {
+            history_update_count: session.resumeUpdates?.length ?? 0,
+            available_model_count: session.availableModels.length,
+            stale_session_count: session.sessionsToCloseAfterConnect?.length ?? 0,
+        },
+    });
+}
+export function emitConnectEvent(session) {
+    const bridgeEvent = buildConnectBridgeEvent(session, session.connectEvent);
+    logConnectEventEmission(session, session.connectEvent, session.connectRequestId);
+    writeEvent(bridgeEvent, session.connectRequestId);
     session.connectRequestId = undefined;
     session.connected = true;
     session.authHintSent = false;
@@ -65,7 +138,7 @@ export function emitConnectEvent(session) {
     }
     void (async () => {
         // Lazy import to break circular dependency at module-evaluation time.
-        const { sessions, closeSession } = await import("./session_lifecycle.js");
+        const { sessions, closeSessionWithLogging } = await import("./session_lifecycle.js");
         for (const stale of staleSessions) {
             if (stale === session) {
                 continue;
@@ -73,19 +146,54 @@ export function emitConnectEvent(session) {
             if (sessions.get(stale.sessionId) === stale) {
                 sessions.delete(stale.sessionId);
             }
-            await closeSession(stale);
+            await closeSessionWithLogging(stale, { reason: "stale_after_connect" });
         }
         refreshSessionsList();
     })();
 }
+export function emitSessionReplacedEvent(session, requestId) {
+    const bridgeEvent = buildConnectBridgeEvent(session, "session_replaced");
+    logConnectEventEmission(session, "session_replaced", requestId);
+    writeEvent(bridgeEvent, requestId);
+    session.resumeUpdates = undefined;
+    refreshSessionsList();
+}
 export async function emitSessionsList(requestId) {
+    bridgeLogger.debug({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "sessions_list_requested",
+        message: "sessions list requested",
+        outcome: "start",
+        ...(requestId ? { requestId } : {}),
+        fields: {
+            has_listing_dir: sessionListingDir !== undefined,
+            limit: SESSION_LIST_LIMIT,
+        },
+    });
     try {
         const sdkSessions = await listSessions(currentSessionListOptions());
-        writeEvent({ event: "sessions_listed", sessions: mapSdkSessions(sdkSessions, SESSION_LIST_LIMIT) }, requestId);
+        const sessions = mapSdkSessions(sdkSessions, SESSION_LIST_LIMIT);
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "sessions_list_completed",
+            message: "sessions list completed",
+            outcome: "success",
+            ...(requestId ? { requestId } : {}),
+            count: sessions.length,
+            fields: { session_count: sessions.length },
+        });
+        writeEvent({ event: "sessions_listed", sessions }, requestId);
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
-        console.error(`[sdk warn] listSessions failed: ${message}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "sessions_list_failed",
+            message: "failed to list SDK sessions",
+            outcome: "failure",
+            ...(requestId ? { requestId } : {}),
+            fields: { error_message: message },
+        });
         writeEvent({ event: "sessions_listed", sessions: [] }, requestId);
     }
 }

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

@@ -0,0 +1,245 @@
+const LOG_SCHEMA = "claude-rs-log/v1";
+const DIAGNOSTICS_ENABLED = process.env.CLAUDE_RS_BRIDGE_DIAGNOSTICS === "1";
+export const LOG_TARGETS = {
+    APP_AUTH: "app.auth",
+    APP_CACHE: "app.cache",
+    APP_CONFIG: "app.config",
+    APP_COMMAND: "app.command",
+    APP_NETWORK: "app.network",
+    APP_INPUT: "app.input",
+    APP_PASTE: "app.paste",
+    APP_PERF: "app.perf",
+    APP_RENDER: "app.render",
+    APP_SESSION: "app.session",
+    APP_TOOL: "app.tool",
+    APP_UPDATE: "app.update",
+    BRIDGE_LIFECYCLE: "bridge.lifecycle",
+    BRIDGE_MCP: "bridge.mcp",
+    BRIDGE_PERMISSION: "bridge.permission",
+    BRIDGE_PROTOCOL: "bridge.protocol",
+    BRIDGE_SDK: "bridge.sdk",
+};
+function definedFields(fields) {
+    if (!fields) {
+        return undefined;
+    }
+    const entries = Object.entries(fields).filter(([, value]) => value !== undefined);
+    return entries.length > 0 ? Object.fromEntries(entries) : undefined;
+}
+function writeDiagnostic(level, event) {
+    if (!DIAGNOSTICS_ENABLED) {
+        return;
+    }
+    const envelope = {
+        schema: LOG_SCHEMA,
+        timestamp: new Date().toISOString(),
+        level,
+        target: event.target,
+        event_name: event.eventName,
+        message: event.message,
+        ...(event.outcome ? { outcome: event.outcome } : {}),
+        ...(event.sessionId ? { session_id: event.sessionId } : {}),
+        ...(event.requestId ? { request_id: event.requestId } : {}),
+        ...(event.toolCallId ? { tool_call_id: event.toolCallId } : {}),
+        ...(event.commandId ? { command_id: event.commandId } : {}),
+        ...(event.terminalId ? { terminal_id: event.terminalId } : {}),
+        ...(event.errorKind ? { error_kind: event.errorKind } : {}),
+        ...(event.errorCode ? { error_code: event.errorCode } : {}),
+        ...(event.durationMs !== undefined ? { duration_ms: event.durationMs } : {}),
+        ...(event.count !== undefined ? { count: event.count } : {}),
+        ...(event.sizeBytes !== undefined ? { size_bytes: event.sizeBytes } : {}),
+    };
+    const fields = definedFields(event.fields);
+    if (fields) {
+        envelope.fields = fields;
+    }
+    process.stderr.write(`${JSON.stringify(envelope)}\n`);
+}
+function previewText(value, limit) {
+    return value.length > limit ? `${value.slice(0, limit)}...` : value;
+}
+function commandSessionId(command) {
+    switch (command.command) {
+        case "resume_session":
+        case "prompt":
+        case "cancel_turn":
+        case "set_model":
+        case "set_mode":
+        case "generate_session_title":
+        case "rename_session":
+        case "permission_response":
+        case "question_response":
+        case "elicitation_response":
+        case "get_status_snapshot":
+        case "mcp_status":
+        case "mcp_reconnect":
+        case "mcp_toggle":
+        case "mcp_set_servers":
+        case "mcp_authenticate":
+        case "mcp_clear_auth":
+        case "mcp_oauth_callback_url":
+            return command.session_id;
+        case "create_session":
+            return command.resume;
+        case "initialize":
+        case "new_session":
+        case "shutdown":
+            return undefined;
+    }
+}
+function commandToolCallId(command) {
+    switch (command.command) {
+        case "permission_response":
+        case "question_response":
+            return command.tool_call_id;
+        case "initialize":
+        case "create_session":
+        case "resume_session":
+        case "prompt":
+        case "cancel_turn":
+        case "set_model":
+        case "set_mode":
+        case "generate_session_title":
+        case "rename_session":
+        case "new_session":
+        case "elicitation_response":
+        case "get_status_snapshot":
+        case "mcp_status":
+        case "mcp_reconnect":
+        case "mcp_toggle":
+        case "mcp_set_servers":
+        case "mcp_authenticate":
+        case "mcp_clear_auth":
+        case "mcp_oauth_callback_url":
+        case "shutdown":
+            return undefined;
+    }
+}
+function eventToolCallId(event) {
+    switch (event.event) {
+        case "permission_request":
+        case "question_request":
+            return event.request.tool_call.tool_call_id;
+        case "connected":
+        case "auth_required":
+        case "connection_failed":
+        case "session_update":
+        case "elicitation_request":
+        case "elicitation_complete":
+        case "mcp_auth_redirect":
+        case "mcp_operation_error":
+        case "turn_complete":
+        case "turn_error":
+        case "slash_error":
+        case "session_replaced":
+        case "initialized":
+        case "sessions_listed":
+        case "status_snapshot":
+        case "mcp_snapshot":
+            return undefined;
+    }
+}
+function protocolCommandLevel(command) {
+    switch (command.command) {
+        case "initialize":
+        case "create_session":
+        case "resume_session":
+        case "new_session":
+        case "shutdown":
+            return "info";
+        default:
+            return "debug";
+    }
+}
+function protocolEventLevel(event) {
+    switch (event.event) {
+        case "initialized":
+        case "connected":
+        case "session_replaced":
+            return "info";
+        case "connection_failed":
+            return "error";
+        case "auth_required":
+        case "mcp_operation_error":
+        case "turn_error":
+        case "slash_error":
+            return "warn";
+        case "session_update":
+        case "permission_request":
+        case "question_request":
+        case "elicitation_request":
+        case "elicitation_complete":
+        case "mcp_auth_redirect":
+        case "turn_complete":
+            return "trace";
+        case "sessions_listed":
+        case "status_snapshot":
+        case "mcp_snapshot":
+            return "debug";
+    }
+}
+export const bridgeLogger = {
+    error(event) {
+        writeDiagnostic("error", event);
+    },
+    warn(event) {
+        writeDiagnostic("warn", event);
+    },
+    info(event) {
+        writeDiagnostic("info", event);
+    },
+    debug(event) {
+        writeDiagnostic("debug", event);
+    },
+    trace(event) {
+        writeDiagnostic("trace", event);
+    },
+};
+export function logSdkStderrLine(line, sessionId) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) {
+        return;
+    }
+    const lowered = trimmed.toLowerCase();
+    const level = lowered.startsWith("error") || lowered.includes("panic")
+        ? "error"
+        : lowered.startsWith("warn")
+            ? "warn"
+            : "debug";
+    writeDiagnostic(level, {
+        target: LOG_TARGETS.BRIDGE_SDK,
+        eventName: "sdk_stderr_line",
+        message: "SDK stderr line received",
+        ...(sessionId ? { sessionId } : {}),
+        fields: {
+            preview: previewText(trimmed, 240),
+            preview_chars: Math.min(trimmed.length, 240),
+            line_chars: trimmed.length,
+        },
+    });
+}
+export function logBridgeCommandReceived(command, requestId) {
+    writeDiagnostic(protocolCommandLevel(command), {
+        target: LOG_TARGETS.BRIDGE_PROTOCOL,
+        eventName: "bridge_command_received",
+        message: "bridge command received",
+        outcome: "success",
+        ...(requestId ? { requestId } : {}),
+        ...(commandSessionId(command) ? { sessionId: commandSessionId(command) } : {}),
+        ...(commandToolCallId(command) ? { toolCallId: commandToolCallId(command) } : {}),
+        fields: { bridge_command: command.command },
+    });
+}
+export function logBridgeEventSent(event, requestId, sizeBytes) {
+    writeDiagnostic(protocolEventLevel(event), {
+        target: LOG_TARGETS.BRIDGE_PROTOCOL,
+        eventName: "bridge_event_sent",
+        message: "bridge event sent",
+        outcome: event.event === "connection_failed" ? "failure" : "success",
+        ...(requestId ? { requestId } : {}),
+        ...("session_id" in event ? { sessionId: event.session_id } : {}),
+        ...(eventToolCallId(event) ? { toolCallId: eventToolCallId(event) } : {}),
+        sizeBytes,
+        fields: { bridge_event: event.event },
+    });
+}

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);
     }
 }