CMSC216 Project 4: Going Commando

// states in which a cmd might be
typedef enum  {
  CMDSTATE_NOTSET = 0,                // hasn't been set
  CMDSTATE_INIT,                      // cmd struct just initialized but no child process
  CMDSTATE_RUNNING,                   // child process fork()/exec()'d and running
  CMDSTATE_EXIT,                      // child process exited normally
  CMDSTATE_SIGNALLED,                 // child process exited abnormally due to a signal
  CMDSTATE_UNKNOWN_END,               // cmd finished but for unknown reasons
  CMDSTATE_FAIL_INPUT=97,             // couldn't find input file for redirection
  CMDSTATE_FAIL_OUTPUT=98,            // couldn't find input file for redirection
  CMDSTATE_FAIL_EXEC=99,              // exec() failed after fork()
} cmdstate_t;

// struct that represents a command and its output 
typedef struct cmd {
  char cmdline[MAX_LINE];             // original command line entered by users, copied from input
  char *argv[MAX_ARGS];               // argv[] for running child, NULL terminated, malloc()'d and must be free()'d
  int argc;                           // length of the argv[] array, used for sanity checks
  cmdstate_t cmdstate;                // indicates phase of cmd in life cycle (running, exited, etc.)
  pid_t pid;                          // PID of running child proces for the cmd; -1 otherwise
  int exit_code;                      // value returned on exit from child process or negative signal number
  char input_filename[MAX_NAME];      // name of file containing input
  char output_filename[MAX_NAME];     // name of file containing output
  ssize_t output_bytes;               // number of bytes of output
} cmd_t;

// control structure to track cmd history, output location, etc.
typedef struct {                
  char cmddir[MAX_NAME];              // name of the directory where cmd output files will be placed
  int cmds_count;                     // number of elements in the cmds array
  int cmds_capacity;                  // capacity of the cmds array
  cmd_t *cmds;                        // array of all cmds that have run / are running
} cmdctl_t;

// UPDATED: Mon Apr 28 04:33:13 PM EDT 2025

#include "commando.h"

////////////////////////////////////////////////////////////////////////////////
// PROVIDED DATA / FUNCTIONS
//
// The data and functions below should not be altered as they should
// be used as-is in the project.
///////////////////////////////////////////////////////////////////////////////

// Prints out a message if the environment variable DEBUG is set;
// Running as `DEBUG=1 ./some_program` or `DEBUG=1 make test-prob1`
// will cause all Dprintf() messages to show while running without the
// DEBUG variable will not print those messages. An example:
// 
// >> DEBUG=1 ./commando              // enable debug messages
// === COMMANDO ver 2 ===
// Re-using existing output directory 'commando-dir'
// Type 'help' for supported commands
// [COMMANDO]>> ls
// |DEBUG| sscanf ret is 1 for line `ls`
// |DEBUG| pid 237205 still running
// [COMMANDO]>> exit
// |DEBUG| sscanf ret is 1 for line `exit`
// |DEBUG| end main loop
// |DEBUG| freeing memory
// 
// >> ./commando                      // no debug messages
// === COMMANDO ver 2 ===
// Re-using existing output directory 'commando-dir'
// Type 'help' for supported commands
// [COMMANDO]>> ls
// [COMMANDO]>> exit
void Dprintf(const char* format, ...) {
  if(getenv("DEBUG") != NULL){
    va_list args;
    va_start (args, format);
    char fmt_buf[2048];
    snprintf(fmt_buf, 2048, "|DEBUG| %s", format);
    vfprintf(stderr, fmt_buf, args);
    va_end(args);
  }
}

// Sleep the running program for the given number of seconds allowing
// fractional values.
void pause_for(double secs){
  int isecs = (int) secs;
  double frac = secs - ((double) isecs);
  long inanos = (long) (frac * 1.0e9);

  struct timespec tm = {
    .tv_nsec = inanos,
    .tv_sec  = isecs,
  };
  nanosleep(&tm,NULL);
}

// Splits `line` into tokens with pointers to each token stored in
// argv[] and argc_ptr set to the number of tokens found. This
// function is in the style of strtok() and destructively modifies
// `line`. A limited amount of "quoting" is supported to allow single-
// or double-quoted strings to be present. The function is useful for
// splitting lines into an argv[] / argc pair in preparation for an
// exec() call.  0 is returned on success while an error message is
// printed and 1 is returned if splitting fails due to problems with
// the string.
//
// EXAMPLES:
// char line[128] = "Hello world 'I feel good' today";
// char *set_argv[32];
// int set_argc;
// int ret = split_into_argv(line, set_argv, &set_argc);
// // set_argc: 4
// // set_argv[0]: Hello
// // set_argv[1]: world
// // set_argv[2]: I feel good
// // set_argv[3]: today
// // set_argv[4]: <NULL>
int split_into_argv(char *line, char *argv[], int *argc_ptr){
  int argc = 0;
  int in_token = 0;
  for(int i=0; line[i]!='\0'; i++){
    if(!in_token && isspace(line[i])){                 // skip spaces between tokens
      continue;
    }
    else if(in_token && (line[i]=='\'' || line[i]=='\"')){
      printf("ERROR: No support for mid-token quote at index %d\n",i);
      return 1;
    }
    else if(line[i]=='\'' || line[i]=='\"'){           // begin quoted token
      char start_quote_char = line[i];
      i++;                                             // skip first quote char
      argv[argc++] = line+i;                           // start of token
      for(;line[i] != start_quote_char;i++){
        if(line[i] == '\0'){
          printf("ERROR: unterminated quote in <%s>\n",line);
          return 1;
        }
      }
      line[i] = '\0';                                  // end quoted token
    }
    else if(in_token && !isspace(line[i])){            // still in a token, move ahead
      continue;
    }
    else if(!in_token && !isspace(line[i])){           // begin unquoted token 
      in_token = 1;
      argv[argc++] = line+i;
    }
    else if(in_token && isspace(line[i])){             // end unquoted token
      in_token = 0;
      line[i] = '\0';
    }
    else{
      printf("ERROR: internal parsing problem at string index %d\n",i);
      return 1;
    }
  }
  *argc_ptr = argc;
  argv[argc] = NULL;                                   // ensure NULL termination required by exec()
  return 0;
}

////////////////////////////////////////////////////////////////////////////////
// PROBLEM 1 Functions
////////////////////////////////////////////////////////////////////////////////

cmdctl_t *cmdctl_new(char *cmddir, int cmds_capacity);
// PROBLEM 1: Allocate a new cmdctl structure with the output
// directory `cmddir` and intitial `cmds_capacity` for its cmds[]
// array field.

void cmdctl_free(cmdctl_t *cmdctl);
// PROBLEM 1: De-allocate the given given cmdctl struct. Free all
// argv[] elements in each of the cmds[], free that array, then free
// the cmdctl struct itself.

int cmdctl_create_cmddir(cmdctl_t *cmdctl);
// PROBLEM 1: Creates the output directory names in cmdctl->cmddir. If
// cmddir does not exist, it is created as directory with permissions
// of User=read/write/execute then returns 1. If cmddir already exists
// and is a directory, prints the following message and returns 0:
//
//   Re-using existing output directory 'XXX'
//
// If a non-directory file named cmddir already exists, print an error
// message and return -1 to indicate the program cannot proceed. The
// error message is:
//
// ERROR: Could not create cmddir directory 'XXX'
//        Non-directory file with that name already exists
//
// with XXX substituted with the value of cmddir. 
//
// CONSTRAINT: This function must be implemented using low-level
// system calls. Use of high-level calls like system("cmd") will be
// reduced to 0 credit. Review system calls like stat() and mkdir()
// for use here. The access() system call may be used but keep in mind
// it does not distinguish between regular files and directories.

int cmdctl_add_cmd(cmdctl_t *cmdctl, char *cmdline);
// PROBLEM 1: Add a command to the cmdctl. If the capacity of the
// cmds[] array is insufficient, is size is doubled before adding
// using the realloc() function. 
//
//
// SETTING ARGV[] OF THE CMD 
//
// `cmdline` is the string typed in as a command. `cmdline` is
// separated into an argv[] array using the split_into_argv()
// function. All strings are duplicated into the argv[] array of the
// cmd_t and are later free()'d on memory de-allocation.  
//
// Example:
// cmdline: "data/sleep_print.sh 1 hello world"
// argv[]:
//   [ 0]: data/sleep_print.sh
//   [ 1]: 1
//   [ 2]: hello
//   [ 3]: world
//   [ 4]: NULL
//
// NOTE: Paramameter `cmdline` is copied into the cmd.cmdline[]
// field. This copy is left unchanged. When splitting, another local
// copy of the string is made. strcpy() is useful for this and
// strdup() is used for creating heap-allocated copies for cmd.argv[]
// to point at.
//
// HANDLING INPUT REDIRECTION
//
// If the last two elements of the command line indicate input
// redirection via "< infile.txt" then the argv[] and input_filename
// fields are set accordingly.  An example:
//
// cmdline: "wc -l -c < Makefile"
// argv[]:
//   [ 0]: wc
//   [ 1]: -l
//   [ 2]: -c
//   [ 3]: NULL      NOTE "<" and "Makefile" removed
// input_filename: Makefile
//
// SETTING OUTPUT FILENAME
//
// The output_filename field is set to a pattern like the following:
//
//     outdir/0017-data_sleep_print.sh.out
//     |      |     |                   +-> suffix .out
//     |      |     +-> argv[0] with any / characters replaced by _
//     |      +-> 4 digit cmdid (index into cmds[] array), 0-padded
//     +->cmddir[] directory name followed by "/"
//
// A copy of the argv[0] string is modified to replace slashes with
// underscores and the sprintf() family of functions is used for
// formatting.
//
// SETTING OTHER FIELDS
//
// Other fields are set as follows:
// - argc to the length of the argv[] array
// - cmdstate to the CMDSTATE_INIT 
// - pid, exit_code, output bytes to -1
//
// The function returns 1 if the added command caused the internal
// array of commands to expand and 0 otherwise. 
//
// CONSTRAINT: Do not use snprintf(), just plain sprintf(). Aim for
// simplicity and add safety at a later time.

void cmdctl_print_oneline(cmdctl_t *cmdctl, int cmdid);
// PROBLEM 1: Prints a oneline summary of the indicated command's
// current state. The format is:
//
// EXAMPLES:
//  A:5 B:1 C:-6    D:7     E:-15         F:remaining
// ------------------------------------------------------------
//    24 #007575       - RUNNING         data/sleep_print.sh
//   123 #007570      54 EXIT(0)         seq         
//     2 #007566      73 EXIT(1)         gcc         
//  2961 #007562      23 SIGNALLED(-15)  data/self_signal.sh
// ------------------------------------------------------------
// 123456789012345678901234567890123456789012345678901234567890
//
// - A: cmdid (index into the cmds[] array), 5 places, right aligned
// - B: # symbol
// - C: PID of command, 6 places 0 padded, left aligned
// - D: number of output bytes if not running, otherwise a "-", 7 places
//      right aligned
// - E: printed state with exit code/signal, 15 places, left aligned
// - F: argv[0] (command name), left aligned, printed for remainder of
//   line
//
// For E, the possible outputs are based on cmdstate_t values:
// - NOTSET
// - INIT
// - RUNNING
// - EXIT(<num>)      : positive number of normal exit
// - SIGNALLED(<num>) : negative number of signal
// - UNKNOWN_END
// - FAIL_INPUT
// - FAIL_OUTPUT
// - FAIL_EXEC
//
// NOTE: Most implementations will use a combination of printf() and
// possibly sprintf() to get the required widths. The trickiest part
// is getting the states EXIT() / SIGNALLED() aligned correctly for
// which an individual call to sprintf() to first format the numbers
// followed by a printf() with a width specifier is helpful.
//
// CONSTRAINT: Do not use snprintf(), just plain sprintf(). Aim for
// simplicity and add safety at a later time.

void cmdctl_print_all(cmdctl_t *cmdctl);
// PROBLEM 1: Prints a header and then iterates through all commands
// printing one-line summaries of them information on them. Prints a
// table header then repeatedly calls cmdctl_print_oneline(). Example:
//
// CMDID PID       BYTES STATE           COMMAND
//     0 #107561      22 SIGNALLED(-9)   data/self_signal.sh
//     1 #107562      23 SIGNALLED(-15)  data/self_signal.sh
//     2 #107566      73 EXIT(1)         gcc         
//     3 #107570      54 EXIT(0)         seq         
//     4 #107575       - RUNNING         data/sleep_print.sh

void cmdctl_print_info(cmdctl_t *cmdctl, int cmdid);
// PROBLEM 1: Prints detailed information about the given
// command. Example output is as follows.
//
// EXAMPLE 1: Exited command
// Call: cmdctl_print_info(cmdctl, 2);
// -------OUTPUT-------------
// CMD 2 INFORMATION
// command: seq 25
// argv[]:
//   [ 0]: seq
//   [ 1]: 25
// cmdstate: EXIT(0)
// input: <NONE>
// output: commando-dir/0002-seq.out
// output size: 66 bytes
// -------------------------
// 
// EXAMPLE 2: Running command
// Call: cmdctl_print_info(cmdctl, 4);
// -------OUTPUT-------------
// CMD 4 INFORMATION
// command: data/sleep_print.sh 25 hello world
// argv[]:
//   [ 0]: data/sleep_print.sh
//   [ 1]: 25
//   [ 2]: hello
//   [ 3]: world
// cmdstate: RUNNING
// input: <NONE>
// output: commando-dir/0004-data_sleep_print.sh.out
// output size: <CMD NOT FINISHED>
// -------------------------
//
// May have be some duplicate code in this function to that present in
// cmd_print_oneline() for handling the different cmdstate values.

void cmdctl_show_output(cmdctl_t *cmdctl, int cmdid);
// PROBLEM 1: If the given command is not finished (e.g. still
// RUNNING), prints the message
//
//   NO OUTPUT AVAILABLE: command has not finished running
//
// If the command is finished, opens the output file for the command
// and prints it to the screen using low-level UNIX I/O.
//
// CONSTRAINT: This routine must use low-level open() and read() calls
// and must allocate no more memory for the file contents than
// MAX_LINE bytes in a buffer. Use of fscanf(), fgetc(), and other C
// standard library functions is not permitted and scanning the
// entirety of the file into memory is also not permitted.

////////////////////////////////////////////////////////////////////////////////
// PROBLEM 2 Functions
////////////////////////////////////////////////////////////////////////////////

int cmdctl_start_cmd(cmdctl_t *cmdctl, int cmdid);
// PROBLEM 2: Start a child process that will run the indicated
// cmd. After creating the child process, the parent sets sets the
// `pid` field, changes the state to RUNNING and returns 0.
//
// The child sets up output redirection so that the standard out AND
// standard error streams for the child process is channeled into the
// file named in field `output_filename`. Note that standard out and
// standard error are "merged" so that they both go to the same
// `outfile_name`. This file should use the standard file
// creation/truncation options (O_WRONLY|O_CREAT|O_TRUNC) and be
// readable/writable by the user (S_IRUSR|S_IWUSR).
//
// If input_filename is not empty, input redirection is also set up
// with input coming from the file named in that field. Output
// redirection is set up first to allow any errors associated with
// input redirection to be captured in the output file for the
// command. 
//
// IMPORTANT: Any errors in the child during I/O redirection or
// exec()'ing print error messages and cause an immediate exit() with
// an associated error code. These are as follows:
//
// | CONDITION            | EXIT WITH CODE              | Message                                                                         |
// |----------------------+-----------------------------+---------------------------------------------------------------------------------|
// | Output redirect fail | exit(CMDSTATE_FAIL_OUTPUT); | No message printed                                                              |
// | Input redirect fail  | exit(CMDSTATE_FAIL_INPUT);  | ERROR: can't open file 'no-such-file.txt' for input : No such file or directory |
// | Exec failure         | exit(CMDSTATE_FAIL_EXEC);   | ERROR: program 'no-such-cmd' failed to exec : No such file or directory         |
//
// The "No such file..." message is obtained and printed via
// strerror(errno) which creates a string based on what caused a
// system call to fail.
//
// NOTE: When correctly implemented, this function should never return
// in the child process though the compiler may require a `return ??`
// at the end to match the int return type. NOT returning from this
// function in the child is important: if a child manages to return,
// there will now be two instances of main() running with the child
// starting its own series of grandchildren which will not end well...

int cmdctl_update_one(cmdctl_t *cmdctl, int cmdid, int finish);
// PROBLEM 2: Updates a single cmd to check for its completion. If the
// cmd is not RUNNING, returns 0 immediately.
//
// If the parameter `finish` is 0, uses wait()-family system calls to
// determine if the child process associated with the command is
// complete. If not returns 0 immediately - a NON-BLOCKING WAIT() is
// required to accomplish this.
//
// If the parameter `finish` is 1, uses a BLOCKING-style call to wait
// until the child process is actually finished before moving on.
//
// If the child process is finished, then diagnosis its exit status to
// determine a normal exit vs abnormal termination due to a
// signal. the W-MACROS() are used to determine this. The
// cmd->exit_code field is set to positive for a regular exit code or th
// negative signal number for an abnormal exit.
//
// The output_bytes is set by using a stat()-family call to determine
// the number of bytes in the associated output file.
//
// When the command finishes, an "ALERT" message is printed like the
// following which primarily uses the cmd_print_oneline() function.
//
// ---> COMPLETE:     2 #108624    2617 EXIT(0)         ls
// ---> COMPLETE:   129 #108725      22 SIGNALLED(-2)   data/self_signal.sh
// <string shown> <----------output from cmd_print_oneline()---------------->
//
// Returns 1 when the child process changes from RUNNING to a
// completed state.

int cmdctl_update_all(cmdctl_t *cmdctl, int finish);
// PROBLEM 2: Iterates through all commands and calls update on
// them. Passes the the `finish` parameter on to each call. Counts
// then number of commands that change state (from RUNNING to a
// finished state) and if 1 or more finish, prints a message like
//
//   4 commands finished
//
// after completing the loop. Returns the number of commands the that
// finished.

////////////////////////////////////////////////////////////////////////////////
// PROBLEM 3: Implement main() in commando_main.c
////////////////////////////////////////////////////////////////////////////////

int main(int argc, char *argv[]);
// Problem 3: main in command_main.c.
//
// * COMMAND LINE FORMS 
//
// The program must support four command line forms.
// | ./commando                        | argc=1 | No echo, default cmddir          |
// | ./commando --echo                 | argc=2 | Echoing on                       |
// | ./commando --dir <dirname>        | argc=3 | Set cmddir to argument           |
// | ./commando --echo --dir <dirname> | argc=4 | Echoing on and non-defaut cmddir |
//
// When the --echo option is provided, each line of input that is read
// in is first printed to the screen. This is makes testing easier.
//
// When the --dir <dirname> option is present, it sets the output
// directory used to store command output. If it is not present, the
// default cmddir name DEFAULT_CMDDIR is used; commando.h sets this to
// "command-dir".
//
// If a command line form above is not matched (arg 1 is not --echo,
// no <dirname> provided, 5 or more args given, etc.), then the
// following usage message should be printed:
//
//   usage: ./commando
//          ./commando --echo
//          ./commando --dir <dirname>
//          ./commando --echo --dir <dirname>
//   Incorrect command line invocation, use one of the above
//
//
// * INTERACTIVE LOOP
//
// After setting up a cmdctl struct, main() enters an interactive loop
// that allows users to use built-in and external commands.  Each
// iteration of the interactive loop prints a prompt then reads a line
// of text from users using the fgets() function. If echoing is
// enabled, the line read is immediately printed.
//
// A full line is read as it may contain many tokens that will become
// part of an external command to run.  The first "token" (word) on
// the line is extracted using a call to sscanf() and checked against
// the built-in commands below. If the word matches a known built-in,
// then the program honors it and iterates.
//
// If no built-in functionality matches, then the line is treated as
// an external command and run via a fork() / exec() regime from
// functions like cmdctl_add_cmd() and cmdctl_start_cmd().
//
// At the top of each interactive loop, all commands are updated via a
// call to cmdctl_update_all(...,0) which which will check to see if
// any commands have finished and print a message indicating as much
// before the prompt.
//
// Cautions on using fgets(): While useful, fgets() is a little tricky
// and implementer should look for a brief explanation of how it
// works. Keep in mind the following
// - It requires a buffer to read into; use one of size MAX_LINE
// - It will return NULL if the end of input has been reached
// - Any newlines in the input will appear in the buffer; use strlen()
//   to manually "chop" lines to replace the trailing \n with \0 when
//   processing the command
// - A handy invocation is something like
//     char firstok[...];
//     sscanf(inline, "%s", firstok);
//   which allows the first token (word) to be extracted from the
//   input line.  Other tokens can be similarly extracted using
//   sscanf(). 
//
// * STARTUP MESSAGES AND ERRORS
//
// When beginning, commando will print out the following:
//
//   === COMMANDO ver 2 ===
//   Re-using existing output directory 'commando-dir'
//   Type 'help' for supported commands
//   COMMANDO>>
//
// The last line is the prompt for input form the user.
//
// The first line indicates that there is already a directory present
// with output so old command output may get overwritten.  It is
// printed during cmdctl_create_cmddir().
//
// * BUILT-IN FUNCTIONALITY
//
// Typing 'help' will show a message about the built-in functionality.
//
// COMMANDO>> help
// help                       : show this message
// exit                       : exit the program
// directory                  : show the directory used for command output
// history                    : list all jobs that have been started giving information on each
// pause <secs>               : pause for the given number of seconds which may be fractional
// info <cmdid>               : show detailed information on a command
// show-output <cmdid>        : print the output for given command number
// finish <cmdid>             : wait until the given command finishes running
// finish-all                 : wait for all running commands to finish
// source <filename>          : (MAKEUP) open and read input from the given file as though it were typed
// command <arg1> <arg2> ...  : non-built-in is run as a command and logged in history
//
// These are all demonstrated in the project specification and
// generally encompass either an associated service function. The
// `source` built-in is optional for MAKEUP credit.

>> ./commando
=== COMMANDO ver 2 ===
Re-using existing output directory 'commando-dir'
Type 'help' for supported commands
[COMMANDO]>> help
help                       : show this message
exit                       : exit the program
directory                  : show the directory used for command output
history                    : list all jobs that have been started giving information on each
pause <secs>               : pause for the given number of seconds which may be fractional
info <cmdid>               : show detailed information on a command
show-output <cmdid>        : print the output for given command number
finish <cmdid>             : wait until the given command finishes running
finish-all                 : wait for all running commands to finish
source <filename>          : (MAKEUP) open and read input from the given file as though it were typed
command <arg1> <arg2> ...  : non-built-in is run as a command and logged in history
[COMMANDO]>> exit

>> 

>> ./commando abc               ## no option 'abc'
usage: ./commando
       ./commando --echo
       ./commando --dir <dirname>
       ./commando --echo --dir <dirname>
Incorrect command line invocation, use one of the above

>> ./commando --dir             ## missing <dirname> for option
usage: ./commando
       ./commando --echo
       ./commando --dir <dirname>
       ./commando --echo --dir <dirname>
Incorrect command line invocation, use one of the above

>> echo $?                      ## exit code 1 when usage is printed
1

>> ./commando                   ## NO echoing 
=== COMMANDO ver 2 ===
Type 'help' for supported commands
[COMMANDO]>> history            ## built-in entered
CMDID PID       BYTES STATE           COMMAND
[COMMANDO]>> directory          ## built-in entered
Output directory is 'commando-dir'
[COMMANDO]>> exit               ## built-in entered

>> ./commando --echo            ## ENABLE echoing
=== COMMANDO ver 2 ===
Type 'help' for supported commands
[COMMANDO]>> history            ## built-in entered
history                         ## and echoed
CMDID PID       BYTES STATE           COMMAND
[COMMANDO]>> directory          ## built-in entered
directory                       ## and echoed
Output directory is 'commando-dir'
[COMMANDO]>> exit               ## built-in entered
exit                            ## and echoed

>> 

#define DEFAULT_CMDDIR "commando-dir" // default output directory for commands

>> ./commando --dir special-dir        ## start with non-default directory 
=== COMMANDO ver 2 ===
Type 'help' for supported commands
[COMMANDO]>> exit

>> ./commando --dir special-dir        ## directory already exists
=== COMMANDO ver 2 ===
Re-using existing output directory 'special-dir'
Type 'help' for supported commands
[COMMANDO]>> exit

>> echo Dont overwrite me > other-dir  ## create a file 

>> ./commando --dir other-dir          ## won't overwrite the existing file so quit
=== COMMANDO ver 2 ===
ERROR: Could not create cmd directory 'other-dir'
       Non-directory file with that name already exists
Unable to run without an output directory, exiting

>> 

>> ./commando
=== COMMANDO ver 2 ===
Re-using existing output directory 'commando-dir'
Type 'help' for supported commands

[COMMANDO]>> ls data

[COMMANDO]>> gcc --version
---> COMPLETE:     0 #237938     242 EXIT(0)         ls
1 commands finished

[COMMANDO]>> data/table.sh
---> COMPLETE:     1 #237941     228 EXIT(0)         gcc
1 commands finished

[COMMANDO]>> 
---> COMPLETE:     2 #237947    1140 EXIT(0)         data/table.sh
1 commands finished

[COMMANDO]>> data/self_signal.sh 9

[COMMANDO]>> 
---> COMPLETE:     3 #237957      22 SIGNALLED(-9)   data/self_signal.sh
1 commands finished
[COMMANDO]>> history
CMDID PID       BYTES STATE           COMMAND
    0 #237938     242 EXIT(0)         ls
    1 #237941     228 EXIT(0)         gcc
    2 #237947    1140 EXIT(0)         data/table.sh
    3 #237957      22 SIGNALLED(-9)   data/self_signal.sh

[COMMANDO]>> 

>> ./commando
=== COMMANDO ver 2 ===
Re-using existing output directory 'commando-dir'
Type 'help' for supported commands
[COMMANDO]>> help                        ## show the help message which includes
...                                      ## the `source` command
source <filename>          : (MAKEUP) open and read input from the given file as though it were typed
...
[COMMANDO]>> source data/script.txt      ## read and execute all input from a script
Sourcing file 'data/script.txt'          ## print a message about the script
[data/script.txt]>> data/sleep_print.sh 1 hello world
[data/script.txt]>> ls -l                ## prompt changes to reflect the script file
[data/script.txt]>> seq 25
[data/script.txt]>> wc -l Makefile
[data/script.txt]>> pause 1.5
Pausing for 1.500000 seconds
---> COMPLETE:     0 #315311      12 EXIT(0)         data/sleep_print.sh
---> COMPLETE:     1 #315312    2415 EXIT(0)         ls
---> COMPLETE:     2 #315313      66 EXIT(0)         seq
---> COMPLETE:     3 #315314      13 EXIT(0)         wc
4 commands finished
[data/script.txt]>>                      ## no more input in the script
End of input                           
Closing source file 'data/script.txt'    ## transition back to stadard inpu
[COMMANDO]>> history                     ## back to standard input; read more commands
CMDID PID       BYTES STATE           COMMAND
    0 #315311      12 EXIT(0)         data/sleep_print.sh
    1 #315312    2415 EXIT(0)         ls
    2 #315313      66 EXIT(0)         seq
    3 #315314      13 EXIT(0)         wc
[COMMANDO]>> exit                        ## exit commando