How can I make a script that opens terminal windows and executes commands in them?

gnome-terminal -- command

or

xterm -e command

or

konsole -e command

Pretty much

terminal -e command

To make the terminal stay when the command exits:

In konsole there is a --noclose flag.

In xterm, there is a -hold flag.

In gnome-terminal, go to Edit -> Profile Preferences -> Title. Click the Command tab. Select Hold the terminal from the drop-down menu labelled When command exits. You should create a new profile for that and execute with

gnome-terminal --window-with-profile=NAMEOFTHEPROFILE -e command

Instead of hard-coding gnome-terminal, konsole, et cetera, use the Alternatives system. The program that executes the default terminal emulator is:

x-terminal-emulator

On my system, it opens a new instance of Konsole every time I execute this command.

Luckily, the terminals seems to support the -e option for executing a command (I verified it for konsole and gnome-terminal). Arguments after the command are passed to the invoked command. Bash refuses to stay open in my terminal, an additional script is needed to get a terminal:

#!/bin/sh
"$@"
exec "$SHELL"

If you've saved the previous script as /home/user/hacky and made it executable, you would run your scripts with:

x-terminal-emulator -e /home/user/hacky your-script optional arguments here

The full path is required and /home/user/hacky has to be executable.

My previous attempt to run a script in a new terminal window can be found in revision #2, it was before I realised arguments can be passed to x-terminal-emulator.

UPDATE 17 FEB 2020: this answer is now perhaps obsolete.

Consider clicking this link and using this other answer of mine instead: Open Terminal with multiple tabs and execute application

Aided by @nickguletskii's answer, and my own comment under his answer, and inspired by @grabantot's upvote of my comment, here's my preferred way to do it, especially when I want the terminal to stay open so I can then manually use it.

Ex. usage: this is really useful to add to your startup programs so this script will run, open a terminal, create and name a tab in the terminal, and run a command for you. Or, you can just add a symlink to this script to your desktop. I use this type of approach so I can double-click a single icon on my desktop and have it open up a bunch of terminals (with various tabs named according to what work I'm going to do in them) and programs to set up my programming environment, for instance, for daily work.

Here's a contrived example, which opens up a single tab, titles it "test", then runs the simple command cd /etc; ls inside it. The $SHELL part at the end forces the shell to stay open so you can then see its output and continue using it (I learned this somewhere else on Stack Overflow):

gnome-terminal --tab --title="test" --command="bash -c 'cd /etc; ls; $SHELL'"

Here's a more complicated example which opens up 3 separate tabs in the same gnome-terminal. This is exactly the type of thing my desktop shortcut does so I can open up a bunch of programming windows at once:

gnome-terminal --tab --title="tab 1" --command="bash -c 'cd /etc; ls; $SHELL'" --tab --title="tab 2" --command="bash -c 'cd ~; ls; $SHELL'" --tab --title="tab 3" --command="bash -c 'cd ~/temp3; ls; $SHELL'"

Here's a breakdown of that command above:

• gnome-terminal = open up a gnome-terminal
• --tab = open up a unique tab for what comes next
• --title="tab 1" = title this tab "tab 1"
• --command="bash -c 'cd /etc; ls; $SHELL'" = run the bash -c 'cd /etc; ls; $SHELL' command, which is a command I just made up as an example; here's what it does:
• bash -c says it is a bash 'c'ommand
• cd /etc = 'c'hange 'd'irectory into the "/etc" path
• ls = 'l'i's't contents of this directory
• $SHELL = this cryptic tidbit is required to keep the shell open so you can work with it. If you want the shell to open, run your command, then close, simply remove this part. I, however, want the tab to stay open so I can go make programming magic. :)
• we then start back over at the --tab part to produce tab 2, then again for tab 3. Customize to your heart's content.

Screenshot:

Quite simply-

#!/bin/bash

/etc/init.d/ccpd status

This is enough for other commands that do not need to display anything in terminal. But here one has to see the status displayed.
So, it needs to run in a terminal window

#!/bin/bash

gnome-terminal -e "/etc/init.d/ccpd status"  --window-with-profile=NAMEOFTHEPROFILE

The other post intended [] to be a placeholder

Here "NAMEOFTHEPROFILE" is to be replaced with the name of the profile that "Holds the terminal when the command exits".

commenting for the answer by Lekensteyn. I know this is a old post, but for anyone who finds this useful (as I just did) Instead of making another "hacky script" with just put a function inside the script you are calling

hacky_function()
{
"$@"
exec "$SHELL"
}

Call your script with "x-terminal-emulator -e /path/to/script hacky_function optional arguments here"

Don't forget to put "$@" at the end of the script

Update to what I use now (2022)

#!/usr/bin/expect -f
# Get a Bash shell 
spawn -noecho bash
# Wait for a prompt 
expect "$ "
send "sudo /home/user/script.sh arg"
# Hand over control to the user
interact
exit

Almost a decade late to the party but, here's my answer using Python.

In the .gif below I launched the program from an existing terminal with screen recorder running to show what it would look like at login:

I wrote a python program for this answer. There are some extra features not requested by OP but beneficial to me:

• Runs on autostart to setup GUI applications frequently used after login.
• Opens multiple gnome-terminal tabs.
• Assign title to terminal tabs.
• Moves windows to preferred position on desktop.
• Opens gedit and last five opened files in separate tabs.

The python program:

#!/usr/bin/env python
# -*- coding: utf-8 -*-

#==============================================================================
#
#       dellstart - Autostart GUI applications on Dell Fileserver
#
#==============================================================================

'''
CALL:

   dellstart

REQUIRES:

   sudo apt install xdotool
    
'''

from __future__ import print_function           # Must be first import
import os
import time

BASHRC_TIME = 2                                 # Seconds to load ~/.bashrc
WINDOW_TIME = .5                                # Secpmds fpr window to appear

commands = [ 'gnome-terminal &',                # Launch terminal in background
             'sleep '+str(BASHRC_TIME),         # Bash command wait a sec
             'move x y',                        # Move windows to x and/or y
#             'move 2100 1000',                  # triple monitor setup
             'xdotool type "cd ~"',             # Change to home directory
             'xdotool key Return',              # Enter Key
             'xdotool type "./ssh-activity"',   # Suspend after 15 minutes
             'xdotool key Return',              # Enter Key
             'title SSH\ Activity',             # Window title (escape spaces)
             'xdotool key Control_L+Shift_L+T', # Open new terminal tab
             'sleep '+str(BASHRC_TIME),         # Bash command wait a sec
             'xdotool type "cd ~/askubuntu"',   # Change to working directory
             'xdotool key Return',              # Enter Key
             'title Ask\ Ubuntu',               # Window title (escape spaces)
             'gedit',                           # Last 5 files will open up
             'move x y',                        # Move windows to x and/or y
#             'move 3849 2266',                  # triple monitor setup
           ]

""" NOTE: To discover window coordinates, arrange on desktop and type:

        wmctrl -lG
"""

def process_commands(command_list):

    for command in command_list:

        if command.endswith('&'):
            # Launch in background and get window ID opened
            active_pid, active_win = launch_command(command)
            if active_pid == 0:
                print("ERROR launching", command, \
                "Aborting 'dellstart' script")
                exit()

        elif command.startswith('move'):
            move_window(command, active_win)

        elif command.startswith('title'):
            terminal_title(command)

        elif command.startswith('gedit'):
            gedit()

        else:
            run_and_wait(command)


def launch_command(ext_name):
    ''' Launch external command in background and return PID to parent.
        Use for programs requiring more than .2 seconds to run.
    '''

    all_pids = get_pids(ext_name)       # Snapshot current PID list
    all_wins = get_wins(all_pids)       # Snapshot of windows open
    new_pids = all_pids
    new_wins = all_wins
    sleep_count = 0                     # Counter to prevent infinite loops

    os.popen(ext_name)                  # Run command in background

    while new_pids == all_pids:         # Loop until new PID is assigned
        new_pids = get_pids(ext_name)   # Snapshot current PID list
        if sleep_count > 0:             # Don't sleep first time through loop
            time.sleep(.005)            # sleep 5 milliseconds
        sleep_count += 1
        if sleep_count == 1000:         # 10 second time-out
            print('launch_ext_command() ERROR: max sleep count reached')
            print('External command name:',ext_name)
            return 0

    pid_list = list(set(new_pids) - set(all_pids))
    if not len(pid_list) == 1:
        print('launch_command() ERROR: A new PID could not be found')
        return 0, 0

    time.sleep(WINDOW_TIME)             # Give time for window to appear
    new_wins = get_wins(all_pids)       # Snapshot of windows open
    win_list = list(set(new_wins) - set(all_wins))
    if not len(win_list) == 1:
        #print('launch_command() ERROR: New Window ID could not be found')
        #suppress error message because we aren't using window ID at all
        return int(pid_list[0]), 0

    # Return PID of program we just launched in background
    return int(pid_list[0]), int(win_list[0])


def run_and_wait(ext_name):
    ''' Launch external command and wait for it to end.
        Use for programs requiring less than .2 seconds to run.
    '''

    result = os.popen(ext_name).read().strip()
    #print('run_and_wait() command:', ext_name)
    return result


def get_pids(ext_name):
    ''' Return list of PIDs for program name and arguments
        Whitespace output is compressed to single space
    '''
    all_lines = []
    # Just grep up to first space in command line. It was failing on !
    prog_name = ext_name.split(' ',1)[0]
    all_lines = os.popen("ps aux | grep -v grep | grep " + \
                        "'" + prog_name + "'").read().strip().splitlines
    PID = []
    for l in all_lines():
        l = ' '.join(l.split())         # Compress whitespace into single space
        PID.append(int(l.split(' ', 2)[1]))

    return PID


def get_wins(all_pids):
    ''' Return list of all windows open under PID list
        Currently unncessary because we work on active window '''
    windows = []
    for pid in all_pids:
        all_lines = os.popen('xdotool search --pid ' + str(pid)). \
                             read().strip().splitlines
        for l in all_lines():
            windows.append(int(l))

    return windows


def move_window(line, active_win):
    ''' Move window to x y coorindates on Desktop

        If the letter x or y is passed, that dimension remains unchanged eg:

            xdotool getactivewindow windowmove 100 100    # Moves to 100,100
            xdotool getactivewindow windowmove x 100      # Moves to x,100
            xdotool getactivewindow windowmove 100 y      # Moves to 100,y

    '''
    line = ' '.join(line.split())       # Compress whitespace to single space
    x = line.split(' ')[-2]
    y = line.split(' ')[-1]

    # We don't need to pass window ID as last active window defaults
    all_lines = os.popen('xdotool getactivewindow windowmove ' + x + ' ' + y). \
                         read().strip().splitlines
    for l in all_lines():
        print(l)


def terminal_title(new_title):
    ''' Rather awkward calling xdotool which chokes on double quotes and bash
        via python which chokes on backslashes.

        Simple format (if it worked) would be:
            command = r'PS1="${PS1/\\u@\\h: \\w/' + title + '}"'

        The bash function copied from is:
            function termtitle() { PS1="${PS1/\\u@\\h: \\w/$@}"; }

        Reference for xdotool keycodes: 
        https://gitlab.com/cunidev/gestures/-/wikis/xdotool-list-of-key-codes
    '''

    title = new_title.split(' ', 1)[1]   # Strip out leading "title" token

    command = 'xdotool type PS1='
    run_and_wait(command)
    run_and_wait('xdotool key quotedbl')
    command = 'xdotool type $'
    run_and_wait(command)
    run_and_wait('xdotool key braceleft')
    command = 'xdotool type PS1/'
    run_and_wait(command)
    run_and_wait('xdotool key backslash')
    run_and_wait('xdotool key backslash')
    command = 'xdotool type u@'
    run_and_wait(command)
    run_and_wait('xdotool key backslash')
    run_and_wait('xdotool key backslash')
    command = 'xdotool type "h: "'
    run_and_wait(command)
    run_and_wait('xdotool key backslash')
    run_and_wait('xdotool key backslash')
    command = 'xdotool type "w/"'
    run_and_wait(command)
    command = 'xdotool type "' + title + '"'
    run_and_wait(command)
    run_and_wait('xdotool key braceright')
    run_and_wait('xdotool key quotedbl')
    run_and_wait('xdotool key Return')


def gedit():

    last_modified_files = gedit_recent_files()
    command = 'gedit '
    for f in last_modified_files:
        command=command+'"'
        command=command+f
        command=command+'" '
    # Open gedit with last five modfied files
    command=command+' &'
    active_pid, active_win = launch_command(command)
    if active_pid == 0:
        print("ERROR launching", command, \
        "Aborting 'dellstart' script")
        exit()


def gedit_recent_files():
    ''' Get list of gedit 5 most recent files:
    
grep --no-group-separator -B5 'group>gedit' ~/.local/share/recently-used.xbel | sed -n 1~6p | sed 's#  <bookmark href="file:///#/#g' | sed 's/"//g'

/home/rick/python/mmm added=2020-05-02T15:34:55Z modified=2020-11-19T00:43:45Z visited=2020-05-02T15:34:56Z>
/home/rick/python/mserve added=2020-07-26T16:36:09Z modified=2020-11-28T01:57:19Z visited=2020-07-26T16:36:09Z>

    '''
    command = "grep --no-group-separator -B5 'group>gedit' " + \
              "~/.local/share/recently-used.xbel | " + \
              "sed -n 1~6p | sed 's#  <bookmark href=" + '"' + \
              "file:///#/#g' | " + "sed 's/" + '"' + "//g'"

    recent_files = []
    times = []
    all_lines = os.popen(command).read().strip().splitlines
    uniquifier = 1                  # gedit can give all open files same time
    for l in all_lines():
        fname = l.split(' added=', 1)[0]
        trailing = l.split(' added=', 1)[1]
        modified = trailing.split(' modified=', 1)[1]
        modified = modified.split('Z', 1)[0]
        # TODO: 2038
        d = time.strptime(modified, '%Y-%m-%dT%H:%M:%S')
        epoch = time.mktime(d)
        epoch = int(epoch)
        recent_files.append(fname)

        try:
            times.index(epoch)
            # gedit has given multiple files the same modification time
            epoch += uniquifier
            uniquifier += 1
        except:
            pass                    # Not a duplicate time
        times.append(epoch)

    N=5
    top_files = []
    if N > len(times):
        # Less than 5 most recent files in list
        N = len(times)
        if N == 0:
            # No most recent files in list
            return top_files            # return empty list

    # Store list in tmp to retrieve index
    tmp=list(times)
    # Sort list so that largest elements are on the far right
    times.sort()

    #print ('5 most recent from lists and indices')
    for i in range(1, N+1):
        top_files.append(recent_files[tmp.index(times[-i])])

    return top_files


if __name__ == "__main__":

    process_commands(commands)

# end of dellstart

Note you may have to tinker with the variable BASHRC_TIME on your system to make program run faster. I have a lot of functions running in my ~/.bashrc and yours may run a lot faster.

I've planned on writing this for many years but never got around to it until now.

I got to chain multiple tabs like this, while avoiding warnings caused by using --command, which will be deprecated soon:

gnome-terminal\
    --tab\
        --title="TAB 1" -- bash -c "cd ~; ls; $SHELL"
gnome-terminal\
    --tab\
        --title="TAB 2" -- bash -c "cd ~/Desktop; ls; $SHELL"\

Use the screen command and -d detach from an existing screen session, and reattach here -m force a new screen session -S create a named session instead of using the default name