decouple the key listener from the main window

# Conflicts:
#	pom.xml

.drone.yml

@@ -1,27 +1,32 @@
 kind: pipeline
-name: default
+name: verify
 platform:
   os: linux
   arch: arm64
 
+trigger:
+  event:
+    - push
+    - pull_request
+
 steps:
   # test if it compiles correctly
   - name: build
-    image: maven:3-eclipse-temurin-17
+    image: maven:3-eclipse-temurin-25
     commands:
-      - mvn verify --no-transfer-progress -DskipTests=true -Dmaven.javadoc.skip=true -B -V
+      - ./mvnw verify --no-transfer-progress -DskipTests=true -Dmaven.javadoc.skip=true -B -V
 
   # run unit tests
   - name: test
-    image: maven:3-eclipse-temurin-17
+    image: maven:3-eclipse-temurin-25
     commands:
-      - mvn test --no-transfer-progress -B -V
+      - ./mvnw test --no-transfer-progress -B -V
 
   # run code analysis
   - name: code-analysis
-    image: maven:3-eclipse-temurin-17
+    image: maven:3-eclipse-temurin-25
     commands:
-      - mvn sonar:sonar --no-transfer-progress -Dsonar.projectKey=$SONAR_PROJECT_KEY -Dsonar.host.url=$SONAR_INSTANCE_URL -Dsonar.login=$SONAR_LOGIN_KEY -B -V
+      - ./mvnw sonar:sonar --no-transfer-progress -Dsonar.projectKey=$SONAR_PROJECT_KEY -Dsonar.host.url=$SONAR_INSTANCE_URL -Dsonar.token=$SONAR_LOGIN_KEY -B -V
     environment:
       SONAR_PROJECT_KEY:
         from_secret: sonar_project_key
@@ -29,3 +34,32 @@ steps:
         from_secret: sonar_instance_url
       SONAR_LOGIN_KEY:
         from_secret: sonar_login_key
+
+---
+
+kind: pipeline
+name: deploy
+type: docker
+platform:
+  os: linux
+  arch: arm64
+
+trigger:
+  event:
+    - promote
+  target:
+    - production
+
+steps:
+  # skip all previous steps because they were already ran in the "build" phase; we don't need to re-analyze the code.
+
+  # upload to maven repository
+  - name: maven-deploy
+    image: maven:3-eclipse-temurin-25
+    commands:
+      - ./mvnw deploy --no-transfer-progress -DskipTests=true -Dmaven.javadoc.skip=true -B -V -gs settings.xml -Dmaven.repo.username=$MAVEN_REPO_USERNAME -Dmaven.repo.password=$MAVEN_REPO_PASSWORD
+    environment:
+      MAVEN_REPO_USERNAME:
+        from_secret: maven_repo_username
+      MAVEN_REPO_PASSWORD:
+        from_secret: maven_repo_password

.mvn/wrapper/maven-wrapper.properties

@@ -0,0 +1,3 @@
+wrapperVersion=3.3.4
+distributionType=only-script
+distributionUrl=https://repo.maven.apache.org/maven2/org/apache/maven/apache-maven/3.9.16/apache-maven-3.9.16-bin.zip

LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2024-2026 Beatrice Dellacà <hello@beatrice.wtf>
+
+All rights reserved.
+
+This software and its source code are the exclusive property of the
+copyright holder and are protected by copyright laws and international
+treaty provisions. No part of this software or its source code may be
+reproduced, distributed, transmitted, displayed, published, or broadcast,
+in any form or by any means, electronic or mechanical, including but not
+limited to photocopying, recording, or the use of any information storage
+and retrieval system, without the prior written permission of the
+copyright holder.
+
+No license or other right to use this software or its source code is
+granted by this notice, whether by implication, estoppel, or otherwise.
+
+THIS SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED. IN NO EVENT SHALL THE COPYRIGHT HOLDER BE LIABLE FOR ANY
+CLAIM, DAMAGES, OR OTHER LIABILITY ARISING FROM, OUT OF, OR IN
+CONNECTION WITH THIS SOFTWARE OR ITS USE.

mvnw

@@ -0,0 +1,295 @@
+#!/bin/sh
+# ----------------------------------------------------------------------------
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements.  See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership.  The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License.  You may obtain a copy of the License at
+#
+#    http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied.  See the License for the
+# specific language governing permissions and limitations
+# under the License.
+# ----------------------------------------------------------------------------
+
+# ----------------------------------------------------------------------------
+# Apache Maven Wrapper startup batch script, version 3.3.4
+#
+# Optional ENV vars
+# -----------------
+#   JAVA_HOME - location of a JDK home dir, required when download maven via java source
+#   MVNW_REPOURL - repo url base for downloading maven distribution
+#   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+#   MVNW_VERBOSE - true: enable verbose log; debug: trace the mvnw script; others: silence the output
+# ----------------------------------------------------------------------------
+
+set -euf
+[ "${MVNW_VERBOSE-}" != debug ] || set -x
+
+# OS specific support.
+native_path() { printf %s\\n "$1"; }
+case "$(uname)" in
+CYGWIN* | MINGW*)
+  [ -z "${JAVA_HOME-}" ] || JAVA_HOME="$(cygpath --unix "$JAVA_HOME")"
+  native_path() { cygpath --path --windows "$1"; }
+  ;;
+esac
+
+# set JAVACMD and JAVACCMD
+set_java_home() {
+  # For Cygwin and MinGW, ensure paths are in Unix format before anything is touched
+  if [ -n "${JAVA_HOME-}" ]; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ]; then
+      # IBM's JDK on AIX uses strange locations for the executables
+      JAVACMD="$JAVA_HOME/jre/sh/java"
+      JAVACCMD="$JAVA_HOME/jre/sh/javac"
+    else
+      JAVACMD="$JAVA_HOME/bin/java"
+      JAVACCMD="$JAVA_HOME/bin/javac"
+
+      if [ ! -x "$JAVACMD" ] || [ ! -x "$JAVACCMD" ]; then
+        echo "The JAVA_HOME environment variable is not defined correctly, so mvnw cannot run." >&2
+        echo "JAVA_HOME is set to \"$JAVA_HOME\", but \"\$JAVA_HOME/bin/java\" or \"\$JAVA_HOME/bin/javac\" does not exist." >&2
+        return 1
+      fi
+    fi
+  else
+    JAVACMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v java
+    )" || :
+    JAVACCMD="$(
+      'set' +e
+      'unset' -f command 2>/dev/null
+      'command' -v javac
+    )" || :
+
+    if [ ! -x "${JAVACMD-}" ] || [ ! -x "${JAVACCMD-}" ]; then
+      echo "The java/javac command does not exist in PATH nor is JAVA_HOME set, so mvnw cannot run." >&2
+      return 1
+    fi
+  fi
+}
+
+# hash string like Java String::hashCode
+hash_string() {
+  str="${1:-}" h=0
+  while [ -n "$str" ]; do
+    char="${str%"${str#?}"}"
+    h=$(((h * 31 + $(LC_CTYPE=C printf %d "'$char")) % 4294967296))
+    str="${str#?}"
+  done
+  printf %x\\n $h
+}
+
+verbose() { :; }
+[ "${MVNW_VERBOSE-}" != true ] || verbose() { printf %s\\n "${1-}"; }
+
+die() {
+  printf %s\\n "$1" >&2
+  exit 1
+}
+
+trim() {
+  # MWRAPPER-139:
+  #   Trims trailing and leading whitespace, carriage returns, tabs, and linefeeds.
+  #   Needed for removing poorly interpreted newline sequences when running in more
+  #   exotic environments such as mingw bash on Windows.
+  printf "%s" "${1}" | tr -d '[:space:]'
+}
+
+scriptDir="$(dirname "$0")"
+scriptName="$(basename "$0")"
+
+# parse distributionUrl and optional distributionSha256Sum, requires .mvn/wrapper/maven-wrapper.properties
+while IFS="=" read -r key value; do
+  case "${key-}" in
+  distributionUrl) distributionUrl=$(trim "${value-}") ;;
+  distributionSha256Sum) distributionSha256Sum=$(trim "${value-}") ;;
+  esac
+done <"$scriptDir/.mvn/wrapper/maven-wrapper.properties"
+[ -n "${distributionUrl-}" ] || die "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+
+case "${distributionUrl##*/}" in
+maven-mvnd-*bin.*)
+  MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/
+  case "${PROCESSOR_ARCHITECTURE-}${PROCESSOR_ARCHITEW6432-}:$(uname -a)" in
+  *AMD64:CYGWIN* | *AMD64:MINGW*) distributionPlatform=windows-amd64 ;;
+  :Darwin*x86_64) distributionPlatform=darwin-amd64 ;;
+  :Darwin*arm64) distributionPlatform=darwin-aarch64 ;;
+  :Linux*x86_64*) distributionPlatform=linux-amd64 ;;
+  *)
+    echo "Cannot detect native platform for mvnd on $(uname)-$(uname -m), use pure java version" >&2
+    distributionPlatform=linux-amd64
+    ;;
+  esac
+  distributionUrl="${distributionUrl%-bin.*}-$distributionPlatform.zip"
+  ;;
+maven-mvnd-*) MVN_CMD=mvnd.sh _MVNW_REPO_PATTERN=/maven/mvnd/ ;;
+*) MVN_CMD="mvn${scriptName#mvnw}" _MVNW_REPO_PATTERN=/org/apache/maven/ ;;
+esac
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+[ -z "${MVNW_REPOURL-}" ] || distributionUrl="$MVNW_REPOURL$_MVNW_REPO_PATTERN${distributionUrl#*"$_MVNW_REPO_PATTERN"}"
+distributionUrlName="${distributionUrl##*/}"
+distributionUrlNameMain="${distributionUrlName%.*}"
+distributionUrlNameMain="${distributionUrlNameMain%-bin}"
+MAVEN_USER_HOME="${MAVEN_USER_HOME:-${HOME}/.m2}"
+MAVEN_HOME="${MAVEN_USER_HOME}/wrapper/dists/${distributionUrlNameMain-}/$(hash_string "$distributionUrl")"
+
+exec_maven() {
+  unset MVNW_VERBOSE MVNW_USERNAME MVNW_PASSWORD MVNW_REPOURL || :
+  exec "$MAVEN_HOME/bin/$MVN_CMD" "$@" || die "cannot exec $MAVEN_HOME/bin/$MVN_CMD"
+}
+
+if [ -d "$MAVEN_HOME" ]; then
+  verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  exec_maven "$@"
+fi
+
+case "${distributionUrl-}" in
+*?-bin.zip | *?maven-mvnd-?*-?*.zip) ;;
+*) die "distributionUrl is not valid, must match *-bin.zip or maven-mvnd-*.zip, but found '${distributionUrl-}'" ;;
+esac
+
+# prepare tmp dir
+if TMP_DOWNLOAD_DIR="$(mktemp -d)" && [ -d "$TMP_DOWNLOAD_DIR" ]; then
+  clean() { rm -rf -- "$TMP_DOWNLOAD_DIR"; }
+  trap clean HUP INT TERM EXIT
+else
+  die "cannot create temp dir"
+fi
+
+mkdir -p -- "${MAVEN_HOME%/*}"
+
+# Download and Install Apache Maven
+verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+verbose "Downloading from: $distributionUrl"
+verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+# select .zip or .tar.gz
+if ! command -v unzip >/dev/null; then
+  distributionUrl="${distributionUrl%.zip}.tar.gz"
+  distributionUrlName="${distributionUrl##*/}"
+fi
+
+# verbose opt
+__MVNW_QUIET_WGET=--quiet __MVNW_QUIET_CURL=--silent __MVNW_QUIET_UNZIP=-q __MVNW_QUIET_TAR=''
+[ "${MVNW_VERBOSE-}" != true ] || __MVNW_QUIET_WGET='' __MVNW_QUIET_CURL='' __MVNW_QUIET_UNZIP='' __MVNW_QUIET_TAR=v
+
+# normalize http auth
+case "${MVNW_PASSWORD:+has-password}" in
+'') MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+has-password) [ -n "${MVNW_USERNAME-}" ] || MVNW_USERNAME='' MVNW_PASSWORD='' ;;
+esac
+
+if [ -z "${MVNW_USERNAME-}" ] && command -v wget >/dev/null; then
+  verbose "Found wget ... using wget"
+  wget ${__MVNW_QUIET_WGET:+"$__MVNW_QUIET_WGET"} "$distributionUrl" -O "$TMP_DOWNLOAD_DIR/$distributionUrlName" || die "wget: Failed to fetch $distributionUrl"
+elif [ -z "${MVNW_USERNAME-}" ] && command -v curl >/dev/null; then
+  verbose "Found curl ... using curl"
+  curl ${__MVNW_QUIET_CURL:+"$__MVNW_QUIET_CURL"} -f -L -o "$TMP_DOWNLOAD_DIR/$distributionUrlName" "$distributionUrl" || die "curl: Failed to fetch $distributionUrl"
+elif set_java_home; then
+  verbose "Falling back to use Java to download"
+  javaSource="$TMP_DOWNLOAD_DIR/Downloader.java"
+  targetZip="$TMP_DOWNLOAD_DIR/$distributionUrlName"
+  cat >"$javaSource" <<-END
+	public class Downloader extends java.net.Authenticator
+	{
+	  protected java.net.PasswordAuthentication getPasswordAuthentication()
+	  {
+	    return new java.net.PasswordAuthentication( System.getenv( "MVNW_USERNAME" ), System.getenv( "MVNW_PASSWORD" ).toCharArray() );
+	  }
+	  public static void main( String[] args ) throws Exception
+	  {
+	    setDefault( new Downloader() );
+	    java.nio.file.Files.copy( java.net.URI.create( args[0] ).toURL().openStream(), java.nio.file.Paths.get( args[1] ).toAbsolutePath().normalize() );
+	  }
+	}
+	END
+  # For Cygwin/MinGW, switch paths to Windows format before running javac and java
+  verbose " - Compiling Downloader.java ..."
+  "$(native_path "$JAVACCMD")" "$(native_path "$javaSource")" || die "Failed to compile Downloader.java"
+  verbose " - Running Downloader.java ..."
+  "$(native_path "$JAVACMD")" -cp "$(native_path "$TMP_DOWNLOAD_DIR")" Downloader "$distributionUrl" "$(native_path "$targetZip")"
+fi
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+if [ -n "${distributionSha256Sum-}" ]; then
+  distributionSha256Result=false
+  if [ "$MVN_CMD" = mvnd.sh ]; then
+    echo "Checksum validation is not supported for maven-mvnd." >&2
+    echo "Please disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  elif command -v sha256sum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | sha256sum -c - >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  elif command -v shasum >/dev/null; then
+    if echo "$distributionSha256Sum  $TMP_DOWNLOAD_DIR/$distributionUrlName" | shasum -a 256 -c >/dev/null 2>&1; then
+      distributionSha256Result=true
+    fi
+  else
+    echo "Checksum validation was requested but neither 'sha256sum' or 'shasum' are available." >&2
+    echo "Please install either command, or disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties." >&2
+    exit 1
+  fi
+  if [ $distributionSha256Result = false ]; then
+    echo "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised." >&2
+    echo "If you updated your Maven version, you need to update the specified distributionSha256Sum property." >&2
+    exit 1
+  fi
+fi
+
+# unzip and move
+if command -v unzip >/dev/null; then
+  unzip ${__MVNW_QUIET_UNZIP:+"$__MVNW_QUIET_UNZIP"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -d "$TMP_DOWNLOAD_DIR" || die "failed to unzip"
+else
+  tar xzf${__MVNW_QUIET_TAR:+"$__MVNW_QUIET_TAR"} "$TMP_DOWNLOAD_DIR/$distributionUrlName" -C "$TMP_DOWNLOAD_DIR" || die "failed to untar"
+fi
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+actualDistributionDir=""
+
+# First try the expected directory name (for regular distributions)
+if [ -d "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain" ]; then
+  if [ -f "$TMP_DOWNLOAD_DIR/$distributionUrlNameMain/bin/$MVN_CMD" ]; then
+    actualDistributionDir="$distributionUrlNameMain"
+  fi
+fi
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if [ -z "$actualDistributionDir" ]; then
+  # enable globbing to iterate over items
+  set +f
+  for dir in "$TMP_DOWNLOAD_DIR"/*; do
+    if [ -d "$dir" ]; then
+      if [ -f "$dir/bin/$MVN_CMD" ]; then
+        actualDistributionDir="$(basename "$dir")"
+        break
+      fi
+    fi
+  done
+  set -f
+fi
+
+if [ -z "$actualDistributionDir" ]; then
+  verbose "Contents of $TMP_DOWNLOAD_DIR:"
+  verbose "$(ls -la "$TMP_DOWNLOAD_DIR")"
+  die "Could not find Maven distribution directory in extracted archive"
+fi
+
+verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+printf %s\\n "$distributionUrl" >"$TMP_DOWNLOAD_DIR/$actualDistributionDir/mvnw.url"
+mv -- "$TMP_DOWNLOAD_DIR/$actualDistributionDir" "$MAVEN_HOME" || [ -d "$MAVEN_HOME" ] || die "fail to move MAVEN_HOME"
+
+clean || :
+exec_maven "$@"

mvnw.cmd

@@ -0,0 +1,189 @@
+<# : batch portion
+@REM ----------------------------------------------------------------------------
+@REM Licensed to the Apache Software Foundation (ASF) under one
+@REM or more contributor license agreements.  See the NOTICE file
+@REM distributed with this work for additional information
+@REM regarding copyright ownership.  The ASF licenses this file
+@REM to you under the Apache License, Version 2.0 (the
+@REM "License"); you may not use this file except in compliance
+@REM with the License.  You may obtain a copy of the License at
+@REM
+@REM    http://www.apache.org/licenses/LICENSE-2.0
+@REM
+@REM Unless required by applicable law or agreed to in writing,
+@REM software distributed under the License is distributed on an
+@REM "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+@REM KIND, either express or implied.  See the License for the
+@REM specific language governing permissions and limitations
+@REM under the License.
+@REM ----------------------------------------------------------------------------
+
+@REM ----------------------------------------------------------------------------
+@REM Apache Maven Wrapper startup batch script, version 3.3.4
+@REM
+@REM Optional ENV vars
+@REM   MVNW_REPOURL - repo url base for downloading maven distribution
+@REM   MVNW_USERNAME/MVNW_PASSWORD - user and password for downloading maven
+@REM   MVNW_VERBOSE - true: enable verbose log; others: silence the output
+@REM ----------------------------------------------------------------------------
+
+@IF "%__MVNW_ARG0_NAME__%"=="" (SET __MVNW_ARG0_NAME__=%~nx0)
+@SET __MVNW_CMD__=
+@SET __MVNW_ERROR__=
+@SET __MVNW_PSMODULEP_SAVE=%PSModulePath%
+@SET PSModulePath=
+@FOR /F "usebackq tokens=1* delims==" %%A IN (`powershell -noprofile "& {$scriptDir='%~dp0'; $script='%__MVNW_ARG0_NAME__%'; icm -ScriptBlock ([Scriptblock]::Create((Get-Content -Raw '%~f0'))) -NoNewScope}"`) DO @(
+  IF "%%A"=="MVN_CMD" (set __MVNW_CMD__=%%B) ELSE IF "%%B"=="" (echo %%A) ELSE (echo %%A=%%B)
+)
+@SET PSModulePath=%__MVNW_PSMODULEP_SAVE%
+@SET __MVNW_PSMODULEP_SAVE=
+@SET __MVNW_ARG0_NAME__=
+@SET MVNW_USERNAME=
+@SET MVNW_PASSWORD=
+@IF NOT "%__MVNW_CMD__%"=="" ("%__MVNW_CMD__%" %*)
+@echo Cannot start maven from wrapper >&2 && exit /b 1
+@GOTO :EOF
+: end batch / begin powershell #>
+
+$ErrorActionPreference = "Stop"
+if ($env:MVNW_VERBOSE -eq "true") {
+  $VerbosePreference = "Continue"
+}
+
+# calculate distributionUrl, requires .mvn/wrapper/maven-wrapper.properties
+$distributionUrl = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionUrl
+if (!$distributionUrl) {
+  Write-Error "cannot read distributionUrl property in $scriptDir/.mvn/wrapper/maven-wrapper.properties"
+}
+
+switch -wildcard -casesensitive ( $($distributionUrl -replace '^.*/','') ) {
+  "maven-mvnd-*" {
+    $USE_MVND = $true
+    $distributionUrl = $distributionUrl -replace '-bin\.[^.]*$',"-windows-amd64.zip"
+    $MVN_CMD = "mvnd.cmd"
+    break
+  }
+  default {
+    $USE_MVND = $false
+    $MVN_CMD = $script -replace '^mvnw','mvn'
+    break
+  }
+}
+
+# apply MVNW_REPOURL and calculate MAVEN_HOME
+# maven home pattern: ~/.m2/wrapper/dists/{apache-maven-<version>,maven-mvnd-<version>-<platform>}/<hash>
+if ($env:MVNW_REPOURL) {
+  $MVNW_REPO_PATTERN = if ($USE_MVND -eq $False) { "/org/apache/maven/" } else { "/maven/mvnd/" }
+  $distributionUrl = "$env:MVNW_REPOURL$MVNW_REPO_PATTERN$($distributionUrl -replace "^.*$MVNW_REPO_PATTERN",'')"
+}
+$distributionUrlName = $distributionUrl -replace '^.*/',''
+$distributionUrlNameMain = $distributionUrlName -replace '\.[^.]*$','' -replace '-bin$',''
+
+$MAVEN_M2_PATH = "$HOME/.m2"
+if ($env:MAVEN_USER_HOME) {
+  $MAVEN_M2_PATH = "$env:MAVEN_USER_HOME"
+}
+
+if (-not (Test-Path -Path $MAVEN_M2_PATH)) {
+    New-Item -Path $MAVEN_M2_PATH -ItemType Directory | Out-Null
+}
+
+$MAVEN_WRAPPER_DISTS = $null
+if ((Get-Item $MAVEN_M2_PATH).Target[0] -eq $null) {
+  $MAVEN_WRAPPER_DISTS = "$MAVEN_M2_PATH/wrapper/dists"
+} else {
+  $MAVEN_WRAPPER_DISTS = (Get-Item $MAVEN_M2_PATH).Target[0] + "/wrapper/dists"
+}
+
+$MAVEN_HOME_PARENT = "$MAVEN_WRAPPER_DISTS/$distributionUrlNameMain"
+$MAVEN_HOME_NAME = ([System.Security.Cryptography.SHA256]::Create().ComputeHash([byte[]][char[]]$distributionUrl) | ForEach-Object {$_.ToString("x2")}) -join ''
+$MAVEN_HOME = "$MAVEN_HOME_PARENT/$MAVEN_HOME_NAME"
+
+if (Test-Path -Path "$MAVEN_HOME" -PathType Container) {
+  Write-Verbose "found existing MAVEN_HOME at $MAVEN_HOME"
+  Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"
+  exit $?
+}
+
+if (! $distributionUrlNameMain -or ($distributionUrlName -eq $distributionUrlNameMain)) {
+  Write-Error "distributionUrl is not valid, must end with *-bin.zip, but found $distributionUrl"
+}
+
+# prepare tmp dir
+$TMP_DOWNLOAD_DIR_HOLDER = New-TemporaryFile
+$TMP_DOWNLOAD_DIR = New-Item -Itemtype Directory -Path "$TMP_DOWNLOAD_DIR_HOLDER.dir"
+$TMP_DOWNLOAD_DIR_HOLDER.Delete() | Out-Null
+trap {
+  if ($TMP_DOWNLOAD_DIR.Exists) {
+    try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+    catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+  }
+}
+
+New-Item -Itemtype Directory -Path "$MAVEN_HOME_PARENT" -Force | Out-Null
+
+# Download and Install Apache Maven
+Write-Verbose "Couldn't find MAVEN_HOME, downloading and installing it ..."
+Write-Verbose "Downloading from: $distributionUrl"
+Write-Verbose "Downloading to: $TMP_DOWNLOAD_DIR/$distributionUrlName"
+
+$webclient = New-Object System.Net.WebClient
+if ($env:MVNW_USERNAME -and $env:MVNW_PASSWORD) {
+  $webclient.Credentials = New-Object System.Net.NetworkCredential($env:MVNW_USERNAME, $env:MVNW_PASSWORD)
+}
+[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12
+$webclient.DownloadFile($distributionUrl, "$TMP_DOWNLOAD_DIR/$distributionUrlName") | Out-Null
+
+# If specified, validate the SHA-256 sum of the Maven distribution zip file
+$distributionSha256Sum = (Get-Content -Raw "$scriptDir/.mvn/wrapper/maven-wrapper.properties" | ConvertFrom-StringData).distributionSha256Sum
+if ($distributionSha256Sum) {
+  if ($USE_MVND) {
+    Write-Error "Checksum validation is not supported for maven-mvnd. `nPlease disable validation by removing 'distributionSha256Sum' from your maven-wrapper.properties."
+  }
+  Import-Module $PSHOME\Modules\Microsoft.PowerShell.Utility -Function Get-FileHash
+  if ((Get-FileHash "$TMP_DOWNLOAD_DIR/$distributionUrlName" -Algorithm SHA256).Hash.ToLower() -ne $distributionSha256Sum) {
+    Write-Error "Error: Failed to validate Maven distribution SHA-256, your Maven distribution might be compromised. If you updated your Maven version, you need to update the specified distributionSha256Sum property."
+  }
+}
+
+# unzip and move
+Expand-Archive "$TMP_DOWNLOAD_DIR/$distributionUrlName" -DestinationPath "$TMP_DOWNLOAD_DIR" | Out-Null
+
+# Find the actual extracted directory name (handles snapshots where filename != directory name)
+$actualDistributionDir = ""
+
+# First try the expected directory name (for regular distributions)
+$expectedPath = Join-Path "$TMP_DOWNLOAD_DIR" "$distributionUrlNameMain"
+$expectedMvnPath = Join-Path "$expectedPath" "bin/$MVN_CMD"
+if ((Test-Path -Path $expectedPath -PathType Container) -and (Test-Path -Path $expectedMvnPath -PathType Leaf)) {
+  $actualDistributionDir = $distributionUrlNameMain
+}
+
+# If not found, search for any directory with the Maven executable (for snapshots)
+if (!$actualDistributionDir) {
+  Get-ChildItem -Path "$TMP_DOWNLOAD_DIR" -Directory | ForEach-Object {
+    $testPath = Join-Path $_.FullName "bin/$MVN_CMD"
+    if (Test-Path -Path $testPath -PathType Leaf) {
+      $actualDistributionDir = $_.Name
+    }
+  }
+}
+
+if (!$actualDistributionDir) {
+  Write-Error "Could not find Maven distribution directory in extracted archive"
+}
+
+Write-Verbose "Found extracted Maven distribution directory: $actualDistributionDir"
+Rename-Item -Path "$TMP_DOWNLOAD_DIR/$actualDistributionDir" -NewName $MAVEN_HOME_NAME | Out-Null
+try {
+  Move-Item -Path "$TMP_DOWNLOAD_DIR/$MAVEN_HOME_NAME" -Destination $MAVEN_HOME_PARENT | Out-Null
+} catch {
+  if (! (Test-Path -Path "$MAVEN_HOME" -PathType Container)) {
+    Write-Error "fail to move MAVEN_HOME"
+  }
+} finally {
+  try { Remove-Item $TMP_DOWNLOAD_DIR -Recurse -Force | Out-Null }
+  catch { Write-Warning "Cannot remove $TMP_DOWNLOAD_DIR" }
+}
+
+Write-Output "MVN_CMD=$MAVEN_HOME/bin/$MVN_CMD"

pom.xml

@@ -9,8 +9,7 @@
     <version>0.0.5-SNAPSHOT</version>
 
     <properties>
-        <maven.compiler.source>17</maven.compiler.source>
+        <maven.compiler.release>25</maven.compiler.release>
-        <maven.compiler.target>17</maven.compiler.target>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
     </properties>
 
@@ -18,13 +17,13 @@
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-api</artifactId>
-            <version>2.23.1</version>
+            <version>2.26.1</version>
         </dependency>
 
         <dependency>
             <groupId>org.apache.logging.log4j</groupId>
             <artifactId>log4j-core</artifactId>
-            <version>2.23.1</version>
+            <version>2.26.1</version>
         </dependency>
 
         <dependency>
@@ -32,12 +31,44 @@
             <artifactId>jnativehook</artifactId>
             <version>2.2.2</version>
         </dependency>
+
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <version>6.1.3</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
 
+    <distributionManagement>
+        <repository>
+            <id>nexus-releases</id>
+            <name>Nexus Releases Repository</name>
+            <url>https://nexus.beatrice.wtf/repository/maven-releases/</url>
+        </repository>
+        <snapshotRepository>
+            <id>nexus-snapshots</id>
+            <name>Nexus Snapshots Repository</name>
+            <url>https://nexus.beatrice.wtf/repository/maven-snapshots/</url>
+        </snapshotRepository>
+    </distributionManagement>
+
     <build>
         <plugins>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <version>3.6.0</version>
+            </plugin>
+
+            <plugin>
+                <groupId>org.sonarsource.scanner.maven</groupId>
+                <artifactId>sonar-maven-plugin</artifactId>
+                <version>5.8.0.7211</version>
+            </plugin>
             <plugin>
                 <artifactId>maven-assembly-plugin</artifactId>
+                <version>3.8.0</version>
                 <configuration>
                     <archive>
                         <manifest>
@@ -68,8 +99,8 @@
         </repository>
 
         <repository>
-            <id>sonatype-nexus-snapshots</id>
+            <id>sonatype-nexus-releases</id>
-            <url>https://oss.sonatype.org/content/repositories/snapshots</url>
+            <url>https://oss.sonatype.org/content/repositories/releases</url>
         </repository>
     </repositories>
 
@@ -80,4 +111,79 @@
         </pluginRepository>
     </pluginRepositories>
 
+    <profiles>
+        <!-- builds a native .app bundle. jpackage can only target the os it runs on:
+             run this profile on macos with `mvn clean package -Pmac-app` -->
+        <profile>
+            <id>mac-app</id>
+            <build>
+                <plugins>
+                    <plugin>
+                        <groupId>org.apache.maven.plugins</groupId>
+                        <artifactId>maven-resources-plugin</artifactId>
+                        <version>3.5.0</version>
+                        <executions>
+                            <execution>
+                                <id>stage-jpackage-input</id>
+                                <phase>package</phase>
+                                <goals>
+                                    <goal>copy-resources</goal>
+                                </goals>
+                                <configuration>
+                                    <outputDirectory>${project.build.directory}/jpackage-input</outputDirectory>
+                                    <resources>
+                                        <resource>
+                                            <directory>${project.build.directory}</directory>
+                                            <includes>
+                                                <include>${project.build.finalName}-jar-with-dependencies.jar</include>
+                                            </includes>
+                                        </resource>
+                                    </resources>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+
+                    <plugin>
+                        <groupId>org.codehaus.mojo</groupId>
+                        <artifactId>exec-maven-plugin</artifactId>
+                        <version>3.6.4</version>
+                        <executions>
+                            <execution>
+                                <id>jpackage-app-image</id>
+                                <phase>package</phase>
+                                <goals>
+                                    <goal>exec</goal>
+                                </goals>
+                                <configuration>
+                                    <executable>${java.home}/bin/jpackage</executable>
+                                    <arguments>
+                                        <argument>--type</argument>
+                                        <argument>app-image</argument>
+                                        <argument>--name</argument>
+                                        <argument>${project.artifactId}</argument>
+                                        <argument>--dest</argument>
+                                        <argument>${project.build.directory}/jpackage</argument>
+                                        <argument>--input</argument>
+                                        <argument>${project.build.directory}/jpackage-input</argument>
+                                        <argument>--main-jar</argument>
+                                        <argument>${project.build.finalName}-jar-with-dependencies.jar</argument>
+                                        <argument>--main-class</argument>
+                                        <argument>wtf.beatrice.autosqueal.Main</argument>
+                                        <argument>--java-options</argument>
+                                        <argument>--enable-native-access=ALL-UNNAMED</argument>
+                                        <argument>--mac-package-identifier</argument>
+                                        <argument>wtf.beatrice.autosqueal</argument>
+                                        <argument>--mac-package-name</argument>
+                                        <argument>autosqueal</argument>
+                                    </arguments>
+                                </configuration>
+                            </execution>
+                        </executions>
+                    </plugin>
+                </plugins>
+            </build>
+        </profile>
+    </profiles>
+
 </project>

readme.md

@@ -8,17 +8,19 @@
   
   
 *little java tool to automatically perform mouse actions*  
+
+*once started, it only acts when you are away: it detects your activity and pauses itself while you are using the machine, so it never fights you for the mouse.*  
   
 ## supported systems  
 | system    | support    |
 |-----------|------------|
-| macOS     | ✅ **full** |
+| macOS     | ✅ complete |
-| Windows   | 🟠 limited |
+| GNU/Linux | ⏳ planned  |
-| GNU/Linux | 🟠 limited |
+| Windows   | ⏳ planned  |
   
 ## building  
 **required tools**  
- - java 17 sdk  
+ - java 25 sdk  
  - git  
  - maven  
   
@@ -26,7 +28,11 @@
  1. clone the official repository linked below using `git clone`.  
  2. `cd` into the directory and run `mvn clean package`.  
  3. you will find a runnable jar with dependencies in the `target/` folder.  
- 4. run the built jar file with `java -jar target/autosqueal-*-dependencies.jar`.
+ 4. run the built jar file with `java -jar target/autosqueal-*-jar-with-dependencies.jar`.
+
+**macos .app bundle**  
+ - on macos, run `mvn clean package -Pmac-app`: you will find `autosqueal.app` in `target/jpackage/`.  
+ - the first time you run it, grant it the device control and data access permission (called "accessibility" on older macos versions) and the screen recording one, in system settings, like any other java app.
   
 ## support  
 | category            | info                                                          |
@@ -34,5 +40,6 @@
 | official repository | [gitea src](https://git.beatrice.wtf/Tools/autosqeal.git)     |
 | mirror repository   | [github src](https://github.com/mind-overflow/autosqueal.git) |
 | build status        | [drone-ci](https://drone.beatrice.wtf/Tools/autosqeal)        |
+| license             | copyright, all rights reserved — see [license](LICENSE)       |
 | dev email           | [hello@beatrice.wtf](mailto:hello@beatrice.wtf)               |
 

renovate.json

@@ -0,0 +1,3 @@
+{
+  "$schema": "https://docs.renovatebot.com/renovate-schema.json"
+}

settings.xml

@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<settings xmlns="http://maven.apache.org/SETTINGS/1.1.0"
+          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+          xsi:schemaLocation="http://maven.apache.org/SETTINGS/1.1.0 http://maven.apache.org/xsd/settings-1.1.0.xsd">
+
+    <servers>
+        <server>
+            <id>nexus-snapshots</id>
+            <username>${maven.repo.username}</username>
+            <password>${maven.repo.password}</password>
+        </server>
+        <server>
+            <id>nexus-releases</id>
+            <username>${maven.repo.username}</username>
+            <password>${maven.repo.password}</password>
+        </server>
+    </servers>
+
+</settings>
+

src/main/java/wtf/beatrice/autosqueal/Main.java

@@ -4,38 +4,91 @@ import com.github.kwhat.jnativehook.GlobalScreen;
 import com.github.kwhat.jnativehook.NativeHookException;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+import wtf.beatrice.autosqueal.config.ConfigStore;
 import wtf.beatrice.autosqueal.listener.KeyPressListener;
 import wtf.beatrice.autosqueal.ui.MainWindow;
 
+import javax.swing.*;
+import javax.swing.UnsupportedLookAndFeelException;
+
 public class Main {
 
     private static final Logger LOGGER = LogManager.getLogger(Main.class);
-    private static final MainWindow mainWindow = new MainWindow();
+    private static MainWindow mainWindow;
+    private static AutoSquealConfig config;
+
+    /** Whether the hook and its listener are registered, so retries don't add duplicates. */
+    private static boolean hookRegistered = false;
 
     public static void main(String[] args) {
         LOGGER.info("Hello world!");
 
-        registerJNativeHook();
+        config = new ConfigStore().load();
-        mainWindow.init();
+        mainWindow = new MainWindow(config);
+
+        // ⌘Q on macOS, the IDE stop button and signals all bypass
+        // windowClosing: make cleanup run on every exit path instead
+        Runtime.getRuntime().addShutdownHook(new Thread(mainWindow::cleanup, "autosqueal-shutdown"));
+
+        useSystemLookAndFeel();
+        boolean hookRegistered = registerJNativeHook();
+
+        // all Swing components must be created and updated on the EDT
+        SwingUtilities.invokeLater(() -> {
+            mainWindow.init();
+            if (!hookRegistered) {
+                mainWindow.showPermissionsHelp();
+            }
+        });
     }
 
-    private static void registerJNativeHook() {
+    private static void useSystemLookAndFeel() {
+        try {
+            UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
+        } catch (ReflectiveOperationException | UnsupportedLookAndFeelException ex) {
+            LOGGER.warn("Could not set the system look and feel, using the default one", ex);
+        }
+    }
+
+    public static boolean registerJNativeHook() {
+        if (hookRegistered) {
+            return true;
+        }
+
         LOGGER.info("Registering jnativehook library...");
         try {
             GlobalScreen.registerNativeHook();
-            GlobalScreen.addNativeKeyListener(new KeyPressListener());
+            GlobalScreen.addNativeKeyListener(
+                    new KeyPressListener(mainWindow::toggleRunning, mainWindow::notifyKeyboardActivity, config));
+            hookRegistered = true;
             LOGGER.info("Successfully registered jnativehook library!");
+            return true;
         }
         catch (NativeHookException ex) {
-            LOGGER.error("There was a problem registering the native hook.");
+            LOGGER.error("There was a problem registering the native hook.", ex);
-            LOGGER.error(ex.getMessage());
 
-            System.exit(1);
+            // without the accessibility permission the hotkey cannot be
+            // registered and the mouse cannot be moved either: the app would
+            // look alive but do nothing. don't exit: keep the window and the
+            // tray icon usable, and tell the user what is missing.
+            return false;
         }
     }
 
-    public static MainWindow getMainWindow() {
+    public static void unregisterJNativeHook() {
-        return mainWindow;
+        if (!hookRegistered) {
+            return;
+        }
+
+        try {
+            GlobalScreen.unregisterNativeHook();
+            LOGGER.info("Successfully unregistered jnativehook library!");
+        }
+        catch (NativeHookException ex) {
+            LOGGER.error("There was a problem unregistering the native hook.");
+            LOGGER.error(ex.getMessage());
+        }
     }
 
-}
+}

src/main/java/wtf/beatrice/autosqueal/config/AutoSquealConfig.java

@@ -0,0 +1,113 @@
+package wtf.beatrice.autosqueal.config;
+
+/**
+ * The user-editable settings of the app.
+ *
+ * A single instance is shared between the components, which read the
+ * current values while running: a change is picked up by the next poll or
+ * movement without a restart. Values are clamped to sane ranges when set,
+ * so that no matter what ends up in the settings file, the automation
+ * always gets workable numbers.
+ */
+public class AutoSquealConfig {
+
+    public static final int AWAY_THRESHOLD_MIN_SECONDS = 5;
+    public static final int AWAY_THRESHOLD_MAX_SECONDS = 600;
+
+    public static final int MOVE_INTERVAL_MIN_SECONDS = 1;
+    public static final int MOVE_INTERVAL_MAX_SECONDS = 3600;
+
+    public static final int STEP_DELAY_MIN_MILLISECONDS = 1;
+    public static final int STEP_DELAY_MAX_MILLISECONDS = 50;
+
+    public static final int CLICK_EVERY_MIN_MOVES = 1;
+    public static final int CLICK_EVERY_MAX_MOVES = 100;
+
+    private volatile int awayThresholdSeconds = 30;
+    private volatile int moveIntervalSeconds = 10;
+    private volatile int stepDelayMilliseconds = 2;
+    private volatile boolean clickEnabled = true;
+    private volatile int clickEveryNMoves = 5;
+    private volatile ScreenArea movementScreen = ScreenArea.PRIMARY;
+    private volatile boolean startAutomatically = true;
+    private volatile boolean hotkeyEnabled = true;
+
+    /** Seconds without user activity after which the user is considered away. */
+    public int getAwayThresholdSeconds() {
+        return awayThresholdSeconds;
+    }
+
+    public void setAwayThresholdSeconds(int seconds) {
+        awayThresholdSeconds = clamp(seconds, AWAY_THRESHOLD_MIN_SECONDS, AWAY_THRESHOLD_MAX_SECONDS);
+    }
+
+    /** Seconds between two movements. */
+    public int getMoveIntervalSeconds() {
+        return moveIntervalSeconds;
+    }
+
+    public void setMoveIntervalSeconds(int seconds) {
+        moveIntervalSeconds = clamp(seconds, MOVE_INTERVAL_MIN_SECONDS, MOVE_INTERVAL_MAX_SECONDS);
+    }
+
+    /** Pause between two cursor steps, in milliseconds: the lower, the faster. */
+    public int getStepDelayMilliseconds() {
+        return stepDelayMilliseconds;
+    }
+
+    public void setStepDelayMilliseconds(int milliseconds) {
+        stepDelayMilliseconds = clamp(milliseconds, STEP_DELAY_MIN_MILLISECONDS, STEP_DELAY_MAX_MILLISECONDS);
+    }
+
+    /** Whether the corner double click is performed at all. */
+    public boolean isClickEnabled() {
+        return clickEnabled;
+    }
+
+    public void setClickEnabled(boolean enabled) {
+        clickEnabled = enabled;
+    }
+
+    /**
+     * One movement every N is a corner double click, so that the
+     * notification area gets exercised too.
+     */
+    public int getClickEveryNMoves() {
+        return clickEveryNMoves;
+    }
+
+    public void setClickEveryNMoves(int moves) {
+        clickEveryNMoves = clamp(moves, CLICK_EVERY_MIN_MOVES, CLICK_EVERY_MAX_MOVES);
+    }
+
+    /** Which screens the cursor may travel to. */
+    public ScreenArea getMovementScreen() {
+        return movementScreen;
+    }
+
+    public void setMovementScreen(ScreenArea screenArea) {
+        movementScreen = screenArea == null ? ScreenArea.PRIMARY : screenArea;
+    }
+
+    /** Whether the automation starts as soon as the window opens. */
+    public boolean isStartAutomatically() {
+        return startAutomatically;
+    }
+
+    public void setStartAutomatically(boolean automatically) {
+        startAutomatically = automatically;
+    }
+
+    /** Whether the global toggle hotkey is active. */
+    public boolean isHotkeyEnabled() {
+        return hotkeyEnabled;
+    }
+
+    public void setHotkeyEnabled(boolean enabled) {
+        hotkeyEnabled = enabled;
+    }
+
+    private static int clamp(int value, int min, int max) {
+        return Math.max(min, Math.min(max, value));
+    }
+}

src/main/java/wtf/beatrice/autosqueal/config/ConfigStore.java

@@ -0,0 +1,163 @@
+package wtf.beatrice.autosqueal.config;
+
+import org.apache.logging.log4j.LogManager;
+import org.apache.logging.log4j.Logger;
+import wtf.beatrice.autosqueal.util.SystemUtil;
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.AtomicMoveNotSupportedException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.StandardCopyOption;
+import java.util.Map;
+import java.util.Properties;
+import java.util.TreeMap;
+import java.util.function.Consumer;
+import java.util.function.IntConsumer;
+
+/**
+ * Loads and saves the settings, as a properties file in the user's config
+ * directory.
+ *
+ * The whole store is defensive: a missing file, garbage values or an
+ * unwritable directory degrade to the defaults instead of breaking the
+ * app, because the automation must be able to start no matter what.
+ * Writing goes through a temp file and an atomic move, so that a crash
+ * mid-save can never leave a truncated settings file behind.
+ */
+public class ConfigStore {
+
+    private static final Logger LOGGER = LogManager.getLogger(ConfigStore.class);
+
+    static final String KEY_AWAY_THRESHOLD_SECONDS = "away.threshold.seconds";
+    static final String KEY_MOVE_INTERVAL_SECONDS = "move.interval.seconds";
+    static final String KEY_STEP_DELAY_MILLISECONDS = "move.step.delay.milliseconds";
+    static final String KEY_CLICK_ENABLED = "click.enabled";
+    static final String KEY_CLICK_EVERY_N_MOVES = "click.every.n.moves";
+    static final String KEY_MOVEMENT_SCREEN = "move.screen";
+    static final String KEY_START_AUTOMATICALLY = "automation.start.automatically";
+    static final String KEY_HOTKEY_ENABLED = "hotkey.enabled";
+
+    private final Path file;
+
+    /** A store reading the standard settings file of the host platform. */
+    public ConfigStore() {
+        this(SystemUtil.getAppConfigDir().resolve("autosqueal.properties"));
+    }
+
+    /** A store reading the given file; used by the tests. */
+    public ConfigStore(Path file) {
+        this.file = file;
+    }
+
+    /** Reads the settings, falling back to the defaults for anything missing or broken. */
+    public AutoSquealConfig load() {
+        AutoSquealConfig config = new AutoSquealConfig();
+
+        if (!Files.isRegularFile(file)) {
+            LOGGER.info("No settings file yet, using the defaults");
+            return config;
+        }
+
+        Properties properties = new Properties();
+        try (InputStream input = Files.newInputStream(file)) {
+            properties.load(input);
+        } catch (IOException ex) {
+            LOGGER.warn("Could not read the settings file, using the defaults", ex);
+            return config;
+        }
+
+        readInt(properties, KEY_AWAY_THRESHOLD_SECONDS, config::setAwayThresholdSeconds);
+        readInt(properties, KEY_MOVE_INTERVAL_SECONDS, config::setMoveIntervalSeconds);
+        readInt(properties, KEY_STEP_DELAY_MILLISECONDS, config::setStepDelayMilliseconds);
+        readInt(properties, KEY_CLICK_EVERY_N_MOVES, config::setClickEveryNMoves);
+        readBoolean(properties, KEY_CLICK_ENABLED, config::setClickEnabled);
+        readBoolean(properties, KEY_START_AUTOMATICALLY, config::setStartAutomatically);
+        readBoolean(properties, KEY_HOTKEY_ENABLED, config::setHotkeyEnabled);
+        readEnum(properties, KEY_MOVEMENT_SCREEN, ScreenArea.class, config::setMovementScreen);
+
+        return config;
+    }
+
+    /** Writes the settings atomically, so that readers never see a half-written file. */
+    public void save(AutoSquealConfig config) {
+        Map<String, String> entries = new TreeMap<>();
+        entries.put(KEY_AWAY_THRESHOLD_SECONDS, String.valueOf(config.getAwayThresholdSeconds()));
+        entries.put(KEY_MOVE_INTERVAL_SECONDS, String.valueOf(config.getMoveIntervalSeconds()));
+        entries.put(KEY_STEP_DELAY_MILLISECONDS, String.valueOf(config.getStepDelayMilliseconds()));
+        entries.put(KEY_CLICK_ENABLED, String.valueOf(config.isClickEnabled()));
+        entries.put(KEY_CLICK_EVERY_N_MOVES, String.valueOf(config.getClickEveryNMoves()));
+        entries.put(KEY_MOVEMENT_SCREEN, String.valueOf(config.getMovementScreen()));
+        entries.put(KEY_START_AUTOMATICALLY, String.valueOf(config.isStartAutomatically()));
+        entries.put(KEY_HOTKEY_ENABLED, String.valueOf(config.isHotkeyEnabled()));
+
+        try {
+            Path directory = file.toAbsolutePath().getParent();
+            Files.createDirectories(directory);
+            Path tempFile = Files.createTempFile(directory, "autosqueal-", ".tmp");
+
+            try (BufferedWriter writer = Files.newBufferedWriter(tempFile)) {
+                writer.write("# autosqueal settings, rewritten by the app when the settings change");
+                writer.newLine();
+                for (Map.Entry<String, String> entry : entries.entrySet()) {
+                    writer.write(entry.getKey());
+                    writer.write("=");
+                    writer.write(entry.getValue());
+                    writer.newLine();
+                }
+            }
+
+            try {
+                Files.move(tempFile, file, StandardCopyOption.ATOMIC_MOVE, StandardCopyOption.REPLACE_EXISTING);
+            } catch (AtomicMoveNotSupportedException ex) {
+                Files.move(tempFile, file, StandardCopyOption.REPLACE_EXISTING);
+            }
+        } catch (IOException ex) {
+            LOGGER.error("Could not save the settings", ex);
+        }
+    }
+
+    private static void readInt(Properties properties, String key, IntConsumer setter) {
+        String value = properties.getProperty(key);
+        if (value == null) {
+            return;
+        }
+
+        try {
+            setter.accept(Integer.parseInt(value.trim()));
+        } catch (NumberFormatException ex) {
+            LOGGER.warn("Ignoring invalid value for {}: {}", key, value);
+        }
+    }
+
+    private static void readBoolean(Properties properties, String key, Consumer<Boolean> setter) {
+        String value = properties.getProperty(key);
+        if (value == null) {
+            return;
+        }
+
+        String normalized = value.trim();
+        if ("true".equalsIgnoreCase(normalized)) {
+            setter.accept(true);
+        } else if ("false".equalsIgnoreCase(normalized)) {
+            setter.accept(false);
+        } else {
+            LOGGER.warn("Ignoring invalid value for {}: {}", key, value);
+        }
+    }
+
+    private static <E extends Enum<E>> void readEnum(Properties properties, String key, Class<E> type, Consumer<E> setter) {
+        String value = properties.getProperty(key);
+        if (value == null) {
+            return;
+        }
+
+        try {
+            setter.accept(Enum.valueOf(type, value.trim()));
+        } catch (IllegalArgumentException ex) {
+            LOGGER.warn("Ignoring unknown value for {}: {}", key, value);
+        }
+    }
+}

src/main/java/wtf/beatrice/autosqueal/config/ScreenArea.java

@@ -0,0 +1,13 @@
+package wtf.beatrice.autosqueal.config;
+
+/**
+ * Which screens the automation is allowed to move the cursor to.
+ */
+public enum ScreenArea {
+
+    /** The main screen only, as the app has always used. */
+    PRIMARY,
+
+    /** Every connected screen, treated as one big virtual screen. */
+    ALL
+}

src/main/java/wtf/beatrice/autosqueal/controls/CursorMover.java

@@ -2,71 +2,114 @@ package wtf.beatrice.autosqueal.controls;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import wtf.beatrice.autosqueal.util.RunnerUtil;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
 
 import java.awt.*;
 import java.security.SecureRandom;
 import java.util.Random;
-import java.util.Timer;
+import java.util.concurrent.ExecutorService;
-import java.util.TimerTask;
+import java.util.concurrent.RejectedExecutionException;
+import java.util.function.BooleanSupplier;
+import java.util.function.Supplier;
 
-public class CursorMover extends TimerTask
+/**
-{
+ * Periodically starts a new movement of the mouse cursor to a random position,
+ * or to the top-right corner of the main screen for a double click.
+ *
+ * The movements only happen when the user is away: while the user is actively
+ * using the machine, they are skipped, so the app never fights for the mouse.
+ * The same goes for a movement already in progress: the task checks whether
+ * the user is still away at every step, and gives the mouse back when they
+ * are not.
+ *
+ * Everything that varies — how often to move, how fast, whether and how
+ * often to click, which screens to travel — comes from the settings, which
+ * are read live at every movement. The movement itself is executed by a
+ * {@link SingleStepMovementTask}, which runs on its own virtual thread
+ * until it reaches its destination.
+ */
+public class CursorMover implements Runnable {
 
     private static final Logger LOGGER = LogManager.getLogger(CursorMover.class);
+
+    /** Distance from the screen edge, so the corner click lands inside the screen. */
+    private static final int CORNER_OFFSET_PIXELS = 5;
+
     private final Random random;
+    private final ExecutorService movementExecutor;
+    private final RobotMouseTracker robotTracker;
+    private final BooleanSupplier isUserAway;
+    private final AutoSquealConfig config;
+    private final Supplier<Rectangle> movementBounds;
+    private final Supplier<Rectangle> primaryScreenBounds;
+    private final Supplier<Point> currentPosition;
 
-    private static final int LOOPS_BEFORE_CLICK = 5;
+    /** Movements started since the last corner click. */
-
     private int iteration = 0;
 
-    public CursorMover() {
+    public CursorMover(ExecutorService movementExecutor, RobotMouseTracker robotTracker,
-        random = new SecureRandom();
+                       BooleanSupplier isUserAway, AutoSquealConfig config,
+                       Supplier<Rectangle> movementBounds, Supplier<Rectangle> primaryScreenBounds) {
+        this(movementExecutor, robotTracker, isUserAway, config, movementBounds, primaryScreenBounds,
+                new SecureRandom(), () -> MouseInfo.getPointerInfo().getLocation());
+    }
+
+    CursorMover(ExecutorService movementExecutor, RobotMouseTracker robotTracker,
+                BooleanSupplier isUserAway, AutoSquealConfig config,
+                Supplier<Rectangle> movementBounds, Supplier<Rectangle> primaryScreenBounds,
+                Random random, Supplier<Point> currentPosition) {
+        this.movementExecutor = movementExecutor;
+        this.robotTracker = robotTracker;
+        this.isUserAway = isUserAway;
+        this.config = config;
+        this.movementBounds = movementBounds;
+        this.primaryScreenBounds = primaryScreenBounds;
+        this.random = random;
+        this.currentPosition = currentPosition;
     }
 
     @Override
     public void run() {
 
-        int currentX = MouseInfo.getPointerInfo().getLocation().x;
+        if (!isUserAway.getAsBoolean()) {
-        int currentY = MouseInfo.getPointerInfo().getLocation().y;
+            LOGGER.debug("User is present, skipping movement");
+            return;
+        }
 
-        LOGGER.info("Starting coordinates: {}, {}", currentX, currentY);
+        Point location = currentPosition.get();
+        LOGGER.info("Starting coordinates: {}, {}", location.x, location.y);
 
         int destX;
         int destY;
+        boolean click;
 
-        SingleStepMovementTask singleStepMovementTask;
+        // one movement every N is a corner double click, so that the
-
+        // notification area gets exercised too. the corner is always the
-        if (iteration == LOOPS_BEFORE_CLICK) {
+        // main screen's top-right one, whatever screens the cursor may
-            destX = RunnerUtil.SCREEN_WIDTH - 5;
+        // otherwise travel to.
-            destY = 5;
+        if (config.isClickEnabled() && iteration == config.getClickEveryNMoves() - 1) {
-
+            Rectangle primary = primaryScreenBounds.get();
-            try {
+            destX = primary.x + primary.width - CORNER_OFFSET_PIXELS;
-                singleStepMovementTask = new SingleStepMovementTask(destX, destY, true);
+            destY = primary.y + CORNER_OFFSET_PIXELS;
-            } catch (AWTException e) {
+            click = true;
-                LOGGER.error(e);
-                return;
-            }
-
             iteration = 0;
         } else {
-            destX = random.nextInt(RunnerUtil.SCREEN_WIDTH);
+            Rectangle bounds = movementBounds.get();
-            destY = random.nextInt(RunnerUtil.SCREEN_HEIGHT);
+            destX = bounds.x + random.nextInt(Math.max(1, bounds.width));
-
+            destY = bounds.y + random.nextInt(Math.max(1, bounds.height));
-            try {
+            click = false;
-                singleStepMovementTask = new SingleStepMovementTask(destX, destY, false);
-            } catch (AWTException e) {
-                LOGGER.error(e);
-                return;
-            }
-
             iteration++;
         }
 
         LOGGER.info("Destination coordinates: {}, {}", destX, destY);
 
-        Timer timer = new Timer();
+        try {
-        timer.schedule(singleStepMovementTask, 0L, 2L);
+            SingleStepMovementTask movement = new SingleStepMovementTask(
-
+                    robotTracker, destX, destY, click, isUserAway,
+                    config.getStepDelayMilliseconds(), location);
+            movementExecutor.execute(movement);
+        } catch (RejectedExecutionException ex) {
+            LOGGER.debug("Movement not started: automation is shutting down");
+        }
     }
-}
+}

src/main/java/wtf/beatrice/autosqueal/controls/RobotMouseTracker.java

@@ -0,0 +1,37 @@
+package wtf.beatrice.autosqueal.controls;
+
+/**
+ * Keeps track of the mouse movements the app itself performs, so that other
+ * components (like the away detection) can tell them apart from the user's.
+ *
+ * Written by the movement tasks, read by whoever needs to know.
+ */
+public class RobotMouseTracker {
+
+    private volatile boolean moving = false;
+    private volatile int lastX = Integer.MIN_VALUE;
+    private volatile int lastY = Integer.MIN_VALUE;
+
+    /** Marks the start of a movement performed by the app. */
+    public void moveStarted() {
+        moving = true;
+    }
+
+    /**
+     * Marks the end of a movement performed by the app, which left the cursor
+     * at the given coordinates.
+     */
+    public void moveEnded(int x, int y) {
+        lastX = x;
+        lastY = y;
+        moving = false;
+    }
+
+    public boolean isMoving() {
+        return moving;
+    }
+
+    public boolean isLastPosition(int x, int y) {
+        return x == lastX && y == lastY;
+    }
+}

src/main/java/wtf/beatrice/autosqueal/controls/SingleStepMovementTask.java

@@ -5,113 +5,203 @@ import org.apache.logging.log4j.Logger;
 
 import java.awt.*;
 import java.awt.event.InputEvent;
-import java.util.TimerTask;
+import java.util.function.BooleanSupplier;
 
-public class SingleStepMovementTask extends TimerTask {
+/**
+ * Moves the mouse cursor towards a destination one small step at a time.
+ *
+ * Runs on its own virtual thread: it mostly sleeps between steps, so blocking
+ * it is free. When it gets to its destination, it can optionally perform a
+ * double click, with the pacing the app has always used.
+ *
+ * If the user comes back mid-movement, the movement is abandoned at once —
+ * within the latency of the away detection, which polls about once a second —
+ * so the mouse is returned to the user instead of being dragged to a corner.
+ *
+ * All the movements it performs are reported to the {@link RobotMouseTracker},
+ * so that the away detection can tell them apart from the user's.
+ */
+public class SingleStepMovementTask implements Runnable {
 
     private static final Logger LOGGER = LogManager.getLogger(SingleStepMovementTask.class);
 
-    final int destX;
+    private final RobotMouseTracker robotTracker;
-    final int destY;
+    private final int destX;
-    final Robot robot;
+    private final int destY;
+    private final boolean click;
+    private final BooleanSupplier userIsAway;
+    private final long stepDelayMilliseconds;
 
-    float currentX;
+    private float currentX;
-    float currentY;
+    private float currentY;
+    private float stepX;
+    private float stepY;
 
-    float stepX = 1;
+    public SingleStepMovementTask(RobotMouseTracker robotTracker, int destinationX, int destinationY,
-    float stepY = 1;
+                                  boolean click, BooleanSupplier userIsAway, long stepDelayMilliseconds,
-    boolean isRunning = true;
+                                  Point start) {
-    boolean click;
-
-
-    public SingleStepMovementTask(int destinationX, int destinationY, boolean click) throws AWTException {
 
+        this.robotTracker = robotTracker;
+        this.destX = destinationX;
+        this.destY = destinationY;
         this.click = click;
+        this.userIsAway = userIsAway;
+        this.stepDelayMilliseconds = stepDelayMilliseconds;
 
-        currentX = MouseInfo.getPointerInfo().getLocation().x;
+        this.currentX = start.x;
-        currentY = MouseInfo.getPointerInfo().getLocation().y;
+        this.currentY = start.y;
 
-        destX = destinationX;
+        int lengthX = Math.round(Math.abs(currentX - destX));
-        destY = destinationY;
+        int lengthY = Math.round(Math.abs(currentY - destY));
 
-        int lengthX;
+        this.stepX = computeStepX(lengthX, lengthY);
-        int lengthY;
+        this.stepY = computeStepY(lengthX, lengthY);
-
-        lengthX = Math.round(Math.abs(currentX - destX));
-        lengthY = Math.round(Math.abs(currentY - destY));
-
-        if(lengthX > lengthY) {
-            stepX = lengthX / (float) lengthY;
-        }
-
-        if(lengthY > lengthX) {
-            stepY = lengthY / (float) lengthX;
-        }
 
         LOGGER.info("Dest: [{}, {}], Curr: [{}, {}]", destX, destY, currentX, currentY);
-        LOGGER.info("Len: [{}, {}]", lengthX, lengthY);
         LOGGER.info("Step: [{}, {}]", stepX, stepY);
-
-        robot = new Robot();
-
     }
 
     @Override
     public void run() {
-        if(Math.abs(currentX - destX) < 1) {
-            stepX = currentX - destX;
-        }
 
-        if(Math.abs(currentY - destY) < 1) {
+        // the robot is created here, not in the constructor: building a
-            stepY = currentY - destY;
+        // movement must never touch the system on its own, or there would be
-        }
+        // no way to queue one for testing or display without moving a mouse
-
+        Robot robot;
-        if(destX == Math.round(currentX) || destY == Math.round(currentY)) {
+        try {
-
+            robot = new Robot();
-            if (click) {
+        } catch (AWTException ex) {
-                try {
+            LOGGER.error("Could not create a robot, skipping this movement", ex);
-                    Thread.sleep(500);
-                    robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
-                    Thread.sleep(200);
-                    robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
-                    Thread.sleep(500);
-                    robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
-                    Thread.sleep(200);
-                    robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
-                    Thread.sleep(200);
-                } catch (InterruptedException e) {
-                    LOGGER.error(e);
-                    Thread.currentThread().interrupt();
-                }
-            }
-
-            LOGGER.info("Reached destination, stopping mover timer");
-            LOGGER.info("Dest: [{}, {}], Curr: [{}, {}]", destX, destY, currentX, currentY);
-            isRunning = false;
-            this.cancel();
             return;
         }
 
-        if(currentX > destX) {
+        // any position change from here on is the app's doing
-            currentX -= stepX;
+        robotTracker.moveStarted();
-        }
 
-        if(currentY > destY) {
+        try {
-            currentY -= stepY;
+            while (!hasReachedDestination()) {
-        }
+                // a user who came back mid-movement gets the mouse back
+                if (!userIsAway.getAsBoolean()) {
+                    LOGGER.info("User is back: abandoning the movement at [{}, {}]",
+                            Math.round(currentX), Math.round(currentY));
+                    robotTracker.moveEnded(Math.round(currentX), Math.round(currentY));
+                    return;
+                }
 
-        if(currentX < destX) {
+                // when less than a full step is left, move exactly what is
-            currentX += stepX;
+                // left, so that both axes always land on their destination
-        }
+                stepX = adjustedStep(currentX, destX, stepX);
+                stepY = adjustedStep(currentY, destY, stepY);
 
-        if(currentY < destY) {
+                currentX = advance(currentX, destX, stepX);
-            currentY += stepY;
+                currentY = advance(currentY, destY, stepY);
-        }
 
-        robot.mouseMove(Math.round(currentX), Math.round(currentY));
+                robot.mouseMove(Math.round(currentX), Math.round(currentY));
+
+                Thread.sleep(stepDelayMilliseconds);
+            }
+
+            onDestinationReached(robot);
+        } catch (InterruptedException ex) {
+            // the movement was interrupted: the automation was stopped, so
+            // just end the movement here
+            Thread.currentThread().interrupt();
+            LOGGER.debug("Movement interrupted");
+            robotTracker.moveEnded(Math.round(currentX), Math.round(currentY));
+        } catch (RuntimeException ex) {
+            LOGGER.error("Unexpected error while moving the cursor", ex);
+            robotTracker.moveEnded(Math.round(currentX), Math.round(currentY));
+        }
     }
 
-    public boolean isRunning() {
+    private boolean hasReachedDestination() {
-        return isRunning;
+        return Math.round(currentX) == destX && Math.round(currentY) == destY;
     }
-}
+
+    private void onDestinationReached(Robot robot) throws InterruptedException {
+        LOGGER.info("Reached destination [{}, {}], stopping mover", destX, destY);
+
+        robotTracker.moveEnded(destX, destY);
+
+        if (click) {
+            performClickSequence(robot);
+        }
+    }
+
+    /**
+     * Performs a double click with the same pacing the app has always used:
+     * press at +500ms, release at +700ms, press at +1200ms, release at +1400ms.
+     */
+    private void performClickSequence(Robot robot) throws InterruptedException {
+        Thread.sleep(500L);
+        robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
+        Thread.sleep(200L);
+        robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
+        Thread.sleep(500L);
+        robot.mousePress(InputEvent.BUTTON1_DOWN_MASK);
+        Thread.sleep(200L);
+        robot.mouseRelease(InputEvent.BUTTON1_DOWN_MASK);
+    }
+
+    /**
+     * Step to take on the X axis so that both axes reach their destination
+     * after the same number of steps. Returns 0 when there is no movement to make.
+     */
+    static float computeStepX(int lengthX, int lengthY) {
+        if (lengthX == 0) {
+            return 0.0f;
+        }
+        if (lengthX >= lengthY) {
+            return 1.0f;
+        }
+        return lengthX / (float) lengthY;
+    }
+
+    /**
+     * Step to take on the Y axis so that both axes reach their destination
+     * after the same number of steps. Returns 0 when there is no movement to make.
+     */
+    static float computeStepY(int lengthX, int lengthY) {
+        if (lengthY == 0) {
+            return 0.0f;
+        }
+        if (lengthY > lengthX) {
+            return 1.0f;
+        }
+        return lengthY / (float) lengthX;
+    }
+
+    /**
+     * When less than a whole step is left to travel, move exactly what is left
+     * instead of a whole step, so that the cursor doesn't overshoot the destination.
+     */
+    static float adjustedStep(float current, float destination, float step) {
+        float remaining = Math.abs(current - destination);
+        return remaining < 1.0f ? remaining : step;
+    }
+
+    /** Moves current towards destination by step, in the right direction. */
+    static float advance(float current, float destination, float step) {
+        if (current > destination) {
+            return current - step;
+        }
+        if (current < destination) {
+            return current + step;
+        }
+        return current;
+    }
+
+    // package-private: read by the tests, and soon by the live status view
+
+    int getDestX() {
+        return destX;
+    }
+
+    int getDestY() {
+        return destY;
+    }
+
+    boolean isClick() {
+        return click;
+    }
+}

src/main/java/wtf/beatrice/autosqueal/listener/CursorMoveListener.java

@@ -2,51 +2,110 @@ package wtf.beatrice.autosqueal.listener;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+import wtf.beatrice.autosqueal.controls.RobotMouseTracker;
 
 import java.awt.*;
-import java.util.TimerTask;
+import java.util.function.LongSupplier;
+import java.util.function.Supplier;
 
-public class CursorMoveListener extends TimerTask {
+/**
-
+ * Watches the cursor position and tracks whether the user is away: if the
-    private int oldX;
+ * user has not touched mouse or keyboard for long enough — ignoring the
-    private int oldY;
+ * movements the app performs on its own — the user is considered away.
-
+ * Keyboard activity counts as presence, too: a user who is typing is using
-    private int loops;
+ * the machine, even if the mouse never moves.
-    private boolean isUserAway;
+ *
+ * The away state is time-based: how long the user has been idle is compared
+ * against the threshold at every poll, so a threshold changed on the fly
+ * applies from the very next poll.
+ */
+public class CursorMoveListener implements Runnable {
 
     private static final Logger LOGGER = LogManager.getLogger(CursorMoveListener.class);
 
+    private final RobotMouseTracker robotTracker;
+    private final Supplier<Point> currentPosition;
+    private final AutoSquealConfig config;
+    private final LongSupplier clock;
 
-    public CursorMoveListener() {
+    private int lastSeenX;
-        oldX = 0;
+    private int lastSeenY;
-        oldY = 0;
+    private boolean firstPoll = true;
-        loops = 0;
+    private long lastUserActivityTime;
+    private volatile boolean userAway = false;
+    private volatile boolean keyboardActivity = false;
+
+    public CursorMoveListener(RobotMouseTracker robotTracker, AutoSquealConfig config) {
+        this(robotTracker, config, () -> MouseInfo.getPointerInfo().getLocation(), System::currentTimeMillis);
+    }
+
+    CursorMoveListener(RobotMouseTracker robotTracker, AutoSquealConfig config,
+                       Supplier<Point> currentPosition, LongSupplier clock) {
+        this.robotTracker = robotTracker;
+        this.config = config;
+        this.currentPosition = currentPosition;
+        this.clock = clock;
+    }
+
+    /**
+     * Reports that the user pressed a key: keyboard activity counts as
+     * presence, so it resets the away timer at the next poll. Safe to call
+     * from any thread.
+     */
+    public void reportKeyboardActivity() {
+        keyboardActivity = true;
     }
 
     @Override
     public void run() {
-        int newX = MouseInfo.getPointerInfo().getLocation().x;
-        int newY = MouseInfo.getPointerInfo().getLocation().y;
 
-        if(newX != oldX || newY != oldY) {
+        // consume the keyboard activity reported since the previous poll
-            // cursor has been moved
+        boolean keyboardActivity = this.keyboardActivity;
-            loops = 0;
+        this.keyboardActivity = false;
-            LOGGER.info("User is no longer away!");
+
-        } else {
+        Point location = currentPosition.get();
-            if (loops < 30) {
+        long now = clock.getAsLong();
-                loops++;
+
-            } else {
+        if (firstPoll) {
-                LOGGER.info("User is away!");
+            // seed the comparison baseline and the activity clock, so that
-            }
+            // the first poll is neither a movement nor a full idle period
+            firstPoll = false;
+            lastSeenX = location.x;
+            lastSeenY = location.y;
+            lastUserActivityTime = now;
+            return;
         }
 
-        isUserAway = loops >= 30;
+        boolean positionChanged = location.x != lastSeenX || location.y != lastSeenY;
+        boolean userMoved = keyboardActivity || (positionChanged && !isAppMovement(location));
 
-        oldX = newX;
+        if (userMoved) {
-        oldY = newY;
+            lastUserActivityTime = now;
+        }
+
+        boolean away = now - lastUserActivityTime >= config.getAwayThresholdSeconds() * 1000L;
+        if (away && !userAway) {
+            LOGGER.info("User is away!");
+        } else if (!away && userAway) {
+            LOGGER.info("User is no longer away!");
+        }
+        userAway = away;
+
+        lastSeenX = location.x;
+        lastSeenY = location.y;
+    }
+
+    /**
+     * Whether a position change was (most likely) caused by the app itself:
+     * either a movement is currently in progress, or the cursor is exactly
+     * where the app last left it.
+     */
+    private boolean isAppMovement(Point location) {
+        return robotTracker.isMoving() || robotTracker.isLastPosition(location.x, location.y);
     }
 
     public boolean isUserAway() {
-        return isUserAway;
+        return userAway;
     }
-}
+}

src/main/java/wtf/beatrice/autosqueal/listener/KeyPressListener.java

@@ -1,57 +1,73 @@
 package wtf.beatrice.autosqueal.listener;
 
-import com.github.kwhat.jnativehook.GlobalScreen;
-import com.github.kwhat.jnativehook.NativeHookException;
 import com.github.kwhat.jnativehook.keyboard.NativeKeyEvent;
 import com.github.kwhat.jnativehook.keyboard.NativeKeyListener;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
-import wtf.beatrice.autosqueal.Main;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
 
 import java.util.ArrayList;
 import java.util.List;
 
-public class KeyPressListener implements NativeKeyListener
+/**
-{
+ * Listens for the global toggle hotkey, and reports every key press to the
+ * away detection: a user who is typing is present, hotkey or not.
+ *
+ * The listener is fully decoupled: it receives the actions to run instead
+ * of reaching into the main window, so it can be wired — and tested — on
+ * its own.
+ */
+public class KeyPressListener implements NativeKeyListener {
+
     private static final Logger LOGGER = LogManager.getLogger(KeyPressListener.class);
-    private static final List<Integer> pressedKeysIds = new ArrayList<>();
+
+    private final Runnable toggleAction;
+    private final Runnable keyboardActivityReporter;
+    private final AutoSquealConfig config;
+    private final List<Integer> pressedKeys = new ArrayList<>();
+
+    public KeyPressListener(Runnable toggleAction, Runnable keyboardActivityReporter, AutoSquealConfig config) {
+        this.toggleAction = toggleAction;
+        this.keyboardActivityReporter = keyboardActivityReporter;
+        this.config = config;
+    }
 
     @Override
     public void nativeKeyPressed(NativeKeyEvent e) {
-        LOGGER.info("Key Pressed: {}", NativeKeyEvent.getKeyText(e.getKeyCode()));
+        // the OS fires repeated "press" events while a key is being held down; ignore them,
-
+        // otherwise holding the toggle combo down would rapidly toggle the app on and off
-        if (e.getKeyCode() == NativeKeyEvent.VC_ESCAPE) {
+        if (pressedKeys.contains(e.getKeyCode())) {
-            try {
+            return;
-                GlobalScreen.unregisterNativeHook();
-            } catch (NativeHookException nativeHookException) {
-                LOGGER.error("Failed to unregister native hook", nativeHookException);
-            }
         }
 
-        pressedKeysIds.add(e.getKeyCode());
+        pressedKeys.add(e.getKeyCode());
+        LOGGER.debug("Key Pressed: {}", NativeKeyEvent.getKeyText(e.getKeyCode()));
 
-        handlePressedKeys();
+        // any key the user presses means they are present: let the away
+        // detection know, so the app doesn't grab the mouse while they type
+        keyboardActivityReporter.run();
+
+        if (!config.isHotkeyEnabled()) {
+            return;
+        }
+
+        // toggle only when the second key of the combo is pressed down: not only does this
+        // fire exactly once per combo, but it also avoids toggling when any other key is
+        // pressed or released while ctrl+alt happen to be held down
+        if ((e.getKeyCode() == NativeKeyEvent.VC_CONTROL && pressedKeys.contains(NativeKeyEvent.VC_ALT))
+                || (e.getKeyCode() == NativeKeyEvent.VC_ALT && pressedKeys.contains(NativeKeyEvent.VC_CONTROL))) {
+            LOGGER.info("Received toggle hotkey: [{}][{}]",
+                    NativeKeyEvent.getKeyText(NativeKeyEvent.VC_CONTROL),
+                    NativeKeyEvent.getKeyText(NativeKeyEvent.VC_ALT));
+
+            toggleAction.run();
+        }
     }
 
     @Override
     public void nativeKeyReleased(NativeKeyEvent e) {
-        LOGGER.info("Key Released: {}", NativeKeyEvent.getKeyText(e.getKeyCode()));
+        LOGGER.debug("Key Released: {}", NativeKeyEvent.getKeyText(e.getKeyCode()));
 
-        pressedKeysIds.remove((Integer) e.getKeyCode());
+        pressedKeys.remove((Integer) e.getKeyCode());
-
-        handlePressedKeys();
     }
-
+}
-    private void handlePressedKeys() {
-        if (pressedKeysIds.contains(NativeKeyEvent.VC_ALT) &&
-        pressedKeysIds.contains(NativeKeyEvent.VC_CONTROL)) {
-
-            StringBuilder keys = new StringBuilder();
-            pressedKeysIds.forEach(keyCode -> keys.append("[").append(NativeKeyEvent.getKeyText(keyCode)).append("]"));
-
-            LOGGER.warn("Received shutdown keystroke: {}", keys);
-
-            Main.getMainWindow().toggleRunning();
-        }
-    }
-}

src/main/java/wtf/beatrice/autosqueal/ui/MainWindow.java

@@ -3,15 +3,27 @@ package wtf.beatrice.autosqueal.ui;
 import com.github.kwhat.jnativehook.keyboard.NativeKeyEvent;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
+import wtf.beatrice.autosqueal.Main;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+import wtf.beatrice.autosqueal.config.ScreenArea;
 import wtf.beatrice.autosqueal.controls.CursorMover;
+import wtf.beatrice.autosqueal.controls.RobotMouseTracker;
 import wtf.beatrice.autosqueal.listener.CursorMoveListener;
 import wtf.beatrice.autosqueal.util.RunnerUtil;
 import wtf.beatrice.autosqueal.util.SystemUtil;
 
 import javax.swing.*;
 import java.awt.*;
+import java.awt.desktop.QuitStrategy;
+import java.awt.event.WindowAdapter;
+import java.awt.event.WindowEvent;
 import java.awt.image.BufferedImage;
-import java.util.Timer;
+import java.io.IOException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.Supplier;
 
 public class MainWindow
 {
@@ -20,22 +32,71 @@ public class MainWindow
     private static final int WINDOW_HEIGHT = 700;
     private static final int WINDOW_WIDTH = 800;
 
-    private Timer timerRunner = new Timer();
+    private static final long AUTOMATION_START_DELAY_SECONDS = 1L;
-    private CursorMover cursorMover = new CursorMover();
+    private static final long AWAY_POLL_INTERVAL_SECONDS = 1L;
-    private Button toggleButton;
 
+    private final JFrame frame = new JFrame();
+    private JButton toggleButton;
+
+    private final AutoSquealConfig config;
+
+    // the away detection tracks the user, not the automation: it lives from
+    // the window's creation and is polled only while the automation runs
+    private final RobotMouseTracker robotTracker;
+    private final CursorMoveListener awayDetector;
+
+    /**
+     * Creates the window around the given settings: the components read
+     * them live, so a change applies without a restart.
+     */
+    public MainWindow(AutoSquealConfig config) {
+        this.config = config;
+        this.robotTracker = new RobotMouseTracker();
+        this.awayDetector = new CursorMoveListener(robotTracker, config);
+    }
+
+    private ScheduledExecutorService periodicScheduler;
+    private ExecutorService movementExecutor;
+    private CursorMover cursorMover;
+
+    private TrayIcon trayIcon;
+    private MenuItem trayToggleItem;
+
+    /** Whether cleanup already ran, so it can safely be called twice. */
+    private boolean cleanedUp = false;
+
+    /**
+     * Builds and shows the main window, and starts the automation.
+     * Must be called on the EDT.
+     */
     public void init() {
 
-        JFrame frame = new JFrame();
         frame.setSize(new Dimension(WINDOW_WIDTH, WINDOW_HEIGHT));
         frame.setTitle("autosqueal");
         frame.setResizable(false);
+        frame.setDefaultCloseOperation(WindowConstants.EXIT_ON_CLOSE);
+        frame.addWindowListener(new WindowAdapter() {
+            @Override
+            public void windowClosing(WindowEvent e) {
+                cleanup();
+            }
+        });
 
-        toggleButton = new Button();
+        // ⌘Q on macOS defaults to calling System.exit(0) directly, which
+        // bypasses windowClosing and skips cleanup: route quits through
+        // the window instead, so the hook is always released
+        if (Desktop.isDesktopSupported()) {
+            try {
+                Desktop.getDesktop().setQuitStrategy(QuitStrategy.CLOSE_ALL_WINDOWS);
+            } catch (UnsupportedOperationException ex) {
+                LOGGER.debug("Quit strategy not supported here", ex);
+            }
+        }
+
+        toggleButton = new JButton();
         toggleButton.setBounds(new Rectangle((WINDOW_WIDTH / 2) - 60, WINDOW_HEIGHT - 60, 120, 30));
         toggleButton.addActionListener(e -> toggleRunning());
         frame.add(toggleButton);
-        toggleRunning();
 
         int bordersPx = 10;
         int rescaleRateo = ((WINDOW_WIDTH - (2 * bordersPx)) * 100) / RunnerUtil.SCREEN_WIDTH;
@@ -50,9 +111,17 @@ public class MainWindow
         timestampLabel.setBounds(new Rectangle(bordersPx, bordersPx + rescaleHeight + bordersPx, 100, 30));
         frame.add(timestampLabel);
 
-
         frame.setLayout(null);
         frame.setVisible(true);
+
+        if (SystemTray.isSupported()) {
+            addTrayIcon();
+        }
+
+        if (config.isStartAutomatically()) {
+            startAutomation();
+        }
+        updateToggleLabel();
     }
 
     private Image getScreenCapture(int rescaleWidth, int rescaleHeight) {
@@ -82,56 +151,227 @@ public class MainWindow
         return null;
     }
 
-    public BufferedImage getBufferedImage(Image img) {
+    /**
-        if (img instanceof BufferedImage image)
+     * Adds a menu bar icon with a toggle entry and a quit entry, so the
-        {
+     * automation can be controlled even with the window closed.
-            return image;
+     */
+    private void addTrayIcon() {
+        PopupMenu menu = new PopupMenu();
+
+        trayToggleItem = new MenuItem();
+        trayToggleItem.addActionListener(e -> toggleRunning());
+        menu.add(trayToggleItem);
+
+        MenuItem quitItem = new MenuItem("Quit");
+        quitItem.addActionListener(e -> {
+            cleanup();
+            System.exit(0);
+        });
+        menu.add(quitItem);
+
+        trayIcon = new TrayIcon(createTrayIconImage(), "autosqueal", menu);
+        trayIcon.setImageAutoSize(true);
+
+        try {
+            SystemTray.getSystemTray().add(trayIcon);
+        } catch (AWTException ex) {
+            LOGGER.error("Could not add the tray icon", ex);
+            trayIcon = null;
+            trayToggleItem = null;
         }
-
-        // Create a buffered image with transparency
-        BufferedImage bimage = new BufferedImage(img.getWidth(null), img.getHeight(null), BufferedImage.TYPE_INT_ARGB);
-
-        // Draw the image on to the buffered image
-        Graphics2D bGr = bimage.createGraphics();
-        bGr.drawImage(img, 0, 0, null);
-        bGr.dispose();
-
-        // Return the buffered image
-        return bimage;
     }
 
+    /** Draws the little mouse pointer used as tray icon. */
+    private Image createTrayIconImage() {
+        BufferedImage image = new BufferedImage(16, 16, BufferedImage.TYPE_INT_ARGB);
+
+        int[] xPoints = {3, 3, 6, 8, 10, 8, 12};
+        int[] yPoints = {1, 12, 8, 12, 11, 7, 7};
+
+        Graphics2D graphics = image.createGraphics();
+        graphics.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
+        graphics.setColor(Color.BLACK);
+        graphics.fillPolygon(xPoints, yPoints, xPoints.length);
+        graphics.setColor(Color.WHITE);
+        graphics.drawPolygon(xPoints, yPoints, xPoints.length);
+        graphics.dispose();
+
+        return image;
+    }
+
+    /**
+     * Stops the automation and releases everything the app is holding.
+     * Safe to call more than once, from any thread: window closing and
+     * JVM shutdown hooks can race each other on the way out.
+     */
+    public synchronized void cleanup() {
+        if (cleanedUp) {
+            return;
+        }
+        cleanedUp = true;
+
+        LOGGER.info("Shutting down...");
+        stopAutomation();
+
+        if (trayIcon != null) {
+            SystemTray.getSystemTray().remove(trayIcon);
+            trayIcon = null;
+        }
+
+        Main.unregisterJNativeHook();
+    }
+
+    /**
+     * Explains which permissions the app needs and offers to open each pane.
+     * the hook is retried on demand, so the app can start working without a
+     * restart. must be called on the EDT, after the window is visible.
+     */
+    public void showPermissionsHelp() {
+        Object[] options = {"Open Device Control Settings", "Open Screen Recording Settings", "Try Again", "Close"};
+
+        while (true) {
+            int choice = JOptionPane.showOptionDialog(frame,
+                    "autosqueal needs three separate permissions to work:\n\n"
+                            + "1. device control and data access — called \"accessibility\" on older macos\n"
+                            + "   versions — lets the app listen for the ctrl+alt hotkey.\n"
+                            + "   if the pane shows a separate \"events\" switch for autosqueal, turn\n"
+                            + "   that on too: it is what lets the app move the mouse and click.\n\n"
+                            + "2. screen recording — lets the app take the screenshot shown\n"
+                            + "   in the main window.\n\n"
+                            + "open each pane, unlock it, and make sure autosqueal is listed and switched on.\n"
+                            + "if it is already listed, remove it with the minus button and re-add it:\n"
+                            + "every rebuild looks like a different app to the system.\n"
+                            + "when you are done, press \"try again\".",
+                    "permissions needed",
+                    JOptionPane.DEFAULT_OPTION,
+                    JOptionPane.WARNING_MESSAGE,
+                    null,
+                    options,
+                    options[0]);
+
+            if (choice == 0) {
+                openPrivacyPane("Privacy_Accessibility");
+            } else if (choice == 1) {
+                openPrivacyPane("Privacy_ScreenCapture");
+            } else if (choice == 2) {
+                if (Main.registerJNativeHook()) {
+                    LOGGER.info("The native hook was registered on a later attempt!");
+                    return;
+                }
+            } else {
+                // closed or gave up: leave the app running, the window and the
+                // tray icon still work
+                return;
+            }
+        }
+    }
+
+    /** Opens the privacy & security pane for the given anchor. */
+    private void openPrivacyPane(String privacyAnchor) {
+        if (SystemUtil.getHostSystem() != SystemUtil.OperatingSystem.MAC_OS) {
+            return;
+        }
+
+        try {
+            new ProcessBuilder("open",
+                    "x-apple.systempreferences:com.apple.preference.security?" + privacyAnchor)
+                    .start();
+        } catch (IOException ex) {
+            LOGGER.error("Could not open the system settings", ex);
+        }
+    }
+
+    /**
+     * Forwards keyboard activity to the away detection, so that typing
+     * counts as presence even when the mouse never moves.
+     */
+    public void notifyKeyboardActivity() {
+        awayDetector.reportKeyboardActivity();
+    }
+
+    /**
+     * Toggles the automation on or off. Safe to call from any thread: the actual
+     * work is always marshalled to the EDT, since it touches Swing components.
+     */
     public void toggleRunning() {
-
+        SwingUtilities.invokeLater(() -> {
-        String label;
+            if (cursorMover == null) {
-
+                startAutomation();
-        if (cursorMover == null) {
+            } else {
-            timerRunner = new Timer();
+                stopAutomation();
-            CursorMoveListener cursorMoveListener = new CursorMoveListener();
+            }
-            timerRunner.schedule(cursorMoveListener, 0L, 1000L);
+            updateToggleLabel();
-
+        });
-            cursorMover = new CursorMover();
-            timerRunner.schedule(cursorMover, 1000L, RunnerUtil.SECONDS_BETWEEN_MOVES * 1000L);
-
-            label = "Stop [" +
-                    NativeKeyEvent.getKeyText(NativeKeyEvent.VC_CONTROL) +
-                    "][" +
-                    NativeKeyEvent.getKeyText(NativeKeyEvent.VC_ALT) +
-                    "]";
-        }
-        else {
-            timerRunner.cancel();
-
-            cursorMover = null;
-
-            label = "Start [" +
-                    NativeKeyEvent.getKeyText(NativeKeyEvent.VC_CONTROL) +
-                    "][" +
-                    NativeKeyEvent.getKeyText(NativeKeyEvent.VC_ALT) +
-                    "]";
-        }
-
-        toggleButton.setLabel(label);
-
     }
 
-}
+    private void startAutomation() {
+        LOGGER.info("Starting automation");
+
+        // periodic work (polling and movement cadence) on a classic scheduler,
+        // so that it can be scheduled with fixed delays
+        periodicScheduler = Executors.newScheduledThreadPool(2, runnable -> {
+            Thread thread = new Thread(runnable, "autosqueal-scheduler");
+            thread.setDaemon(true);
+            return thread;
+        });
+
+        // movements and clicks run on virtual threads: they mostly sleep,
+        // and blocking them costs nothing
+        movementExecutor = Executors.newThreadPerTaskExecutor(
+                Thread.ofVirtual().name("autosqueal-movement-").factory());
+
+        // away-detection: polls the cursor position and ignores the movements
+        // the app performs itself, as reported by the robot mouse tracker.
+        // the automation only moves the mouse when the user is away.
+        periodicScheduler.scheduleWithFixedDelay(awayDetector, 0L, AWAY_POLL_INTERVAL_SECONDS, TimeUnit.SECONDS);
+
+        // the movement bounds are read again at every movement, so a change
+        // of setting applies from the next movement without a restart. the
+        // corner click always aims at the main screen, whatever screens the
+        // cursor may otherwise travel to.
+        Supplier<Rectangle> movementBounds = () -> RunnerUtil.screenBounds(config.getMovementScreen());
+        Supplier<Rectangle> primaryScreenBounds = () -> RunnerUtil.screenBounds(ScreenArea.PRIMARY);
+
+        cursorMover = new CursorMover(movementExecutor, robotTracker, awayDetector::isUserAway,
+                config, movementBounds, primaryScreenBounds);
+        periodicScheduler.scheduleWithFixedDelay(cursorMover,
+                AUTOMATION_START_DELAY_SECONDS,
+                config.getMoveIntervalSeconds(),
+                TimeUnit.SECONDS);
+    }
+
+    private void stopAutomation() {
+        LOGGER.info("Stopping automation");
+
+        if (periodicScheduler != null) {
+            periodicScheduler.shutdownNow();
+            periodicScheduler = null;
+        }
+
+        if (movementExecutor != null) {
+            // interrupts the in-flight movement threads, too
+            movementExecutor.shutdownNow();
+            movementExecutor = null;
+        }
+
+        cursorMover = null;
+    }
+
+    private void updateToggleLabel() {
+        if (toggleButton == null) {
+            // the window is not initialized yet
+            return;
+        }
+
+        String hotkey = "[" + NativeKeyEvent.getKeyText(NativeKeyEvent.VC_CONTROL) + "]"
+                + "[" + NativeKeyEvent.getKeyText(NativeKeyEvent.VC_ALT) + "]";
+
+        String label = (cursorMover == null ? "Start " : "Stop ") + hotkey;
+
+        toggleButton.setText(label);
+        if (trayToggleItem != null) {
+            trayToggleItem.setLabel(label);
+        }
+    }
+
+}

src/main/java/wtf/beatrice/autosqueal/util/RunnerUtil.java

@@ -1,5 +1,7 @@
 package wtf.beatrice.autosqueal.util;
 
+import wtf.beatrice.autosqueal.config.ScreenArea;
+
 import java.awt.*;
 
 public class RunnerUtil {
@@ -8,9 +10,35 @@ public class RunnerUtil {
         throw new AssertionError("The RunnerUtil class is not intended to be instantiated.");
     }
 
-    public static final int SECONDS_BETWEEN_MOVES = 10;
-
     public static final int SCREEN_HEIGHT = Toolkit.getDefaultToolkit().getScreenSize().height;
     public static final int SCREEN_WIDTH = Toolkit.getDefaultToolkit().getScreenSize().width;
 
+    /**
+     * The bounds of the screens the cursor may travel to, according to the
+     * given setting. Fetched on every call, so that a change of setting, or
+     * a screen plugged in while the app runs, is picked up by the next
+     * movement.
+     *
+     * The result is never empty: when no screen is found, the main screen
+     * is returned, because it always exists.
+     */
+    public static Rectangle screenBounds(ScreenArea area) {
+        Rectangle bounds = new Rectangle();
+
+        if (area == ScreenArea.ALL) {
+            for (GraphicsDevice device : GraphicsEnvironment.getLocalGraphicsEnvironment().getScreenDevices()) {
+                bounds.add(device.getDefaultConfiguration().getBounds());
+            }
+        }
+
+        if (bounds.isEmpty()) {
+            // the main screen was requested, or no other screen was found
+            bounds = GraphicsEnvironment.getLocalGraphicsEnvironment()
+                    .getDefaultScreenDevice().getDefaultConfiguration().getBounds();
+        }
+
+        // defensive copy: the callers treat the rectangle as theirs
+        return new Rectangle(bounds);
+    }
+
 }

src/main/java/wtf/beatrice/autosqueal/util/SystemUtil.java

@@ -1,19 +1,45 @@
 package wtf.beatrice.autosqueal.util;
 
+import java.nio.file.Path;
 import java.util.Locale;
 
 public class SystemUtil
 {
 
     public static OperatingSystem getHostSystem() {
-        String osName = System.getProperty("os.name").toLowerCase(Locale.ENGLISH);
+        return fromOsName(System.getProperty("os.name"));
-        if (osName.contains("win")) {
+    }
+
+    /**
+     * The per-user directory where the app keeps its settings, following
+     * the conventions of the host platform.
+     */
+    public static Path getAppConfigDir() {
+        String home = System.getProperty("user.home", ".");
+        String appData = System.getenv("APPDATA");
+        String xdgConfigHome = System.getenv("XDG_CONFIG_HOME");
+
+        return switch (getHostSystem()) {
+            case MAC_OS -> Path.of(home, "Library", "Application Support", "autosqueal");
+            case WINDOWS -> appData != null && !appData.isBlank()
+                    ? Path.of(appData, "autosqueal")
+                    : Path.of(home, ".autosqueal");
+            case LINUX -> xdgConfigHome != null && !xdgConfigHome.isBlank()
+                    ? Path.of(xdgConfigHome, "autosqueal")
+                    : Path.of(home, ".config", "autosqueal");
+            default -> Path.of(home, ".autosqueal");
+        };
+    }
+
+    public static OperatingSystem fromOsName(String osName) {
+        String normalizedOsName = osName.toLowerCase(Locale.ENGLISH);
+        if (normalizedOsName.contains("win")) {
             return OperatingSystem.WINDOWS;
-        } else if (osName.contains("nix") ||
+        } else if (normalizedOsName.contains("nix") ||
-                osName.contains("nux") ||
+                normalizedOsName.contains("nux") ||
-                osName.contains("aix")) {
+                normalizedOsName.contains("aix")) {
             return OperatingSystem.LINUX;
-        } else if (osName.contains("mac")) {
+        } else if (normalizedOsName.contains("mac")) {
             return OperatingSystem.MAC_OS;
         } else {
             return OperatingSystem.UNKNOWN;

src/main/resources/log4j2.xml

@@ -1,17 +1,13 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<Configuration status="INFO">
+<Configuration status="WARN">
     <Appenders>
         <Console name="ConsoleAppender" target="SYSTEM_OUT">
             <PatternLayout pattern="[%d{HH:mm:ss.SSS}] [%t] %-4level | %logger{36} - %msg%n" />
         </Console>
-        <File name="FileAppender" fileName="application-${date:yyyyMMdd}.log" immediateFlush="false" append="true">
-            <PatternLayout pattern="[%d{yyy-MM-dd HH:mm:ss.SSS}] [%t] %-4level | %logger{36} - %msg%n"/>
-        </File>
     </Appenders>
     <Loggers>
         <Root level="debug">
             <AppenderRef ref="ConsoleAppender" />
-            <AppenderRef ref="FileAppender"/>
         </Root>
     </Loggers>
 </Configuration>

src/test/java/wtf/beatrice/autosqueal/config/ConfigStoreTest.java

@@ -0,0 +1,125 @@
+package wtf.beatrice.autosqueal.config;
+
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.io.TempDir;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class ConfigStoreTest
+{
+    @TempDir
+    Path tempDir;
+
+    private ConfigStore store;
+
+    @BeforeEach
+    void createStore() {
+        store = new ConfigStore(tempDir.resolve("autosqueal.properties"));
+    }
+
+    @Test
+    void missingFileYieldsTheDefaults() {
+        AutoSquealConfig config = store.load();
+
+        assertEquals(30, config.getAwayThresholdSeconds());
+        assertEquals(10, config.getMoveIntervalSeconds());
+        assertEquals(2, config.getStepDelayMilliseconds());
+        assertTrue(config.isClickEnabled());
+        assertEquals(5, config.getClickEveryNMoves());
+        assertEquals(ScreenArea.PRIMARY, config.getMovementScreen());
+        assertTrue(config.isStartAutomatically());
+        assertTrue(config.isHotkeyEnabled());
+    }
+
+    @Test
+    void savedSettingsLoadBack() {
+        AutoSquealConfig config = new AutoSquealConfig();
+        config.setAwayThresholdSeconds(45);
+        config.setMoveIntervalSeconds(20);
+        config.setStepDelayMilliseconds(4);
+        config.setClickEnabled(false);
+        config.setClickEveryNMoves(7);
+        config.setMovementScreen(ScreenArea.ALL);
+        config.setStartAutomatically(false);
+        config.setHotkeyEnabled(false);
+
+        store.save(config);
+        AutoSquealConfig loaded = store.load();
+
+        assertEquals(45, loaded.getAwayThresholdSeconds());
+        assertEquals(20, loaded.getMoveIntervalSeconds());
+        assertEquals(4, loaded.getStepDelayMilliseconds());
+        assertFalse(loaded.isClickEnabled());
+        assertEquals(7, loaded.getClickEveryNMoves());
+        assertEquals(ScreenArea.ALL, loaded.getMovementScreen());
+        assertFalse(loaded.isStartAutomatically());
+        assertFalse(loaded.isHotkeyEnabled());
+    }
+
+    @Test
+    void outOfRangeValuesAreClamped() throws IOException {
+        writeFile(ConfigStore.KEY_AWAY_THRESHOLD_SECONDS + "=0",
+                ConfigStore.KEY_MOVE_INTERVAL_SECONDS + "=99999999",
+                ConfigStore.KEY_STEP_DELAY_MILLISECONDS + "=-3",
+                ConfigStore.KEY_CLICK_EVERY_N_MOVES + "=1000");
+
+        AutoSquealConfig config = store.load();
+
+        assertEquals(5, config.getAwayThresholdSeconds());
+        assertEquals(3600, config.getMoveIntervalSeconds());
+        assertEquals(1, config.getStepDelayMilliseconds());
+        assertEquals(100, config.getClickEveryNMoves());
+    }
+
+    @Test
+    void invalidValuesKeepTheDefaults() throws IOException {
+        writeFile(ConfigStore.KEY_AWAY_THRESHOLD_SECONDS + "=soon",
+                ConfigStore.KEY_CLICK_ENABLED + "=banana",
+                ConfigStore.KEY_MOVEMENT_SCREEN + "=THE_MOON",
+                ConfigStore.KEY_MOVE_INTERVAL_SECONDS + "=15");
+
+        AutoSquealConfig config = store.load();
+
+        assertEquals(30, config.getAwayThresholdSeconds());
+        assertTrue(config.isClickEnabled());
+        assertEquals(ScreenArea.PRIMARY, config.getMovementScreen());
+        // the one valid value still loads
+        assertEquals(15, config.getMoveIntervalSeconds());
+    }
+
+    @Test
+    void settingsSettersClampToo() {
+        AutoSquealConfig config = new AutoSquealConfig();
+
+        config.setAwayThresholdSeconds(-10);
+        assertEquals(5, config.getAwayThresholdSeconds());
+
+        config.setAwayThresholdSeconds(10_000);
+        assertEquals(600, config.getAwayThresholdSeconds());
+
+        config.setMovementScreen(null);
+        assertEquals(ScreenArea.PRIMARY, config.getMovementScreen());
+    }
+
+    @Test
+    void savingNeverLeavesTempFilesBehind() throws IOException {
+        store.save(new AutoSquealConfig());
+
+        assertTrue(Files.isRegularFile(tempDir.resolve("autosqueal.properties")));
+        try (var files = Files.list(tempDir)) {
+            assertEquals(1, files.count());
+        }
+    }
+
+    private void writeFile(String... lines) throws IOException {
+        Files.write(tempDir.resolve("autosqueal.properties"), List.of(lines));
+    }
+}

src/test/java/wtf/beatrice/autosqueal/controls/CursorMoverTest.java

@@ -0,0 +1,187 @@
+package wtf.beatrice.autosqueal.controls;
+
+import org.junit.jupiter.api.Test;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+
+import java.awt.Point;
+import java.awt.Rectangle;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Random;
+import java.util.concurrent.AbstractExecutorService;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class CursorMoverTest
+{
+    private static final Point CURSOR_AT = new Point(100, 100);
+
+    private final RobotMouseTracker robotTracker = new RobotMouseTracker();
+    private final AutoSquealConfig config = new AutoSquealConfig();
+    private final RecordingExecutor executor = new RecordingExecutor();
+
+    /** Bounds of a pretend multi-screen setup: the main screen is offset. */
+    private final Rectangle movementBounds = new Rectangle(100, 50, 800, 600);
+    private final Rectangle primaryBounds = new Rectangle(100, 50, 800, 600);
+
+    /** A mover that queues its movements on the recording executor. */
+    private CursorMover mover() {
+        return new CursorMover(executor, robotTracker, () -> true, config,
+                () -> movementBounds, () -> primaryBounds,
+                new Random(42), () -> CURSOR_AT);
+    }
+
+    private List<SingleStepMovementTask> movements() {
+        List<SingleStepMovementTask> movements = new ArrayList<>();
+        for (Runnable movement : executor.movements) {
+            movements.add((SingleStepMovementTask) movement);
+        }
+        return movements;
+    }
+
+    @Test
+    void movementsAreSkippedWhileTheUserIsPresent() {
+        // the automation only moves the mouse when the user is away
+        CursorMover presentMover = new CursorMover(executor, robotTracker, () -> false, config,
+                () -> movementBounds, () -> primaryBounds,
+                new Random(42), () -> CURSOR_AT);
+
+        for (int i = 0; i < 10; i++) {
+            presentMover.run();
+        }
+
+        assertTrue(executor.movements.isEmpty());
+    }
+
+    @Test
+    void randomMovementsStayWithinTheBounds() {
+        config.setClickEnabled(false);
+
+        CursorMover cursorMover = mover();
+        for (int i = 0; i < 50; i++) {
+            cursorMover.run();
+        }
+
+        List<SingleStepMovementTask> movements = movements();
+        assertEquals(50, movements.size());
+        for (SingleStepMovementTask movement : movements) {
+            assertFalse(movement.isClick());
+            assertTrue(movement.getDestX() >= 100, "destX below the bounds: " + movement.getDestX());
+            assertTrue(movement.getDestX() < 900, "destX above the bounds: " + movement.getDestX());
+            assertTrue(movement.getDestY() >= 50, "destY below the bounds: " + movement.getDestY());
+            assertTrue(movement.getDestY() < 650, "destY above the bounds: " + movement.getDestY());
+        }
+    }
+
+    @Test
+    void cornerClicksHappenEveryNthMovement() {
+        config.setClickEveryNMoves(3);
+
+        CursorMover cursorMover = mover();
+        for (int i = 0; i < 6; i++) {
+            cursorMover.run();
+        }
+
+        List<SingleStepMovementTask> movements = movements();
+        assertEquals(6, movements.size());
+
+        // one movement every 3: the 3rd and the 6th are corner clicks
+        assertFalse(movements.get(0).isClick());
+        assertFalse(movements.get(1).isClick());
+        assertTrue(movements.get(2).isClick());
+        assertFalse(movements.get(3).isClick());
+        assertFalse(movements.get(4).isClick());
+        assertTrue(movements.get(5).isClick());
+    }
+
+    @Test
+    void cornerClicksAimAtTheMainScreensTopRight() {
+        // the click must open the notifications, which live on the main
+        // screen's corner: wherever the movement bounds are, the click
+        // destination follows the main screen
+        config.setClickEveryNMoves(3);
+        Rectangle elsewhere = new Rectangle(5000, 5000, 200, 200);
+        CursorMover cursorMover = new CursorMover(executor, robotTracker, () -> true, config,
+                () -> elsewhere, () -> primaryBounds,
+                new Random(42), () -> CURSOR_AT);
+
+        cursorMover.run(); // iteration 0: a normal movement
+        cursorMover.run(); // iteration 1: a normal movement
+        cursorMover.run(); // iteration 2: the corner click
+
+        List<SingleStepMovementTask> movements = movements();
+        assertTrue(movements.get(2).isClick());
+        // the main screen's top-right corner, 5px inside
+        assertEquals(100 + 800 - 5, movements.get(2).getDestX());
+        assertEquals(50 + 5, movements.get(2).getDestY());
+    }
+
+    @Test
+    void clicksCanBeTurnedOff() {
+        config.setClickEnabled(false);
+
+        CursorMover cursorMover = mover();
+        for (int i = 0; i < 10; i++) {
+            cursorMover.run();
+        }
+
+        for (SingleStepMovementTask movement : movements()) {
+            assertFalse(movement.isClick());
+        }
+    }
+
+    @Test
+    void clickCadenceIsReadLive() {
+        config.setClickEveryNMoves(2);
+
+        CursorMover cursorMover = mover();
+        cursorMover.run(); // iteration 0
+        cursorMover.run(); // iteration 1: click, cadence 2
+        assertTrue(movements().get(1).isClick());
+
+        // the user loosens the cadence while the automation runs
+        config.setClickEveryNMoves(4);
+        cursorMover.run(); // iteration 0
+        cursorMover.run(); // iteration 1
+        cursorMover.run(); // iteration 2
+        cursorMover.run(); // iteration 3: click, cadence 4
+
+        List<SingleStepMovementTask> movements = movements();
+        assertEquals(6, movements.size());
+        assertFalse(movements.get(2).isClick());
+        assertFalse(movements.get(3).isClick());
+        assertFalse(movements.get(4).isClick());
+        assertTrue(movements.get(5).isClick());
+    }
+
+    /** An executor that records the tasks instead of running them. */
+    private static class RecordingExecutor extends AbstractExecutorService {
+
+        final List<Runnable> movements = new ArrayList<>();
+
+        public void execute(Runnable command) {
+            movements.add(command);
+        }
+
+        public void shutdown() { }
+
+        public List<Runnable> shutdownNow() {
+            return List.of();
+        }
+
+        public boolean isShutdown() {
+            return false;
+        }
+
+        public boolean isTerminated() {
+            return false;
+        }
+
+        public boolean awaitTermination(long timeout, TimeUnit unit) {
+            return false;
+        }
+    }
+}

src/test/java/wtf/beatrice/autosqueal/controls/RobotMouseTrackerTest.java

@@ -0,0 +1,31 @@
+package wtf.beatrice.autosqueal.controls;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class RobotMouseTrackerTest
+{
+    @Test
+    void startsIdle() {
+        RobotMouseTracker tracker = new RobotMouseTracker();
+
+        assertFalse(tracker.isMoving());
+        assertFalse(tracker.isLastPosition(10, 20));
+    }
+
+    @Test
+    void tracksOngoingMovement() {
+        RobotMouseTracker tracker = new RobotMouseTracker();
+
+        tracker.moveStarted();
+        assertTrue(tracker.isMoving());
+
+        tracker.moveEnded(15, 25);
+        assertFalse(tracker.isMoving());
+        assertTrue(tracker.isLastPosition(15, 25));
+        assertFalse(tracker.isLastPosition(15, 26));
+        assertFalse(tracker.isLastPosition(25, 15));
+    }
+}

src/test/java/wtf/beatrice/autosqueal/controls/SingleStepMovementTaskTest.java

@@ -0,0 +1,117 @@
+package wtf.beatrice.autosqueal.controls;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.fail;
+
+class SingleStepMovementTaskTest
+{
+    private static final int MAX_TICKS = 20_000;
+    private static final float DELTA = 0.0f;
+
+    @Test
+    void noStepWhenAlreadyAtDestination() {
+        assertEquals(0.0f, SingleStepMovementTask.computeStepX(0, 0), DELTA);
+        assertEquals(0.0f, SingleStepMovementTask.computeStepY(0, 0), DELTA);
+    }
+
+    @Test
+    void axisAlignedMovementsProduceNoInfiniteSteps() {
+        // moving only horizontally: the y step must be 0, not Infinity or NaN
+        assertEquals(1.0f, SingleStepMovementTask.computeStepX(100, 0), DELTA);
+        assertEquals(0.0f, SingleStepMovementTask.computeStepY(100, 0), DELTA);
+
+        // moving only vertically: the x step must be 0, not Infinity or NaN
+        assertEquals(0.0f, SingleStepMovementTask.computeStepX(0, 100), DELTA);
+        assertEquals(1.0f, SingleStepMovementTask.computeStepY(0, 100), DELTA);
+    }
+
+    @Test
+    void diagonalMovementsMoveBothAxes() {
+        assertEquals(1.0f, SingleStepMovementTask.computeStepX(100, 100), DELTA);
+        assertEquals(1.0f, SingleStepMovementTask.computeStepY(100, 100), DELTA);
+
+        assertEquals(0.5f, SingleStepMovementTask.computeStepX(50, 100), DELTA);
+        assertEquals(1.0f, SingleStepMovementTask.computeStepY(50, 100), DELTA);
+
+        assertEquals(1.0f, SingleStepMovementTask.computeStepX(100, 50), DELTA);
+        assertEquals(0.5f, SingleStepMovementTask.computeStepY(100, 50), DELTA);
+    }
+
+    @Test
+    void stepsAreNeverInfiniteOrNaN() {
+        for (int lengthX = 0; lengthX <= 400; lengthX += 7) {
+            for (int lengthY = 0; lengthY <= 400; lengthY += 7) {
+                float stepX = SingleStepMovementTask.computeStepX(lengthX, lengthY);
+                float stepY = SingleStepMovementTask.computeStepY(lengthX, lengthY);
+
+                assertFalse(Float.isInfinite(stepX), "infinite stepX for lengths [" + lengthX + ", " + lengthY + "]");
+                assertFalse(Float.isNaN(stepX), "NaN stepX for lengths [" + lengthX + ", " + lengthY + "]");
+                assertFalse(Float.isInfinite(stepY), "infinite stepY for lengths [" + lengthX + ", " + lengthY + "]");
+                assertFalse(Float.isNaN(stepY), "NaN stepY for lengths [" + lengthX + ", " + lengthY + "]");
+            }
+        }
+    }
+
+    @Test
+    void advanceMovesTowardTheDestination() {
+        assertEquals(5.0f, SingleStepMovementTask.advance(5.0f, 5.0f, 1.0f), DELTA); // already there
+        assertEquals(9.0f, SingleStepMovementTask.advance(10.0f, 5.0f, 1.0f), DELTA); // decreasing
+        assertEquals(6.0f, SingleStepMovementTask.advance(5.0f, 10.0f, 1.0f), DELTA); // increasing
+    }
+
+    @Test
+    void adjustedStepUsesExactRemainderWhenClose() {
+        assertEquals(0.4f, SingleStepMovementTask.adjustedStep(10.0f, 10.4f, 1.0f), 0.00001f);
+        assertEquals(0.4f, SingleStepMovementTask.adjustedStep(10.8f, 10.4f, 1.0f), 0.00001f);
+        assertEquals(1.0f, SingleStepMovementTask.adjustedStep(10.0f, 20.0f, 1.0f), DELTA);
+    }
+
+    @Test
+    void movementConvergesToDestination() {
+        record MovementCase(float startX, float startY, int destX, int destY) {}
+
+        MovementCase[] cases = {
+                new MovementCase(100, 100, 500, 500),   // plain diagonal
+                new MovementCase(500, 500, 100, 100),   // going up-left
+                new MovementCase(100, 100, 500, 100),   // horizontal (used to break: infinite step)
+                new MovementCase(500, 100, 100, 100),   // horizontal, other direction
+                new MovementCase(100, 100, 100, 500),   // vertical (used to break: infinite step)
+                new MovementCase(100, 500, 100, 100),   // vertical, other direction
+                new MovementCase(105, 105, 105, 105),   // already at destination
+                new MovementCase(0, 0, 2000, 1000),     // steep diagonal
+                new MovementCase(2000, 1000, 0, 0),     // same, backwards
+                new MovementCase(37, 173, 2311, 997),   // random-ish, both directions mixed
+        };
+
+        for (MovementCase move : cases) {
+            float x = move.startX();
+            float y = move.startY();
+
+            int lengthX = Math.round(Math.abs(x - move.destX()));
+            int lengthY = Math.round(Math.abs(y - move.destY()));
+            float stepX = SingleStepMovementTask.computeStepX(lengthX, lengthY);
+            float stepY = SingleStepMovementTask.computeStepY(lengthX, lengthY);
+
+            boolean converged = false;
+            for (int tick = 0; tick < MAX_TICKS; tick++) {
+                if (Math.round(x) == move.destX() && Math.round(y) == move.destY()) {
+                    converged = true;
+                    break;
+                }
+
+                stepX = SingleStepMovementTask.adjustedStep(x, move.destX(), stepX);
+                stepY = SingleStepMovementTask.adjustedStep(y, move.destY(), stepY);
+                x = SingleStepMovementTask.advance(x, move.destX(), stepX);
+                y = SingleStepMovementTask.advance(y, move.destY(), stepY);
+            }
+
+            if (!converged) {
+                fail("movement did not converge: stuck at [" + Math.round(x) + ", " + Math.round(y)
+                        + "] while heading to [" + move.destX() + ", " + move.destY() + "]");
+            }
+        }
+    }
+}

src/test/java/wtf/beatrice/autosqueal/listener/CursorMoveListenerTest.java

@@ -0,0 +1,281 @@
+package wtf.beatrice.autosqueal.listener;
+
+import org.junit.jupiter.api.Test;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+import wtf.beatrice.autosqueal.controls.RobotMouseTracker;
+
+import java.awt.*;
+import java.util.ArrayDeque;
+import java.util.Queue;
+
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+class CursorMoveListenerTest
+{
+    private static final int AWAY_THRESHOLD_SECONDS = 30;
+
+    private final RobotMouseTracker robotTracker = new RobotMouseTracker();
+
+    /** The fake clock the listener polls with, in milliseconds. */
+    private long now = 1_000_000L;
+
+    /** Builds a listener that reads scripted cursor positions, one per poll. */
+    private CursorMoveListener scriptedListener(Point... positions) {
+        Queue<Point> positionQueue = new ArrayDeque<>(java.util.List.of(positions));
+        return new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positionQueue::remove, () -> now);
+    }
+
+    private static Point at(int x, int y) {
+        return new Point(x, y);
+    }
+
+    /** Polls, pretending that the given seconds have passed since the previous poll. */
+    private void poll(CursorMoveListener listener, int secondsSincePreviousPoll) {
+        now += secondsSincePreviousPoll * 1000L;
+        listener.run();
+    }
+
+    @Test
+    void userIsAwayAfterThirtyStillSeconds() {
+        Point[] still = new Point[AWAY_THRESHOLD_SECONDS + 3];
+        for (int i = 0; i < still.length; i++) {
+            still[i] = at(100, 100);
+        }
+        CursorMoveListener listener = scriptedListener(still);
+
+        // the first poll seeds the baseline and does not count
+        poll(listener, 1);
+
+        // 29 still seconds: the user is still considered present
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) {
+            poll(listener, 1);
+            assertFalse(listener.isUserAway());
+        }
+
+        // the 30th still second: the user is away
+        poll(listener, 1);
+        assertTrue(listener.isUserAway());
+    }
+
+    @Test
+    void firstPollDoesNotCountAsMovementOrIdleTime() {
+        // the very first position read must seed the baseline and the
+        // activity clock: starting anywhere else would have counted the
+        // first poll as a movement, or as a full idle period
+        CursorMoveListener listener = scriptedListener(at(500, 300), at(500, 300));
+
+        poll(listener, 5);
+        poll(listener, 10);
+
+        assertFalse(listener.isUserAway());
+        // still at (500, 300), and only 10 idle seconds: the seeding poll
+        // consumed the first 5 seconds
+    }
+
+    @Test
+    void userMovementResetsTheAwayTimer() {
+        Queue<Point> positions = new ArrayDeque<>();
+        positions.add(at(100, 100));                          // baseline
+        for (int i = 0; i < 3; i++) positions.add(at(100, 100)); // 3 still seconds
+        positions.add(at(140, 100));                          // the user moves the mouse
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) positions.add(at(140, 100)); // then it stays put
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
+
+        poll(listener, 1); // seed the baseline
+        for (int i = 0; i < 3; i++) {
+            poll(listener, 1);
+        }
+        assertFalse(listener.isUserAway());
+
+        poll(listener, 1); // the user moved: the away timer resets
+        assertFalse(listener.isUserAway());
+
+        // ...and it still takes 30 more still seconds to be away again
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) {
+            poll(listener, 1);
+            assertFalse(listener.isUserAway());
+        }
+
+        poll(listener, 1);
+        assertTrue(listener.isUserAway());
+    }
+
+    @Test
+    void appMovementsDoNotKeepTheUserPresent() {
+        // this is the regression the away detection was disconnected for: the
+        // app moves the mouse every few seconds, and before the fix those
+        // movements were indistinguishable from the user's, so the app would
+        // always think the user was present
+
+        // every poll finds the cursor where the app last left it
+        Queue<Point> appPositions = new ArrayDeque<>();
+        appPositions.add(at(100, 100));
+        for (int i = 1; i <= 40; i++) {
+            appPositions.add(at(100 + i, 100));
+        }
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                appPositions::remove, () -> now);
+
+        poll(listener, 1); // seed the baseline
+
+        for (int i = 1; i <= 40; i++) {
+            // the app just finished a movement, leaving the cursor exactly
+            // where this poll will find it
+            robotTracker.moveEnded(100 + i, 100);
+            poll(listener, 1);
+        }
+
+        // every position change was the app's own doing: the user is away
+        assertTrue(listener.isUserAway());
+    }
+
+    @Test
+    void ongoingAppMovementsDoNotKeepTheUserPresent() {
+        // same as above, but the polls happen while the app is mid-movement,
+        // with the cursor transiently at intermediate positions
+        Queue<Point> positions = new ArrayDeque<>();
+        positions.add(at(100, 100));
+        for (int i = 1; i <= 40; i++) {
+            positions.add(at(100 + (i / 2), 100));
+        }
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
+
+        robotTracker.moveStarted();
+        for (int i = 0; i <= 40; i++) {
+            poll(listener, 1);
+        }
+
+        assertTrue(listener.isUserAway());
+    }
+
+    @Test
+    void keyboardActivityResetsTheAwayTimer() {
+        Queue<Point> positions = new ArrayDeque<>();
+        positions.add(at(100, 100)); // baseline
+        for (int i = 0; i < 60; i++) {
+            positions.add(at(100, 100)); // the mouse never moves
+        }
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
+
+        poll(listener, 1); // seed the baseline
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) {
+            poll(listener, 1);
+        }
+        assertFalse(listener.isUserAway());
+
+        // the user is typing without moving the mouse: the timer resets
+        listener.reportKeyboardActivity();
+        poll(listener, 1);
+        assertFalse(listener.isUserAway());
+
+        // ...and it still takes 30 still seconds to be away again
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS - 1; i++) {
+            poll(listener, 1);
+            assertFalse(listener.isUserAway());
+        }
+
+        poll(listener, 1);
+        assertTrue(listener.isUserAway());
+    }
+
+    @Test
+    void keyboardActivityBringsTheUserBackWhileAway() {
+        Queue<Point> positions = new ArrayDeque<>();
+        positions.add(at(100, 100));
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS + 3; i++) {
+            positions.add(at(100, 100));
+        }
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
+
+        poll(listener, 1); // seed the baseline
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) {
+            poll(listener, 1);
+        }
+        assertTrue(listener.isUserAway());
+
+        // the user comes back at the keyboard: the away state must end,
+        // even though the mouse never moved
+        listener.reportKeyboardActivity();
+        poll(listener, 1);
+        assertFalse(listener.isUserAway());
+    }
+
+    @Test
+    void userComingBackIsDetectedWhileTheAppIsWiggling() {
+        // the app keeps wiggling while the user is away; when the user comes
+        // back and moves the mouse, the away state must end
+        Queue<Point> positions = new ArrayDeque<>();
+        positions.add(at(100, 100));
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) {
+            positions.add(at(100, 100));
+        }
+        positions.add(at(150, 100)); // app wiggle
+        positions.add(at(200, 100)); // app wiggle
+        positions.add(at(333, 100)); // the user's move
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, new AutoSquealConfig(),
+                positions::remove, () -> now);
+
+        poll(listener, 1); // seed the baseline
+        for (int i = 0; i < AWAY_THRESHOLD_SECONDS; i++) {
+            poll(listener, 1);
+        }
+        assertTrue(listener.isUserAway());
+
+        // the app wiggles: each movement is discounted, the user stays "away"
+        robotTracker.moveEnded(150, 100);
+        poll(listener, 1);
+        assertTrue(listener.isUserAway());
+
+        robotTracker.moveEnded(200, 100);
+        poll(listener, 1);
+        assertTrue(listener.isUserAway());
+
+        // the user comes back and grabs the mouse
+        poll(listener, 1);
+        assertFalse(listener.isUserAway());
+    }
+
+    @Test
+    void thresholdChangesApplyFromTheNextPoll() {
+        // the threshold is read live: a change applies without a restart
+        AutoSquealConfig config = new AutoSquealConfig();
+        config.setAwayThresholdSeconds(10);
+        Queue<Point> positions = new ArrayDeque<>();
+        for (int i = 0; i < 20; i++) {
+            positions.add(at(100, 100));
+        }
+        CursorMoveListener listener = new CursorMoveListener(robotTracker, config,
+                positions::remove, () -> now);
+
+        poll(listener, 1); // seed the baseline
+
+        // 9 still seconds: not away with a 10 seconds threshold
+        for (int i = 0; i < 9; i++) {
+            poll(listener, 1);
+            assertFalse(listener.isUserAway());
+        }
+
+        // 10th second: away
+        poll(listener, 1);
+        assertTrue(listener.isUserAway());
+
+        // the user tightens the threshold to 5: the next poll re-evaluates
+        // and the user is still away (already idle for more than 5 seconds)
+        config.setAwayThresholdSeconds(5);
+        poll(listener, 1);
+        assertTrue(listener.isUserAway());
+
+        // the user loosens the threshold to 600: the same idle time is no
+        // longer enough, so the user is present again — and back to away
+        // only after 600 seconds of stillness
+        config.setAwayThresholdSeconds(600);
+        poll(listener, 1);
+        assertFalse(listener.isUserAway());
+    }
+}

src/test/java/wtf/beatrice/autosqueal/listener/KeyPressListenerTest.java

@@ -0,0 +1,86 @@
+package wtf.beatrice.autosqueal.listener;
+
+import com.github.kwhat.jnativehook.keyboard.NativeKeyEvent;
+import org.junit.jupiter.api.Test;
+import wtf.beatrice.autosqueal.config.AutoSquealConfig;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class KeyPressListenerTest
+{
+    private final List<String> events = new ArrayList<>();
+    private final AutoSquealConfig config = new AutoSquealConfig();
+    private final KeyPressListener listener = new KeyPressListener(
+            () -> events.add("toggle"), () -> events.add("activity"), config);
+
+    private static NativeKeyEvent press(int keyCode) {
+        return new NativeKeyEvent(NativeKeyEvent.NATIVE_KEY_PRESSED, 0, 0, keyCode, ' ');
+    }
+
+    private static NativeKeyEvent release(int keyCode) {
+        return new NativeKeyEvent(NativeKeyEvent.NATIVE_KEY_RELEASED, 0, 0, keyCode, ' ');
+    }
+
+    @Test
+    void theComboTogglesOnceOnItsSecondKey() {
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+
+        // ctrl alone is not the combo: it only reports presence
+        assertEquals(List.of("activity"), events);
+
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        // the second key completes the combo: presence first, then the toggle
+        assertEquals(List.of("activity", "activity", "toggle"), events);
+    }
+
+    @Test
+    void theComboWorksInTheOtherOrderToo() {
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+
+        assertEquals(List.of("activity", "activity", "toggle"), events);
+    }
+
+    @Test
+    void repeatedPressesAreIgnored() {
+        // the OS repeats press events while a key is held down: they must
+        // not toggle repeatedly
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        events.clear();
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        assertEquals(List.of(), events);
+    }
+
+    @Test
+    void theComboCanFireAgainAfterBothKeysAreReleased() {
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+        listener.nativeKeyReleased(release(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyReleased(release(NativeKeyEvent.VC_ALT));
+
+        events.clear();
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        assertEquals(List.of("activity", "activity", "toggle"), events);
+    }
+
+    @Test
+    void theHotkeyCanBeDisabledWithoutLosingPresenceReporting() {
+        config.setHotkeyEnabled(false);
+
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_CONTROL));
+        listener.nativeKeyPressed(press(NativeKeyEvent.VC_ALT));
+
+        // typing still counts as presence, but the combo does nothing
+        assertEquals(List.of("activity", "activity"), events);
+    }
+}

src/test/java/wtf/beatrice/autosqueal/util/SystemUtilTest.java

@@ -0,0 +1,34 @@
+package wtf.beatrice.autosqueal.util;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+
+class SystemUtilTest
+{
+    @Test
+    void detectsWindows() {
+        assertEquals(SystemUtil.OperatingSystem.WINDOWS, SystemUtil.fromOsName("Windows 11"));
+    }
+
+    @Test
+    void detectsLinux() {
+        assertEquals(SystemUtil.OperatingSystem.LINUX, SystemUtil.fromOsName("Linux"));
+        assertEquals(SystemUtil.OperatingSystem.LINUX, SystemUtil.fromOsName("GNU/Linux"));
+    }
+
+    @Test
+    void detectsMacOS() {
+        assertEquals(SystemUtil.OperatingSystem.MAC_OS, SystemUtil.fromOsName("Mac OS X"));
+    }
+
+    @Test
+    void unknownForOtherSystems() {
+        assertEquals(SystemUtil.OperatingSystem.UNKNOWN, SystemUtil.fromOsName("SunOS"));
+    }
+
+    @Test
+    void hostSystemMatchesOsName() {
+        assertEquals(SystemUtil.fromOsName(System.getProperty("os.name")), SystemUtil.getHostSystem());
+    }
+}