Use the following code :

#!/bin/bash
# type "finish" to exit

stty -echoctl # hide ^C

# function called by trap
other_commands() {
    tput setaf 1
    printf "\rSIGINT caught      "
    tput sgr0
    sleep 1
    printf "\rType a command >>> "
}

trap 'other_commands' SIGINT

input="$@"

while true; do
    printf "\rType a command >>> "
    read input
    [[ $input == finish ]] && break
    bash -c "$input"
done

Here is how you can trap the CTRL+C in the script. You don't call the ctrl_c function as that will be called when you press CTRL+C on the keyboard. I added in an exit 0 so that it exits the script after it traps the CTRL+C and stops looping through the for .. loop.

cat ctrl_test.bsh 
#!/bin/bash

#Setup trap command, assign what to call and what is the trigger (SIGINT)
trap ctrl_c INT

#Function of what trap command calls    
function ctrl_c() {
    printf "\n** Trapped CTRL-C after $i seconds.\n"
    exit 0
}

#Rest of script to print counting numbers to screen will not break with CTRL+C due to trap
for ((i=1;i>0;i++))
do
    printf "\r$i"
    sleep 1
done

Example:

terrance@terrance-ubuntu:~$ ./ctrl_test.bsh 
13^C
** Trapped CTRL-C after 13 seconds.
terrance@terrance-ubuntu:~$ 

In your script case you could do something like this:

#TimerInTerminal.sh

#Trap Ctrl+C and re-enable suspend and hibernation modes
trap ctrl_c INT
function ctrl_c() {
    sudo systemctl unmask sleep.target suspend.target hibernate.target hybrid-sleep.target
    exit 0
}

# To prevent your Linux system from suspending or going into hibernation, you need to disable the following systemd targets:
# sudo systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target

# To re-enable the suspend and hibernation modes, run the command:
# sudo systemctl unmask sleep.target suspend.target hibernate.target hybrid-sleep.target

soundfile="/usr/share/sounds/My_Sounds/Electronic_Chime.wav"
# Stop computer from sleeping while timer is running

# prevent your Linux system from suspending or going into hibernation
sudo systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target

# This allows supend ?
#trap "echo marlin | sudo -S systemctl mask sleep.target suspend.target hibernate.target hybrid-sleep.target" INT EXIT

if [ $# -eq 1 ]
then
    DURATION="$1"
else
    read -r -p "Timer for how many minutes?( for fractional, use decimal notation , 0.5==30s, 1.25==75s etc) : "  DURATION
    read -r -p "Enter text to display at the end of the timer : " n1
fi

DURATION=$(echo "$DURATION * 60 / 1" | bc) # lets us deal with fractional inputs

START=$(date +%s)   # only do this once (anchor's the time)

countdown () {
    NOW=$(date +%s)              # Get time now in seconds
    DIF=$((NOW - START))         # Compute diff in seconds
    ELAPSE=$((DURATION - DIF))   # Compute elapsed time in seconds
    MINS=$((ELAPSE / 60))        # Convert to minutes... (dumps remainder from division)
    SECS=$((ELAPSE - (MINS*60))) # ... and seconds
    #banner "$MINS:$SECS"
    echo "$MINS:$SECS"
    sleep "$1"
}

while true 
do
    clear
    
    countdown 0 # calc time remaining
    
    if [ $MINS -le 0 ]
    then
        # Blink screen

        while [ $SECS -gt 0 ]
        do
            
            clear # Flash on
            #setterm -term linux -back red -fore white 
            countdown 0.5

            clear # Flash off
            #setterm -term linux -default
            countdown 0.5

        done # End for loop
        
        setterm -term linux -default
        clear
        
        break   # time has expired lets get out of here
    
    else
        countdown 1 
    fi
done

echo $n1
amixer -D pulse sset Master 30% > /dev/null 2>&1
# Play a sound
cvlc --play-and-exit "$soundfile" > /dev/null 2>&1

# To re-enable the suspend and hibernation modes, run the command:
 echo marlin | sudo -S systemctl unmask sleep.target suspend.target hibernate.target hybrid-sleep.target

Add this somewhere near the top of your script:

trap cleanup SIGINT

cleanup () {
    sudo systemctl unmask sleep.target suspend.target hibernate.target hybrid-sleep.target
}

I'm not sure why you are sending marlin across the pipe to systemctl when you reenable but the trap command you have commented out would probably still work except you have it using mask instead of unmask fwiw. Although it's worth noting that by trapping for INT and EXIT when you press ctrl+c your command will be executed twice.

This other answer explains why you see trap worked only after done. If you run the subshell in the background and then wait for it, the result will be different:

#!/bin/bash

trap 'echo "trap worked"' INT

(
   trap '' INT
   sleep 5
   echo "done"
) &

wait

If you hit Ctrl+c when the subshell works, it will trigger the trap immediately. It will also make the script go past wait and thus finish. Run wait in a loop if you don't want the script to finish:

until wait; do :; done

This way you will be able to trigger the trap multiple times easily and the script will exit after the subshell exits.

I guess this is not exactly what you mean by "without interrupting the foreground task", since the task (here: sleep) is in the background instead and it has its consequences. When job control is disabled (and it is by default in a script), & redirects stdin to /dev/null or equivalent file. This way what you run in the background cannot steal input. If you want our background subshell to be able to read from the stdin of the whole script then you need to explicitly redirect stdin to stdin (<&0). It looks like a no-op, but with & it actually makes sense, it makes an asynchronous job behave more like a job in the foreground:

(…) <&0 &

Another thing: note wait without arguments waits for all currently active child processes. If your actual script runs more jobs in the background and you want wait not to wait for some of them, the easiest way may be to disown.

Example code:

#!/bin/bash

trap 'echo "trap worked"' INT

(
   trap '' INT
   sleep 10
   echo "(not waited for) done"
) &
disown "$!"

(
   trap '' INT
   cat
   echo "(waited for) done"
) <&0 &

until wait; do :; done

Notes:

• cat and sleep are both immune to Ctrl+c.
• You can strike Ctrl+c and trigger the trap multiple times.
• At the same time you can write lines to cat and it will work, i.e. it will print upon Enter (but if you Ctrl+c in the middle of a line then what you typed so far (i.e. what hasn't been delivered to cat yet) will be discarded and never delivered to cat because this is how the line discipline works).
• Exit cat with Ctrl+d before sleep 10 finishes and you will see the script does not wait for the disowned job.

Side note: while playing with SIGINT and bash, it's good to know bash implements a "wait and cooperative exit" approach at handling SIGINT/SIGQUIT delivery. See this link and this article.

The '' in trap '' <signame> is special. It will cause <signame> to be ignored, not bound to dummy handler.

The "ignore" disposition of a signal is inherited by child processes (e.g. by ssh), but signal handlers are not.

trap '' INT is not the same as trap true INT or trap ' ' INT.

help trap in bash would've told you as much:

If ARG is the null string each SIGNAL_SPEC is ignored by the shell and by the commands it invokes.

It's hard to tell what you really want to do, but if you just want your script to print a message when you press Ctrl-C, without the ssh command being terminated, this will do:

#!/bin/bash
trap 'echo "message"' INT
ssh user@server 'svn checkout ...' &
while :; do
        wait
        s=$?
        case $s in
        130)    ;;
        129|13?) kill -n "$((s - 128))" "$$";;
        *)      exit "$s";;
        esac
done
echo "done"

Change ssh ... & to (trap - QUIT; trap '' INT; exec ssh ...) & if you want to still be able to kill your script via Ctrl-\ (SIGQUIT).

You should use trap true 2 or trap : 2 instead of trap '' 2. That's what "help trap" in a bash shell says about it:

If ARG is the null string each SIGNAL_SPEC is ignored by the shell and by the commands it invokes.

Example:

$ cat /tmp/test
#! /bin/sh
trap : INT
cat
echo first cat killed
cat
echo second cat killed
echo done
$ /tmp/test
   <press control-C>
^Cfirst cat killed
   <press control-C>
^Csecond cat killed
done