19 Audit Nags in One Night: Making a Claude Code Stop Hook Detect Unattended Sessions

Introduction

Debugging an autonomous setup often requires addressing multiple issues simultaneously. This article delves into 19 common nags encountered in one night during the maintenance process. Specifically, we focus on how to improve the functionality of a Claude Code stop hook by detecting when it is running without any input or interaction. The goal is to ensure that the system does not consume unnecessary resources when there are no active users interacting with it.

Understanding the Context

In an autonomous setup like the one described in the source article, the Claude Code stop hook plays a crucial role in gracefully shutting down processes and services. However, there are situations where this hook may inadvertently stay active for extended periods without being interrupted by new input, leading to potential inefficiencies or resource leaks.

Identifying Common Nags

Before addressing any specific issue within the Claude Code environment, it’s important to identify common pitfalls and bugs that can arise due to improper configuration or misalignment with intended use cases. Some of these issues include:

Improving the Claude Code Stop Hook

To enhance the functionality of the stop hook, we will consider implementing improvements that address common nags such as detecting unattended sessions. Detecting a session as unattended can be done by monitoring for input events or idle periods without user interaction, which is especially useful in contexts where automatic shutdown might not be desirable.

Implementing Idle Detection

One effective way to detect when the system becomes unattended is by implementing a mechanism that monitors the absence of certain types of user inputs. This could involve tracking keyboard and mouse activity over a period of time. If no input is detected within this interval, we can consider the session as unattended and trigger appropriate actions.

Here’s how you might set up such an implementation in bash:

# Define timeout value (in seconds)
INPUT_TIMEOUT=120

# Function to check if idle for INPUT_TIMEOUT seconds
is_idle() {
    local last_input=$(grep -m 1 -oH "$(declare -p input_counter)" | cut -d ' ' -f3)
    echo $(( $(date +%s) - last_input ))
}

# Initialize an input counter with the current time as its value
input_counter=$(date)

while true; do
    # Check for keyboard and mouse input (pseudo implementation)
    # In real applications, you'd use something like `cat /dev/input/mouse0` or similar
    if [ "$(whoami)" != "root" ]; then
        echo "Input detected!"
        break  # Stop loop when user interacts again
    fi

    # Update input counter only after detecting new input
    [[ $input_counter = $(date) ]] && {
        echo -n "."
        sleep 0.25
    }
    input_counter=$(date)

    if [ "$(is_idle)" -ge "$INPUT_TIMEOUT" ]; then
        echo "No activity detected for $INPUT_TIMEOUT seconds."
        # Trigger shutdown logic here, e.g., calling the stop hook.
        echo "Shutting down due to inactivity..."
        # Stop hook logic goes here.
        break 2  # Exit both main loop and is_idle function
    }
done

This script initializes a timer input_counter which updates every second with current time. If no new input is detected within the timeout period, it considers the session as idle and triggers the shutdown logic.

Monitoring User Interaction

To track user interactions more accurately, you might consider monitoring common application events or user profiles for activities that indicate ongoing user engagement. For instance, checking file access patterns or network traffic could serve as indicators of an active session.

#### Tracking File Access Patterns

You can monitor file access using tools like find to see if any files are being modified frequently by the same user account. If not, it might be a sign that no one is actively interacting with your system anymore.

# Function to check for recent changes in files
is_file_activity() {
    find /path/to/files -mmin -30 | wc -l > /dev/null 2>&1 && echo "File activity detected" || echo "No file activity."
}

# Check if there is any file activity within the last 30 minutes
is_file_activity

Conclusion

By implementing mechanisms to detect when a session has become unattended, we can ensure that our Claude Code stop hook operates efficiently and doesn’t waste