Scala command line app with background tasks - multithreading

Question

I'm working on a command line program in Scala. Some of the commands will spawn background thread to perform some work. Some commands will spawn threads that will run the same task repetitively with some delay. I also need a stop command that will prevent existing background task from repeating (doesn't need to kill it, just quit after finishing the iteration). What are the best primitives to construct this sort of program?
I'm thinking about using Futures, e.g. below. What do you guys think of this design? How would you implement this sort of functionality?
case class OneTimeTaskCommand(arg: String)
case class StopTaskCommand(name: String)
case class RepeatingTaskCommand(name: String, delay: Long, arg: String)
def runOneTimeTask(arg: String): Unit = { ... }
def runRepeatingTaskCommand(arg: String): Unit = { ... }
trait Scheduler {
def schedule(name: String, delay: Long): Unit
def unschedule(name: String): Unit
def isScheduled(name: String): Boolean = repeatDelay(name).isDefined
def repeatDelay(name: String): Option[Long]
}
def runCommand(command)(implicit scheduler: Scheduler): Future[Unit] = {
command match {
case OneTimeTaskCommand(arg) => Future(runOneTimeTask(arg))
case StopTaskCommand(name) =>
if (scheduler.isScheduled(name)) {
scheduler.unschedule(name)
Future.successful(())
} else {
Future.failure(new CommandException(s"task $name is not running"))
}
case RepeatingTaskCommand(name, delay, arg) =>
/* function to generate repeating future */
def createFuture(): Future[Unit] = {
runRepeatingTaskCommand(arg)).flatMap { _ =>
scheduler.repeatDelay(name) match {
case Some(d) =>
Thread.sleep(d)
Future(createFuture())
case None =>
Future.successful(())
}
}
}
/* spin off repeating task */
if (scheduler.isScheduled(name)) {
Future.failure(new CommandException(s"task $name is already running"))
} else {
scheduler.schedule(name, delay)
createFuture()
}
}
}
The code above will be integrated into some REPL that reads users input and invokes some of the following calls:
implicit val scheduler: Scheduler = new SchedulerImpl
runCommand(OneTimeTaskCommand(someArg))
// Run backgrounded task to be repeated every second
runCommand(RepeatingTaskCommand("backgrounded-task", 1000L, someArg))
// Stop backgrounded task
runCommand(StopTaskCommand("backgrounded-task"))