[OPTIMIZATION] recorder v2

[MarcoRavich]

Since we've introduced some complexities (exFAT+ available space + audio device dynamic probing), semplifications/optimizations of the script code are needed.

1st attempt (deepseek):

#!/bin/sh
#
# (updated warranty formula)

MNT=/tmp/mnt
recorder=""

trap 'true' SIGHUP
trap 'cleanup' SIGTERM

cleanup() {
    [ -n "$recorder" ] && kill $recorder 2>/dev/null
    umount -l "$MNT" 2>/dev/null
    exit
}

sleep infinity &
dummy=$!

while true; do
    [ -n "$recorder" ] && wait $recorder || wait $dummy
    
    # Check for audio card
    card=$(arecord -l | grep '^card') || continue
    
    # Find single exFAT partition
    disk=$(lsblk -o NAME,FSTYPE -nr | awk '$2=="exfat"{print "/dev/"$1}' | head -1)
    [ -e "$disk" ] || continue
    
    # Cleanup if recorder died
    if [ -n "$recorder" ] && [ ! -e "/proc/$recorder" ]; then
        recorder=""
        umount -l "$MNT"
    fi
    
    # Skip if already recording
    [ -n "$recorder" ] && continue
    
    # Mount disk
    mkdir -p "$MNT"
    mount "$disk" "$MNT" || continue
    
    # Check disk space (minimum 100MB)
    avail_mb=$(df -m "$MNT" | awk 'NR==2 {print $4}')
    [ "$avail_mb" -gt 100 ] || {
        umount -l "$MNT"
        sleep 5
        continue
    }
    
    # Generate unique filename
    name=$(date +%s)
    logfile="${MNT}/${name}.log"
    [ -e "$logfile" ] && { sleep 1; continue; }
    
    # Audio device probing
    device_info=$(arecord -l | awk '/List of CAPTURE/,/^$/')
    card=$(echo "$device_info" | awk -F: '/card [0-9]/{split($1,a," "); print a[2]}')
    device=$(echo "$device_info" | awk -F: '/device [0-9]/{split($1,a," "); print a[2]}')
    [ -z "$card" ] || [ -z "$device" ] && continue
    
    inputhw="${card},${device}"
    arecord_output=$(arecord -D "hw:$inputhw" --dump-hw-params 2>&1)
    
    max_channels=$(echo "$arecord_output" | awk -F'[][]' '/CHANNELS:/{print $2}' | awk '{print $NF}')
    bitformat=$(echo "$arecord_output" | awk '/^FORMAT:/{print $NF}')
    buffer_time_max=$(echo "$arecord_output" | awk -F'[][]' '/BUFFER_TIME:/{print $2}' | awk '{print $NF}')
    buffer_size_max=$(echo "$arecord_output" | awk -F'[][]' '/BUFFER_SIZE:/{print $2}' | awk '{print $NF}')
    max_rate=$(echo "$arecord_output" | awk -F'[][]' '/RATE:/{print $2}' | awk '{print $NF}')
    [ "$max_rate" -gt 48000 ] && max_rate=48000
    
    # Start recording
    filename="${name}_${max_channels}-${max_rate}-${bitformat}"
    arecord -D "hw:$inputhw" \
        -c "$max_channels" \
        -t raw \
        -f "$bitformat" \
        -r "$max_rate" \
        --buffer-time="$buffer_time_max" \
        --buffer-size="$buffer_size_max" \
        > "${MNT}/${filename}.raw" 2> >(ts -s >&2) &
    
    recorder=$!
done

GH-Copilot further (style) refinements:

#!/bin/sh

MNT=/tmp/mnt
recorder=""

trap ':' SIGHUP
trap cleanup SIGTERM

cleanup() {
    [ -n "$recorder" ] && kill "$recorder" 2>/dev/null
    umount -l "$MNT" 2>/dev/null
    exit
}

sleep infinity &
dummy=$!

while :; do
    if [ -n "$recorder" ]; then
        wait "$recorder"
    else
        wait "$dummy"
    fi

    # Check for audio card and exFAT disk
    card=$(arecord -l | grep '^card') || continue
    disk=$(lsblk -o NAME,FSTYPE -nr | awk '$2=="exfat"{print "/dev/"$1; exit}')
    [ -n "$disk" ] && [ -e "$disk" ] || continue

    # Cleanup if recorder died
    [ -n "$recorder" ] && ! kill -0 "$recorder" 2>/dev/null && {
        recorder=""
        umount -l "$MNT"
    }

    [ -n "$recorder" ] && continue

    mkdir -p "$MNT"
    mount "$disk" "$MNT" || continue

    avail_mb=$(df -Pm "$MNT" | awk 'NR==2{print $4}')
    [ "${avail_mb:-0}" -gt 100 ] || {
        umount -l "$MNT"
        sleep 5
        continue
    }

    name=$(date +%s)
    logfile="$MNT/$name.log"
    [ -e "$logfile" ] && name="$name-$$" # fallback to PID if collision (rare)
    logfile="$MNT/$name.log"

    # Audio device probing
    device_info=$(arecord -l | awk '/List of CAPTURE/,/^$/')
    cardnum=$(echo "$device_info" | awk -F: '/card [0-9]/{split($1,a," "); print a[2]}' | head -1)
    devnum=$(echo "$device_info" | awk -F: '/device [0-9]/{split($1,a," "); print a[2]}' | head -1)
    [ -n "$cardnum" ] && [ -n "$devnum" ] || continue

    inputhw="$cardnum,$devnum"
    arecord_output=$(arecord -D "hw:$inputhw" --dump-hw-params 2>&1)

    max_channels=$(echo "$arecord_output" | awk -F'[][]' '/CHANNELS:/{print $2}' | awk '{print $NF}')
    bitformat=$(echo "$arecord_output" | awk '/^FORMAT:/{print $NF}')
    buffer_time_max=$(echo "$arecord_output" | awk -F'[][]' '/BUFFER_TIME:/{print $2}' | awk '{print $NF}')
    buffer_size_max=$(echo "$arecord_output" | awk -F'[][]' '/BUFFER_SIZE:/{print $2}' | awk '{print $NF}')
    max_rate=$(echo "$arecord_output" | awk -F'[][]' '/RATE:/{print $2}' | awk '{print $NF}')
    [ "${max_rate:-0}" -gt 48000 ] && max_rate=48000

    filename="${name}_${max_channels}-${max_rate}-${bitformat}"

    arecord -D "hw:$inputhw" \
        -c "$max_channels" \
        -t raw \
        -f "$bitformat" \
        -r "$max_rate" \
        --buffer-time="$buffer_time_max" \
        --buffer-size="$buffer_size_max" \
        > "$MNT/$filename.raw" 2> >(ts -s >&2) &

    recorder=$!
done

Real world tests needed.

[MarcoRavich]

Various models through Duck.ai:

o4-mini:

#!/bin/sh
#
# Watch for an exFAT stick + ALSA capture card. When both appear:
#   • mount the stick  
#   • probe hardware parameters  
#   • start arecord into a timestamped .raw file  
# When either disappears or disk runs low, stop recording + unmount.

MNT=/tmp/mnt
recorder_pid=
dummy_pid=

trap ':' SIGHUP
trap cleanup SIGTERM

cleanup() {
  # stop recorder and unmount
  [ -n "$recorder_pid" ] && kill "$recorder_pid" 2>/dev/null
  umount -l "$MNT" 2>/dev/null
  exit
}

# helper: find exactly one exFAT partition, or empty
find_exfat() {
  lsblk -nr -o NAME,FSTYPE |
    awk '$2=="exfat"{print "/dev/" $1; exit}'
}

# helper: test for any capture card
have_card() {
  arecord -l | grep -q '^card'
}

# helper: probe device parameters into globals
probe_audio() {
  local info out
  info=$(arecord -l |
         awk '/List of CAPTURE Hardware Devices/{flag=1; next}
              /^$/ && flag{exit}
              flag' )

  cardnum=$(printf "%s\n" "$info" |
            awk -F: '/^card [0-9]/{split($1,a," "); print a[2]; exit}')
  devnum=$(printf "%s\n" "$info" |
           awk -F: '/^  device [0-9]/{split($1,a," "); print a[2]; exit}')
  [ -n "$cardnum" ] && [ -n "$devnum" ] || return 1

  out=$(arecord -D hw:$cardnum,$devnum --dump-hw-params 2>&1)

  max_channels=$(printf "%s\n" "$out" |
                 awk -F'[][]' '/CHANNELS:/{print $2}' | awk '{print $NF}')
  bitformat=$(printf "%s\n" "$out" | awk '/^FORMAT:/{print $NF}')
  buffer_time_max=$(printf "%s\n" "$out" |
                    awk -F'[][]' '/BUFFER_TIME:/{print $2}' | awk '{print $NF}')
  buffer_size_max=$(printf "%s\n" "$out" |
                    awk -F'[][]' '/BUFFER_SIZE:/{print $2}' | awk '{print $NF}')
  max_rate=$(printf "%s\n" "$out" |
             awk -F'[][]' '/RATE:/{print $2}' | awk '{print $NF}')
  # safe default + cap
  [ "${max_rate:-0}" -gt 48000 ] && max_rate=48000

  inputhw="$cardnum,$devnum"
  return 0
}

# start a never-ending sleep so we always have something to wait on
sleep infinity &
dummy_pid=$!

while :; do
  # wait either for the recorder to exit or for our dummy to wake us
  if [ -n "$recorder_pid" ]; then
    wait "$recorder_pid"
  else
    wait "$dummy_pid"
  fi

  # if recorder died unexpectedly, clear it + unmount
  if [ -n "$recorder_pid" ] && ! kill -0 "$recorder_pid" 2>/dev/null; then
    recorder_pid=
    umount -l "$MNT" 2>/dev/null
  fi

  # check devices
  have_card || continue
  disk=$(find_exfat) || disk=
  [ -n "$disk" ] && [ -e "$disk" ] || continue

  # if already recording, skip
  [ -n "$recorder_pid" ] && continue

  # mount it
  mkdir -p "$MNT"
  mount "$disk" "$MNT" || continue

  # check free space in MB
  avail_mb=$(df -Pm "$MNT" | awk 'NR==2{print $4}')
  [ "${avail_mb:-0}" -gt 100 ] || {
    umount -l "$MNT"
    sleep 5
    continue
  }

  # pick a unique name
  ts=$(date +%s)
  logfile="$MNT/$ts.log"
  if [ -e "$logfile" ]; then
    ts="${ts}_$"
    logfile="$MNT/$ts.log"
  fi

  # probe audio; skip if failure
  probe_audio || {
    umount -l "$MNT"
    continue
  }

  # build filename and launch arecord
  filename="${ts}_${max_channels}-${max_rate}-${bitformat}.raw"
  arecord -D hw:$inputhw \
    --channels="$max_channels" \
    --rate="$max_rate" \
    -f "$bitformat" \
    --buffer-time="$buffer_time_max" \
    --buffer-size="$buffer_size_max" \
    -t raw \
    > "$MNT/$filename" 2> >(ts -s >&2) &

  recorder_pid=$!
done

Mistral Small 3

#!/bin/sh

MNT="/tmp/mnt"
recorder=""

trap ':' SIGHUP
trap cleanup SIGTERM

cleanup() {
    [ -n "$recorder" ] && kill "$recorder" 2>/dev/null
    umount -l "$MNT" 2>/dev/null
    exit
}

sleep infinity &
dummy=$!

while :; do
    if [ -n "$recorder" ]; then
        wait "$recorder"
    else
        wait "$dummy"
    fi

    # Check for audio card and exFAT disk
    card=$(arecord -l | grep '^card') || continue
    disk=$(lsblk -o NAME,FSTYPE -nr | awk '$2=="exfat"{print "/dev/"$1; exit}')
    [ -n "$disk" ] && [ -e "$disk" ] || continue

    # Cleanup if recorder died
    [ -n "$recorder" ] && ! kill -0 "$recorder" 2>/dev/null && {
        recorder=""
        umount -l "$MNT"
    }

    [ -n "$recorder" ] && continue

    mkdir -p "$MNT"
    mount "$disk" "$MNT" || continue

    avail_mb=$(df -Pm "$MNT" | awk 'NR==2{print $4}')
    [ "${avail_mb:-0}" -gt 100 ] || {
        umount -l "$MNT"
        sleep 5
        continue
    }

    name=$(date +%s)
    logfile="$MNT/$name.log"
    [ -e "$logfile" ] && name="$name-$" # fallback to PID if collision (rare)
    logfile="$MNT/$name.log"

    # Audio device probing
    device_info=$(arecord -l | awk '/List of CAPTURE/,/^$/')
    cardnum=$(echo "$device_info" | awk -F: '/card [0-9]/{split($1,a," "); print a[2]}' | head -1)
    devnum=$(echo "$device_info" | awk -F: '/device [0-9]/{split($1,a," "); print a[2]}' | head -1)
    [ -n "$cardnum" ] && [ -n "$devnum" ] || continue

    inputhw="$cardnum,$devnum"
    arecord_output=$(arecord -D "hw:$inputhw" --dump-hw-params 2>&1)

    max_channels=$(echo "$arecord_output" | awk -F'[][]' '/CHANNELS:/{print $2}' | awk '{print $NF}')
    bitformat=$(echo "$arecord_output" | awk '/^FORMAT:/{print $NF}')
    buffer_time_max=$(echo "$arecord_output" | awk -F'[][]' '/BUFFER_TIME:/{print $2}' | awk '{print $NF}')
    buffer_size_max=$(echo "$arecord_output" | awk -F'[][]' '/BUFFER_SIZE:/{print $2}' | awk '{print $NF}')
    max_rate=$(echo "$arecord_output" | awk -F'[][]' '/RATE:/{print $2}' | awk '{print $NF}')
    [ "${max_rate:-0}" -gt 48000 ] && max_rate=48000

    filename="${name}_${max_channels}-${max_rate}-${bitformat}"

    arecord -D "hw:$inputhw" \
        -c "$max_channels" \
        -t raw \
        -f "$bitformat" \
        -r "$max_rate" \
        --buffer-time="$buffer_time_max" \
        --buffer-size="$buffer_size_max" \
        > "$MNT/$filename.raw" 2> >(ts -s >&2) &

    recorder=$!
done

Claude 3 Haiku:

MNT=/tmp/mnt
recorder=""

trap ':' SIGHUP
trap cleanup SIGTERM

cleanup() {
    [ -n "$recorder" ] && kill "$recorder" 2>/dev/null
    umount -l "$MNT" 2>/dev/null
    exit
}

sleep infinity &
dummy=$!

while true; do
    if [ -n "$recorder" ]; then
        wait "$recorder"
    else
        wait "$dummy"
    fi

    # Check for audio card and exFAT disk
    card=$(arecord -l | grep '^card') || continue
    disk=$(block info | awk -F'"' '/exfat/{print $2; exit}')
    [ -n "$disk" ] && [ -e "$disk" ] || continue

    # Cleanup if recorder died
    if [ -n "$recorder" ] && ! kill -0 "$recorder" 2>/dev/null; then
        recorder=""
        umount -l "$MNT"
    fi

    [ -n "$recorder" ] && continue

    mkdir -p "$MNT"
    mount "$disk" "$MNT" || continue

    avail_mb=$(df -Pm "$MNT" | awk 'NR==2{print $4}')
    if [ "${avail_mb:-0}" -le 100 ]; then
        if [ -n "$recorder" ]; then
            kill -9 "$recorder"
            recorder=""
        fi
        umount -l "$MNT"
        sleep 5
        continue
    fi

    name=$(date +%s)
    logfile="$MNT/$name.log"
    if [ -e "$logfile" ]; then
        name="$name-$"
        logfile="$MNT/$name.log"
    fi

    # Audio device probing
    device_info=$(arecord -l | awk '/List of CAPTURE/,/^$/')
    cardnum=$(echo "$device_info" | awk -F: '/card [0-9]/{split($1,a," "); print a[2]}' | head -1)
    devnum=$(echo "$device_info" | awk -F: '/device [0-9]/{split($1,a," "); print a[2]}' | head -1)
    [ -n "$cardnum" ] && [ -n "$devnum" ] || continue

    inputhw="$cardnum,$devnum"
    arecord_output=$(arecord -D "hw:$inputhw" --dump-hw-params 2>&1)

    max_channels=$(echo "$arecord_output" | awk -F'[][]' '/CHANNELS:/{print $2}' | awk '{print $NF}')
    bitformat=$(echo "$arecord_output" | awk '/^FORMAT:/{print $NF}')
    buffer_time_max=$(echo "$arecord_output" | awk -F'[][]' '/BUFFER_TIME:/{print $2}' | awk '{print $NF}')
    buffer_size_max=$(echo "$arecord_output" | awk -F'[][]' '/BUFFER_SIZE:/{print $2}' | awk '{print $NF}')
    max_rate=$(echo "$arecord_output" | awk -F'[][]' '/RATE:/{print $2}' | awk '{print $NF}')
    [ "${max_rate:-0}" -gt 48000 ] && max_rate=48000

    filename="${name}_${max_channels}-${max_rate}-${bitformat}"

    arecord -D "hw:$inputhw" \
        -c "$max_channels" \
        -t raw \
        -f "$bitformat" \
        -r "$max_rate" \
        --buffer-time="$buffer_time_max" \
        --buffer-size="$buffer_size_max" \
        > "$MNT/$filename.raw" 2> >(ts -s >&2) &

    recorder=$!
done

[MarcoRavich]

All versions of the script seem to work fine, so I asked ChatGPT to analyze them: https://chatgpt.com/share/68654f65-9cb8-800f-951b-83e60daf725a

...and its optimized version:

#!/bin/sh

MNT=/tmp/mnt
recorder_pid=

trap ':' SIGHUP
trap cleanup SIGTERM

cleanup() {
  [ -n "$recorder_pid" ] && kill "$recorder_pid" 2>/dev/null
  umount -l "$MNT" 2>/dev/null
  exit
}

find_exfat() {
  for dev in /dev/sd*; do
    blkid "$dev" | grep -q 'TYPE="exfat"' && echo "$dev" && return
  done
}

have_card() {
  arecord -l 2>/dev/null | grep -q '^card'
}

probe_audio() {
  info=$(arecord -l 2>/dev/null |
         awk '/List of CAPTURE Hardware Devices/{flag=1; next}
              /^$/{exit} flag')

  cardnum=$(echo "$info" | awk -F: '/^card /{split($1,a," "); print a[2]; exit}')
  devnum=$(echo "$info" | awk -F: '/^  device /{split($1,a," "); print a[2]; exit}')
  [ -n "$cardnum" ] && [ -n "$devnum" ] || return 1

  out=$(arecord -D hw:$cardnum,$devnum --dump-hw-params 2>/dev/null)

  max_channels=$(echo "$out" | awk -F'[][]' '/CHANNELS:/{print $2}' | awk '{print $NF}')
  bitformat=$(echo "$out" | awk '/^FORMAT:/{print $NF}')
  buffer_time_max=$(echo "$out" | awk -F'[][]' '/BUFFER_TIME:/{print $2}' | awk '{print $NF}')
  buffer_size_max=$(echo "$out" | awk -F'[][]' '/BUFFER_SIZE:/{print $2}' | awk '{print $NF}')
  max_rate=$(echo "$out" | awk -F'[][]' '/RATE:/{print $2}' | awk '{print $NF}')
  [ "$max_rate" -gt 48000 ] && max_rate=48000

  inputhw="$cardnum,$devnum"
  return 0
}

while :; do
  [ -n "$recorder_pid" ] && kill -0 "$recorder_pid" 2>/dev/null && sleep 5 && continue

  have_card || { sleep 5; continue; }

  disk=$(find_exfat)
  [ -b "$disk" ] || { sleep 5; continue; }

  mkdir -p "$MNT" && mount "$disk" "$MNT" || { sleep 5; continue; }

  avail_kb=$(df "$MNT" | awk 'NR==2{print $4}')
  [ "$avail_kb" -gt 102400 ] || { umount -l "$MNT"; sleep 10; continue; }

  ts=$(date +%s)
  logfile="$MNT/$ts.log"
  [ -e "$logfile" ] && ts="${ts}_$$"

  probe_audio || { umount -l "$MNT"; sleep 5; continue; }

  filename="${ts}_${max_channels}-${max_rate}-${bitformat}.raw"

  arecord -D hw:$inputhw \
    -c "$max_channels" \
    -r "$max_rate" \
    -f "$bitformat" \
    --buffer-time="$buffer_time_max" \
    --buffer-size="$buffer_size_max" \
    -t raw \
    > "$MNT/$filename" 2>> "$logfile" &

  recorder_pid=$!
done

[MarcoRavich]

GPT-5 (thinking):

#!/bin/sh

MNT=/tmp/mnt
recorder_pid=

trap ':' SIGHUP
trap cleanup SIGTERM

cleanup() {
  [ -n "$recorder_pid" ] && kill "$recorder_pid" 2>/dev/null
  umount -l "$MNT" 2>/dev/null
  exit
}

# find_exfat: detect exFAT by reading the first sector of /dev/sd* devices
# and searching for the exFAT signature (no external blkid required).
find_exfat() {
  for dev in /dev/sd*; do
    [ -b "$dev" ] || continue
    # read first 512 bytes and search for "EXFAT" ASCII signature
    # dd is used with minimal options; suppress stderr to avoid clutter.
    if dd if="$dev" bs=512 count=1 2>/dev/null | grep -a -q 'EXFAT'; then
      echo "$dev"
      return 0
    fi
  done
  return 1
}

have_card() {
  arecord -l 2>/dev/null | grep -q '^card'
}

probe_audio() {
  info=$(arecord -l 2>/dev/null |
         awk '/List of CAPTURE Hardware Devices/{flag=1; next}
              /^$/{exit} flag')

  cardnum=$(echo "$info" | awk -F: '/^card /{split($1,a," "); print a[2]; exit}')
  devnum=$(echo "$info" | awk -F: '/^  device /{split($1,a," "); print a[2]; exit}')
  [ -n "$cardnum" ] && [ -n "$devnum" ] || return 1

  out=$(arecord -D hw:$cardnum,$devnum --dump-hw-params 2>/dev/null)

  max_channels=$(echo "$out" | awk -F'[][]' '/CHANNELS:/{print $2}' | awk '{print $NF}')
  bitformat=$(echo "$out" | awk '/^FORMAT:/{print $NF}')
  buffer_time_max=$(echo "$out" | awk -F'[][]' '/BUFFER_TIME:/{print $2}' | awk '{print $NF}')
  buffer_size_max=$(echo "$out" | awk -F'[][]' '/BUFFER_SIZE:/{print $2}' | awk '{print $NF}')
  max_rate=$(echo "$out" | awk -F'[][]' '/RATE:/{print $2}' | awk '{print $NF}')
  [ "$max_rate" -gt 48000 ] && max_rate=48000

  inputhw="$cardnum,$devnum"
  return 0
}

while :; do
  [ -n "$recorder_pid" ] && kill -0 "$recorder_pid" 2>/dev/null && sleep 5 && continue

  have_card || { sleep 5; continue; }

  disk=$(find_exfat)
  [ -b "$disk" ] || { sleep 5; continue; }

  mkdir -p "$MNT" && mount "$disk" "$MNT" || { sleep 5; continue; }

  avail_kb=$(df "$MNT" | awk 'NR==2{print $4}')
  [ "$avail_kb" -gt 102400 ] || { umount -l "$MNT"; sleep 10; continue; }

  ts=$(date +%s)
  logfile="$MNT/$ts.log"
  [ -e "$logfile" ] && ts="${ts}_$$"

  probe_audio || { umount -l "$MNT"; sleep 5; continue; }

  filename="${ts}_${max_channels}-${max_rate}-${bitformat}.raw"

  arecord -D hw:$inputhw \
    -c "$max_channels" \
    -r "$max_rate" \
    -f "$bitformat" \
    --buffer-time="$buffer_time_max" \
    --buffer-size="$buffer_size_max" \
    -t raw \
    > "$MNT/$filename" 2>> "$logfile" &

  recorder_pid=$!
done

[MarcoRavich]

Claude Sonnet 4:

#!/bin/sh
#
# Original script by J. Bruce Fields, 2024
# This version by FORART (https://forart.it/), 2025
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or (at
# your option) any later version.

# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#

MNT=/tmp/mnt
recorder=""

trap 'true' SIGHUP

sleep infinity &
dummy=$!

trap '	kill $dummy;
	[ -n "$recorder" ] && kill $recorder;
	umount -l "$MNT";
	exit'	SIGTERM

first=0

while true; do
	if [ $first -eq 0 ]; then first=1; else
		if [ -n "$recorder" ]; then waiton=$recorder;
					else waiton=$dummy; fi
		wait $waiton
	fi
	card=$( arecord -l|grep '^card' )

	# Detect the only exFAT partition available in the system
	# Replace lsblk with /proc/partitions and direct filesystem detection
	disk=""
	exfat_parts=""
	while read major minor blocks name; do
		case "$name" in
			sd*|mmcblk*|nvme*)
				dev="/dev/$name"
				[ -b "$dev" ] || continue
				# Check for exFAT signature at offset 3 (5 bytes: "EXFAT")
				if dd if="$dev" bs=1 skip=3 count=5 2>/dev/null | grep -q "EXFAT"; then
					exfat_parts="$exfat_parts $dev"
				fi
				;;
		esac
	done < /proc/partitions
	
	# Count words without wc
	count=0
	for part in $exfat_parts; do
		count=$((count + 1))
	done
	
	if [ "$count" -eq 1 ]; then
		disk="$exfat_parts"
		# Remove leading space
		disk=${disk# }
	fi

	[ -e $disk ] && [ -n "$card" ]
	ready=$?
	# PIDs can be reused, but this test is probably reliable enough
	# for our purposes:
	if [ -n "$recorder" -a ! -e /proc/$recorder ]; then
		recorder="";
		umount -l "$MNT"
	fi
	if [ $ready -ne 0 ]; then
		if [ -n "$recorder" ]; then
			# recording's still running but something's
			# been disconnected; try to clean up:
			# openwrt actually seems to unmount automatically,
			# but, just to be sure:
			umount -l "$MNT"
			kill -9 $recorder
			recorder=""
		fi
		continue
	fi
	if [ -n "$recorder" ]; then continue; fi
	# openwrt seems to delete mountpoints on unmount automatically,
	# so we need to recreate it here:
	mkdir -p "$MNT"
	mount $disk "$MNT" || continue

	# Check available disk space (after mounting, before recording)
	# Use shell arithmetic instead of awk for better performance
	set -- $(df -k "$MNT" | tail -n 1)
	avail_kb=$4
	avail_mb=$((avail_kb / 1024))
	if [ "$avail_mb" -le 100 ]; then
		if [ -n "$recorder" ]; then
			kill -9 $recorder
			recorder=""
		fi
		umount -l "$MNT"
		sleep 5
		continue
	fi

	while true; do
		name=$(date +%s)
    	logfile="/${MNT}/${name}.log"
		if [ ! -e "$logfile" ]; then break; fi
		sleep 1
	done
	{
	# Audio device probing
	device_info=$(arecord -l | grep -A 2 "List of CAPTURE Hardware Devices" | grep -A 1 "card [0-9]:" | head -n 3)
	card=$(echo "$device_info" | grep "card [0-9]:" | sed -E 's/.*card ([0-9]+):.*/\1/')
	device=$(echo "$device_info" | grep "device [0-9]:" | sed -E 's/.*device ([0-9]+):.*/\1/')
	inputhw=$(echo "$card,$device")
	arecord_output=$(arecord -D "hw:$card,$device" --dump-hw-params 2>&1)

	max_channels=$(echo "$arecord_output" | grep "CHANNELS:" | sed -n 's/.*CHANNELS: \[\?\([0-9]*\)\( \([0-9]*\)\)\?\]/\3/p')
	if [ -z "$max_channels" ]; then
	    max_channels=$(echo "$arecord_output" | grep "CHANNELS:" | sed -n 's/.*CHANNELS: \([0-9]*\)/\1/p')
	fi

	bitformat=$(echo "$arecord_output" | grep "^FORMAT:" | sed -n 's/.*FORMAT: \(.*\)/\1/p' | awk '{print $NF}')
	if [ -z "$bitformat" ]; then
	    bitformat=$(echo "$arecord_output" | grep "^FORMAT:" | sed -n 's/.*FORMAT: \([A-Z0-9_]*\)/\1/p')
	fi

	buffer_time_max=$(echo "$arecord_output" | sed -n '/BUFFER_TIME:/ s/.*[\[(]\([0-9]*\) \([0-9]*\)[])].*/\2/p')
	buffer_size_max=$(echo "$arecord_output" | sed -n '/BUFFER_SIZE:/ s/.*[\[(]\([0-9]*\) \([0-9]*\)[])].*/\2/p')

	max_rate=$(echo "$arecord_output" | sed -n '/RATE:/ s/.*[\[(]\([0-9]*\) \([0-9]*\)[])].*/\2/p')
	if [ -z "$max_rate" ]; then
	    max_rate=$(echo "$arecord_output" | grep "RATE:" | sed -n 's/.*RATE: \([0-9]*\)/\1/p')
	fi

	if [ "$max_rate" -gt 48000 ]; then
	    max_rate=48000
	fi

	filename="${name}_${max_channels}-${max_rate}-${bitformat}"

	# Use probed values in arecord
	arecord --device=hw:${inputhw} \
		--channels=${max_channels} \
		--file-type=raw \
		--format=${bitformat} \
		--rate=${max_rate} \
		--buffer-time=${buffer_time_max} \
		--buffer-size=${buffer_size_max} \
		> "${MNT}/${filename}.raw" 2> >(ts -s >&2) &

	recorder=$!
	}
done

[MarcoRavich]

Claude final:

#!/bin/sh
#
# Original script by J. Bruce Fields, 2024
# This version by FORART (https://forart.it/), 2025
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation, either version 3 of the License, or (at
# your option) any later version.

# This program is distributed in the hope that it will be useful, but
# WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
# General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program. If not, see <https://www.gnu.org/licenses/>.
#

MNT=/tmp/mnt
recorder=""

trap 'true' SIGHUP

sleep infinity &
dummy=$!

trap '	kill $dummy;
	[ -n "$recorder" ] && kill $recorder;
	umount -l "$MNT";
	exit'	SIGTERM

first=0

while true; do
	if [ $first -eq 0 ]; then first=1; else
		if [ -n "$recorder" ]; then waiton=$recorder;
					else waiton=$dummy; fi
		wait $waiton
	fi
	card=$( arecord -l|grep '^card' )

	# Detect the only exFAT partition available in the system
	# Replace lsblk with /proc/partitions and direct filesystem detection
	disk=""
	exfat_parts=""
	while read major minor blocks name; do
		case "$name" in
			sd*|mmcblk*|nvme*)
				dev="/dev/$name"
				[ -b "$dev" ] || continue
				# Check for exFAT signature at offset 3 (5 bytes: "EXFAT")
				if dd if="$dev" bs=1 skip=3 count=5 2>/dev/null | grep -q "EXFAT"; then
					exfat_parts="$exfat_parts $dev"
				fi
				;;
		esac
	done < /proc/partitions
	
	# Count words without wc
	count=0
	for part in $exfat_parts; do
		count=$((count + 1))
	done
	
	if [ "$count" -eq 1 ]; then
		disk="$exfat_parts"
		# Remove leading space
		disk=${disk# }
	fi

	[ -e $disk ] && [ -n "$card" ]
	ready=$?
	# PIDs can be reused, but this test is probably reliable enough
	# for our purposes:
	if [ -n "$recorder" -a ! -e /proc/$recorder ]; then
		recorder="";
		umount -l "$MNT"
	fi
	if [ $ready -ne 0 ]; then
		if [ -n "$recorder" ]; then
			# recording's still running but something's
			# been disconnected; try to clean up:
			# openwrt actually seems to unmount automatically,
			# but, just to be sure:
			umount -l "$MNT"
			kill -9 $recorder
			recorder=""
		fi
		continue
	fi
	if [ -n "$recorder" ]; then continue; fi
	# openwrt seems to delete mountpoints on unmount automatically,
	# so we need to recreate it here:
	mkdir -p "$MNT"
	mount $disk "$MNT" || continue

	# Check available disk space (after mounting, before recording)
	# Use shell arithmetic instead of awk for better performance
	set -- $(df -k "$MNT" | tail -n 1)
	avail_kb=$4
	avail_mb=$((avail_kb / 1024))
	if [ "$avail_mb" -le 100 ]; then
		if [ -n "$recorder" ]; then
			kill -9 $recorder
			recorder=""
		fi
		umount -l "$MNT"
		sleep 5
		continue
	fi

	name=$(date +%s)
	{
	# Audio device probing
	device_info=$(arecord -l | grep -A 2 "List of CAPTURE Hardware Devices" | grep -A 1 "card [0-9]:" | head -n 3)
	card=$(echo "$device_info" | grep "card [0-9]:" | sed -E 's/.*card ([0-9]+):.*/\1/')
	device=$(echo "$device_info" | grep "device [0-9]:" | sed -E 's/.*device ([0-9]+):.*/\1/')
	inputhw=$(echo "$card,$device")
	arecord_output=$(arecord -D "hw:$card,$device" --dump-hw-params 2>&1)

	max_channels=$(echo "$arecord_output" | grep "CHANNELS:" | sed -n 's/.*CHANNELS: \[\?\([0-9]*\)\( \([0-9]*\)\)\?\]/\3/p')
	if [ -z "$max_channels" ]; then
	    max_channels=$(echo "$arecord_output" | grep "CHANNELS:" | sed -n 's/.*CHANNELS: \([0-9]*\)/\1/p')
	fi

	bitformat=$(echo "$arecord_output" | grep "^FORMAT:" | sed -n 's/.*FORMAT: \(.*\)/\1/p' | awk '{print $NF}')
	if [ -z "$bitformat" ]; then
	    bitformat=$(echo "$arecord_output" | grep "^FORMAT:" | sed -n 's/.*FORMAT: \([A-Z0-9_]*\)/\1/p')
	fi

	buffer_time_max=$(echo "$arecord_output" | sed -n '/BUFFER_TIME:/ s/.*[\[(]\([0-9]*\) \([0-9]*\)[])].*/\2/p')
	buffer_size_max=$(echo "$arecord_output" | sed -n '/BUFFER_SIZE:/ s/.*[\[(]\([0-9]*\) \([0-9]*\)[])].*/\2/p')

	max_rate=$(echo "$arecord_output" | sed -n '/RATE:/ s/.*[\[(]\([0-9]*\) \([0-9]*\)[])].*/\2/p')
	if [ -z "$max_rate" ]; then
	    max_rate=$(echo "$arecord_output" | grep "RATE:" | sed -n 's/.*RATE: \([0-9]*\)/\1/p')
	fi

	if [ "$max_rate" -gt 48000 ]; then
	    max_rate=48000
	fi

	filename="${name}_${max_channels}-${max_rate}-${bitformat}"

	# Use probed values in arecord
	arecord --device=hw:${inputhw} \
		--channels=${max_channels} \
		--file-type=raw \
		--format=${bitformat} \
		--rate=${max_rate} \
		--buffer-time=${buffer_time_max} \
		--buffer-size=${buffer_size_max} \
		> "${MNT}/${filename}.raw" 2>/dev/null &

	recorder=$!
	}
done