claude-code-rust 0.9.0 → 0.10.0

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

@@ -2,9 +2,10 @@ import { randomUUID } from "node:crypto";
 import { spawn as spawnChild } from "node:child_process";
 import fs from "node:fs";
 import { query, } from "@anthropic-ai/claude-agent-sdk";
-import { AsyncQueue, logPermissionDebug } from "./shared.js";
-import { formatPermissionUpdates, permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./permissions.js";
-import { writeEvent, failConnection, emitSessionUpdate, emitConnectEvent, } from "./events.js";
+import { bridgeLogger, LOG_TARGETS, logSdkStderrLine } from "./logger.js";
+import { AsyncQueue } from "./shared.js";
+import { permissionOptionsFromSuggestions, permissionResultFromOutcome, } from "./permissions.js";
+import { failConnection, emitSessionUpdate, emitConnectEvent, emitPermissionRequestEvent, emitElicitationRequestEvent, } from "./events.js";
 import { ensureToolCallVisible, setToolCallStatus, } from "./tool_calls.js";
 import { requestExitPlanModeApproval, requestAskUserQuestionAnswers, EXIT_PLAN_MODE_TOOL_NAME, ASK_USER_QUESTION_TOOL_NAME, } from "./user_interaction.js";
 import { mapAvailableAgents, emitAvailableAgentsIfChanged, refreshAvailableAgents } from "./agents.js";
@@ -44,25 +45,50 @@ export async function closeSession(session) {
     }
     session.pendingElicitations.clear();
 }
-export async function closeAllSessions() {
+export async function closeSessionWithLogging(session, options = {}) {
+    await closeSession(session);
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_closed",
+        message: "session closed",
+        outcome: "success",
+        sessionId: session.sessionId,
+        ...(options.requestId ? { requestId: options.requestId } : {}),
+        fields: { reason: options.reason ?? "unspecified" },
+    });
+}
+export async function closeAllSessions(options = {}) {
     const active = Array.from(sessions.values());
     sessions.clear();
-    await Promise.all(active.map((session) => closeSession(session)));
+    await Promise.all(active.map((session) => closeSessionWithLogging(session, {
+        reason: options.reason ?? "bulk_close",
+        requestId: options.requestId,
+    })));
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "all_sessions_closed",
+        message: "all sessions closed",
+        outcome: "success",
+        ...(options.requestId ? { requestId: options.requestId } : {}),
+        count: active.length,
+        fields: { reason: options.reason ?? "bulk_close" },
+    });
 }
 export async function createSession(params) {
     const input = new AsyncQueue();
     const provisionalSessionId = params.resume ?? randomUUID();
     const initialModel = initialSessionModel(params.launchSettings);
     const initialMode = initialSessionMode(params.launchSettings);
+    const historyUpdateCount = params.resumeUpdates?.length ?? 0;
+    const staleSessionCount = params.sessionsToCloseAfterConnect?.length ?? 0;
     let session;
+    const sessionIdForLogs = () => session?.sessionId ?? provisionalSessionId;
     const canUseTool = async (toolName, inputData, options) => {
         const toolUseId = options.toolUseID;
         if (toolName === EXIT_PLAN_MODE_TOOL_NAME) {
             const existing = ensureToolCallVisible(session, toolUseId, toolName, inputData);
             return await requestExitPlanModeApproval(session, toolUseId, inputData, existing);
         }
-        logPermissionDebug(`request tool_use_id=${toolUseId} tool=${toolName} blocked_path=${options.blockedPath ?? "<none>"} ` +
-            `decision_reason=${options.decisionReason ?? "<none>"} suggestions=${formatPermissionUpdates(options.suggestions)}`);
         const existing = ensureToolCallVisible(session, toolUseId, toolName, inputData);
         if (toolName === ASK_USER_QUESTION_TOOL_NAME) {
             return await requestAskUserQuestionAnswers(session, toolUseId, inputData, existing);
@@ -71,7 +97,21 @@ export async function createSession(params) {
             tool_call: existing,
             options: permissionOptionsFromSuggestions(options.suggestions),
         };
-        writeEvent({ event: "permission_request", session_id: session.sessionId, request });
+        bridgeLogger.info({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "permission_request_created",
+            message: "permission request created",
+            outcome: "start",
+            sessionId: session.sessionId,
+            toolCallId: toolUseId,
+            count: request.options.length,
+            fields: {
+                tool_name: toolName,
+                blocked_path: options.blockedPath ?? "<none>",
+                decision_reason: options.decisionReason ?? "<none>",
+            },
+        });
+        emitPermissionRequestEvent(session.sessionId, request);
         return await new Promise((resolve) => {
             session.pendingPermissions.set(toolUseId, {
                 resolve,
@@ -89,6 +129,21 @@ export async function createSession(params) {
         throw new Error(`CLAUDE_CODE_EXECUTABLE does not exist: ${claudeCodeExecutable}`);
     }
     let queryHandle;
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_create_started",
+        message: "session creation started",
+        outcome: "start",
+        ...(params.requestId ? { requestId: params.requestId } : {}),
+        sessionId: provisionalSessionId,
+        fields: {
+            cwd: params.cwd,
+            connect_event: params.connectEvent,
+            resume_requested: params.resume !== undefined,
+            history_update_count: historyUpdateCount,
+            stale_session_count: staleSessionCount,
+        },
+    });
     try {
         queryHandle = query({
             prompt: input,
@@ -103,12 +158,25 @@ export async function createSession(params) {
                 sdkDebugFile,
                 enableSdkDebug,
                 enableSpawnDebug,
-                sessionIdForLogs: () => session.sessionId,
+                sessionIdForLogs,
             }),
         });
     }
     catch (error) {
         const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_query_failed",
+            message: "session query creation failed",
+            outcome: "failure",
+            ...(params.requestId ? { requestId: params.requestId } : {}),
+            sessionId: provisionalSessionId,
+            fields: {
+                cwd: params.cwd,
+                resume_requested: params.resume !== undefined,
+                error_message: message,
+            },
+        });
         throw new Error(`query() failed: node_executable=${process.execPath}; cwd=${params.cwd}; ` +
             `resume=${params.resume ?? "<none>"}; ` +
             `CLAUDE_CODE_EXECUTABLE=${claudeCodeExecutable ?? "<unset>"}; error=${message}`);
@@ -140,12 +208,51 @@ export async function createSession(params) {
             : {}),
     };
     sessions.set(provisionalSessionId, session);
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_query_started",
+        message: "session query started",
+        outcome: "success",
+        ...(params.requestId ? { requestId: params.requestId } : {}),
+        sessionId: session.sessionId,
+        fields: {
+            cwd: session.cwd,
+            connect_event: session.connectEvent,
+            resume_requested: params.resume !== undefined,
+        },
+    });
+    bridgeLogger.info({
+        target: LOG_TARGETS.APP_SESSION,
+        eventName: "session_create_registered",
+        message: "session registered in bridge state",
+        outcome: "success",
+        ...(params.requestId ? { requestId: params.requestId } : {}),
+        sessionId: session.sessionId,
+        count: sessions.size,
+        fields: {
+            active_session_count: sessions.size,
+            connect_event: session.connectEvent,
+        },
+    });
     // In stream-input mode the SDK may defer init until input arrives.
     // Trigger initialization explicitly so the Rust UI can receive `connected`
     // before the first user prompt.
     void session.query
         .initializationResult()
         .then((result) => {
+        bridgeLogger.info({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_initialization_completed",
+            message: "session initialization completed",
+            outcome: "success",
+            ...(session.connectRequestId ? { requestId: session.connectRequestId } : {}),
+            sessionId: session.sessionId,
+            fields: {
+                available_model_count: Array.isArray(result.models) ? result.models.length : 0,
+                connect_event: session.connectEvent,
+                history_update_count: session.resumeUpdates?.length ?? 0,
+            },
+        });
         session.availableModels = mapAvailableModels(result.models);
         if (!session.connected) {
             emitConnectEvent(session);
@@ -177,6 +284,15 @@ export async function createSession(params) {
             return;
         }
         const message = error instanceof Error ? error.message : String(error);
+        bridgeLogger.error({
+            target: LOG_TARGETS.APP_SESSION,
+            eventName: "session_initialization_failed",
+            message: "session initialization failed before connect",
+            outcome: "failure",
+            ...(session.connectRequestId ? { requestId: session.connectRequestId } : {}),
+            sessionId: session.sessionId,
+            fields: { error_message: message },
+        });
         failConnection(`agent initialization failed: ${message}`, session.connectRequestId);
         session.connectRequestId = undefined;
     });
@@ -188,15 +304,74 @@ export async function createSession(params) {
                 handleSdkMessage(session, message);
             }
             if (!session.connected) {
+                bridgeLogger.error({
+                    target: LOG_TARGETS.APP_SESSION,
+                    eventName: "session_stream_ended_before_connect",
+                    message: "session stream ended before connect",
+                    outcome: "failure",
+                    ...(params.requestId ? { requestId: params.requestId } : {}),
+                    sessionId: session.sessionId,
+                });
                 failConnection("agent stream ended before session initialization", params.requestId);
             }
         }
         catch (error) {
             const message = error instanceof Error ? error.message : String(error);
+            bridgeLogger.error({
+                target: LOG_TARGETS.APP_SESSION,
+                eventName: "session_stream_failed_before_connect",
+                message: "session stream failed before connect",
+                outcome: "failure",
+                ...(params.requestId ? { requestId: params.requestId } : {}),
+                sessionId: session.sessionId,
+                fields: { error_message: message },
+            });
             failConnection(`agent stream failed: ${message}`, params.requestId);
         }
     })();
 }
+function logSdkProcessSpawnStarted(options, includeArgsPreview) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_SDK,
+        eventName: "sdk_spawn_started",
+        message: "spawning Claude Code process",
+        outcome: "start",
+        fields: {
+            command: options.command,
+            cwd: options.cwd ?? "<none>",
+            arg_count: options.args.length,
+            ...(includeArgsPreview ? { args_preview: options.args.slice(0, 5) } : {}),
+        },
+    });
+}
+function logSdkProcessSpawned(sessionId, child, cwd) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_SDK,
+        eventName: "sdk_spawned",
+        message: "Claude Code process spawned",
+        outcome: "success",
+        ...(sessionId ? { sessionId } : {}),
+        fields: {
+            cwd: cwd ?? "<none>",
+            pid: child.pid ?? "<none>",
+        },
+    });
+}
+function logSdkProcessExit(sessionId, code, signal) {
+    const exitedCleanly = code === 0 && signal === null;
+    const logger = exitedCleanly ? bridgeLogger.info : bridgeLogger.warn;
+    logger({
+        target: LOG_TARGETS.BRIDGE_SDK,
+        eventName: "sdk_process_exited",
+        message: "Claude Code process exited",
+        outcome: exitedCleanly ? "success" : "failure",
+        ...(sessionId ? { sessionId } : {}),
+        fields: {
+            exit_code: code ?? "<none>",
+            exit_signal: signal ?? "<none>",
+        },
+    });
+}
 function permissionModeFromSettingsValue(rawMode) {
     if (typeof rawMode !== "string") {
         return undefined;
@@ -281,28 +456,37 @@ export function buildQueryOptions(params) {
         ...(params.sdkDebugFile ? { debugFile: params.sdkDebugFile } : {}),
         stderr: (line) => {
             if (line.trim().length > 0) {
-                console.error(`[sdk stderr] ${line}`);
+                logSdkStderrLine(line);
             }
         },
-        ...(params.enableSpawnDebug
-            ? {
-                spawnClaudeCodeProcess: (options) => {
-                    console.error(`[sdk spawn] command=${options.command} args=${JSON.stringify(options.args)} cwd=${options.cwd ?? "<none>"}`);
-                    const child = spawnChild(options.command, options.args, {
-                        cwd: options.cwd,
-                        env: options.env,
-                        signal: options.signal,
-                        stdio: ["pipe", "pipe", "pipe"],
-                        windowsHide: true,
-                    });
-                    child.on("error", (error) => {
-                        console.error(`[sdk spawn error] code=${error.code ?? "<none>"} message=${error.message}`);
-                    });
-                    return child;
-                },
-            }
-            : {}),
-        // Match claude-agent-acp defaults to avoid emitting an empty
+        spawnClaudeCodeProcess: (options) => {
+            logSdkProcessSpawnStarted(options, params.enableSpawnDebug);
+            const child = spawnChild(options.command, options.args, {
+                cwd: options.cwd,
+                env: options.env,
+                signal: options.signal,
+                stdio: ["pipe", "pipe", "pipe"],
+                windowsHide: true,
+            });
+            logSdkProcessSpawned(params.sessionIdForLogs() || undefined, child, options.cwd);
+            child.on("error", (error) => {
+                const sessionId = params.sessionIdForLogs();
+                bridgeLogger.error({
+                    target: LOG_TARGETS.BRIDGE_SDK,
+                    eventName: "sdk_spawn_failed",
+                    message: "Claude Code process spawn failed",
+                    outcome: "failure",
+                    ...(sessionId ? { sessionId } : {}),
+                    errorCode: error.code ?? "<none>",
+                    fields: { error_message: error.message },
+                });
+            });
+            child.on("exit", (code, signal) => {
+                logSdkProcessExit(params.sessionIdForLogs() || undefined, code, signal);
+            });
+            return child;
+        },
+        // Match the Claude Code CLI defaults to avoid emitting an empty
         // --setting-sources argument.
         settingSources: DEFAULT_SETTING_SOURCES,
         resume: params.resume,
@@ -333,14 +517,32 @@ export function buildQueryOptions(params) {
                     ? { requested_schema: request.requestedSchema }
                     : {}),
             };
-            writeEvent({
-                event: "elicitation_request",
-                session_id: params.sessionIdForLogs(),
-                request: normalized,
+            bridgeLogger.info({
+                target: LOG_TARGETS.BRIDGE_PERMISSION,
+                eventName: "elicitation_request_created",
+                message: "elicitation request created",
+                outcome: "start",
+                sessionId: params.sessionIdForLogs(),
+                requestId,
+                fields: {
+                    server_name: normalized.server_name,
+                    mode: normalized.mode,
+                    has_url: normalized.url !== undefined,
+                },
             });
+            emitElicitationRequestEvent(params.sessionIdForLogs(), normalized);
             return await new Promise((resolve) => {
                 const currentSession = sessions.get(params.sessionIdForLogs());
                 if (!currentSession) {
+                    bridgeLogger.warn({
+                        target: LOG_TARGETS.BRIDGE_PERMISSION,
+                        eventName: "elicitation_request_dropped",
+                        message: "elicitation request dropped without an active session",
+                        outcome: "dropped",
+                        sessionId: params.sessionIdForLogs(),
+                        requestId,
+                        fields: { reason: "unknown_session" },
+                    });
                     resolve({ action: "cancel" });
                     return;
                 }
@@ -386,29 +588,76 @@ export function mapAvailableModels(models) {
     }));
 }
 export function handlePermissionResponse(command) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "permission_response_received",
+        message: "permission response received",
+        outcome: "success",
+        sessionId: command.session_id,
+        toolCallId: command.tool_call_id,
+        fields: {
+            response_kind: command.outcome.outcome,
+            selected_option: command.outcome.outcome === "selected" ? command.outcome.option_id : "cancelled",
+        },
+    });
     const session = sessionById(command.session_id);
     if (!session) {
-        logPermissionDebug(`response dropped: unknown session session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "permission_response_dropped",
+            message: "permission response dropped for unknown session",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: { reason: "unknown_session" },
+        });
         return;
     }
     const resolver = session.pendingPermissions.get(command.tool_call_id);
     if (!resolver) {
-        logPermissionDebug(`response dropped: no pending resolver session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "permission_response_dropped",
+            message: "permission response dropped without a pending resolver",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: { reason: "missing_pending_resolver" },
+        });
         return;
     }
     session.pendingPermissions.delete(command.tool_call_id);
     const outcome = command.outcome;
     if (resolver.onOutcome) {
+        bridgeLogger.info({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "permission_response_applied",
+            message: "permission response applied to outcome callback",
+            outcome: "success",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: {
+                tool_name: resolver.toolName,
+                response_kind: outcome.outcome,
+                selected_option: outcome.outcome === "selected" ? outcome.option_id : "cancelled",
+            },
+        });
         resolver.onOutcome(outcome);
         return;
     }
     if (!resolver.resolve) {
-        logPermissionDebug(`response dropped: resolver missing callback session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "permission_response_dropped",
+            message: "permission response dropped because resolver callback was missing",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: { reason: "missing_resolver_callback" },
+        });
         return;
     }
     const selectedOption = outcome.outcome === "selected" ? outcome.option_id : "cancelled";
-    logPermissionDebug(`response session_id=${command.session_id} tool_call_id=${command.tool_call_id} tool=${resolver.toolName} ` +
-        `selected=${selectedOption} suggestions=${formatPermissionUpdates(resolver.suggestions)}`);
     if (outcome.outcome === "selected" &&
         (outcome.option_id === "allow_once" ||
             outcome.option_id === "allow_session" ||
@@ -422,43 +671,128 @@ export function handlePermissionResponse(command) {
         setToolCallStatus(session, command.tool_call_id, "failed", "Permission cancelled");
     }
     const permissionResult = permissionResultFromOutcome(outcome, command.tool_call_id, resolver.inputData, resolver.suggestions, resolver.toolName);
-    if (permissionResult.behavior === "allow") {
-        logPermissionDebug(`result tool_call_id=${command.tool_call_id} behavior=allow updated_permissions=` +
-            `${formatPermissionUpdates(permissionResult.updatedPermissions)}`);
-    }
-    else {
-        logPermissionDebug(`result tool_call_id=${command.tool_call_id} behavior=deny message=${permissionResult.message}`);
-    }
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "permission_response_applied",
+        message: "permission response applied",
+        outcome: "success",
+        sessionId: command.session_id,
+        toolCallId: command.tool_call_id,
+        fields: {
+            tool_name: resolver.toolName,
+            response_kind: outcome.outcome,
+            selected_option: selectedOption,
+            behavior: permissionResult.behavior,
+        },
+    });
     resolver.resolve(permissionResult);
 }
 export function handleQuestionResponse(command) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "question_response_received",
+        message: "question response received",
+        outcome: "success",
+        sessionId: command.session_id,
+        toolCallId: command.tool_call_id,
+        fields: { response_kind: command.outcome.outcome },
+    });
     const session = sessionById(command.session_id);
     if (!session) {
-        logPermissionDebug(`question response dropped: unknown session session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "question_response_dropped",
+            message: "question response dropped for unknown session",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: { reason: "unknown_session" },
+        });
         return;
     }
     const resolver = session.pendingQuestions.get(command.tool_call_id);
     if (!resolver) {
-        logPermissionDebug(`question response dropped: no pending resolver session_id=${command.session_id} tool_call_id=${command.tool_call_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "question_response_dropped",
+            message: "question response dropped without a pending resolver",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            toolCallId: command.tool_call_id,
+            fields: { reason: "missing_pending_resolver" },
+        });
         return;
     }
     session.pendingQuestions.delete(command.tool_call_id);
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "question_response_applied",
+        message: "question response applied",
+        outcome: "success",
+        sessionId: command.session_id,
+        toolCallId: command.tool_call_id,
+        fields: {
+            tool_name: resolver.toolName,
+            response_kind: command.outcome.outcome,
+            selected_option_count: command.outcome.outcome === "answered" ? command.outcome.selected_option_ids.length : 0,
+            has_annotation: command.outcome.outcome === "answered" && command.outcome.annotation !== undefined,
+        },
+    });
     resolver.onOutcome(command.outcome);
 }
 export function handleElicitationResponse(command) {
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "elicitation_response_received",
+        message: "elicitation response received",
+        outcome: "success",
+        sessionId: command.session_id,
+        requestId: command.elicitation_request_id,
+        fields: {
+            action: command.action,
+            has_content: command.content !== undefined,
+        },
+    });
     const session = sessionById(command.session_id);
     if (!session) {
-        console.error(`[sdk warn] elicitation response dropped: unknown session ` +
-            `session_id=${command.session_id} request_id=${command.elicitation_request_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "elicitation_response_dropped",
+            message: "elicitation response dropped for unknown session",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            requestId: command.elicitation_request_id,
+            fields: { reason: "unknown_session" },
+        });
         return;
     }
     const pending = session.pendingElicitations.get(command.elicitation_request_id);
     if (!pending) {
-        console.error(`[sdk warn] elicitation response dropped: no pending request ` +
-            `session_id=${command.session_id} request_id=${command.elicitation_request_id}`);
+        bridgeLogger.warn({
+            target: LOG_TARGETS.BRIDGE_PERMISSION,
+            eventName: "elicitation_response_dropped",
+            message: "elicitation response dropped without pending request",
+            outcome: "dropped",
+            sessionId: command.session_id,
+            requestId: command.elicitation_request_id,
+            fields: { reason: "missing_pending_request" },
+        });
         return;
     }
     session.pendingElicitations.delete(command.elicitation_request_id);
+    bridgeLogger.info({
+        target: LOG_TARGETS.BRIDGE_PERMISSION,
+        eventName: "elicitation_response_applied",
+        message: "elicitation response applied",
+        outcome: "success",
+        sessionId: command.session_id,
+        requestId: command.elicitation_request_id,
+        fields: {
+            action: command.action,
+            server_name: pending.serverName,
+            has_content: command.content !== undefined,
+        },
+    });
     pending.resolve({
         action: command.action,
         ...(command.content ? { content: command.content } : {}),

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

@@ -46,10 +46,3 @@ export class AsyncQueue {
         };
     }
 }
-const permissionDebugEnabled = process.env.CLAUDE_RS_SDK_PERMISSION_DEBUG === "1" || process.env.CLAUDE_RS_SDK_DEBUG === "1";
-export function logPermissionDebug(message) {
-    if (!permissionDebugEnabled) {
-        return;
-    }
-    console.error(`[perm debug] ${message}`);
-}