Ubuntu – How to make a script that opens terminal windows and executes commands in them

A common way people handle this is to make a bin directory in their home directory: mkdir ~/bin

Then, you can put your custom scripts in there: mv start-working ~/bin

Make sure your script is executable: chmod +x ~/bin/start-working

Add this to the bottom of your ~/.bashrc file (if you're using bash, which you probably are): export PATH=$PATH:~/bin

Now log back in and out of your terminal and you should be able to simply type start-working, and your script will execute.

Now that your path is setup, any new scripts you drop into your ~/bin you can just type in the name of.

Since you mention you solved the problem for your specific situation, below a solution for general purpose. Thanks to xdotool's --sync option, it works pretty reliable in the tests I ran; I could "send" commands to specific terminal windows and it ran perfectly without an exception.

How it works in practice

The solution exists from a script, which can be run with two options -set and -run:

1. To set up (open) an arbitrary number of terminal windows, in this example 3:

   target_term -set 3
   

   Three new terminals will open up, their window id is remembered in a hidden file:

   

   For clarity reasons I minimized the terminal window I ran the command from :)

2. Now that I created three windows, I can send commands to either one of them with the run command (e.g.):

   target_term -run 2 echo "Monkey eats banana since it ran out of peanuts"
   

   As shown below, the command ran in the second terminal:

   

   Subsequently, I can send a command to the first terminal:

    target_term -run 1 sudo apt-get update
   

   making sudo apt-get update run in terminal 1:

   

   and so on...

How to set up

1. The script needs both wmctrl and xdotool:

   sudo apt-get install wmctrl xdotool
   

2. Copy the script below into an empty file, safe it as target_term (no extension!) in ~/bin (create the directory ~/bin if necessary.

3. Make the script executable (don't forget) and either log out/in or run:

   source ~/.profile
   

4. Now setup your terminal windows, with the number of required windows as an argument:

   target_term -set <number_of_windows>
   

5. Now you can "send" commands to either one of your terminals with the command:

   target_term -run <terminal_number> <command_to_run>
   

The script

#!/usr/bin/env python3
import subprocess
import os
import sys
import time
#--- set your terminal below
application = "gnome-terminal"
#---

option = sys.argv[1]
data = os.environ["HOME"]+"/.term_list"

def current_windows():
    w_list = subprocess.check_output(["wmctrl", "-lp"]).decode("utf-8")
    w_lines = [l for l in w_list.splitlines()]
    try:
        pid = subprocess.check_output(["pgrep", application]).decode("utf-8").strip()
        return [l for l in w_lines if str(pid) in l]
    except subprocess.CalledProcessError:
        return []

def arr_windows(n):
    w_count1 = current_windows()
    for requested in range(n):
        subprocess.Popen([application])
    called = []
    while len(called) < n:
        time.sleep(1)
        w_count2 = current_windows()
        add = [w for w in w_count2 if not w in w_count1]
        [called.append(w.split()[0]) for w in add if not w in called]
        w_count1 = w_count2

    return called

def run_intterm(w, command):
    subprocess.call(["xdotool", "windowfocus", "--sync", w])
    subprocess.call(["xdotool", "type", command+"\n"]) 

if option == "-set":
    open(data, "w").write("")
    n = int(sys.argv[2])
    new = arr_windows(n)
    for w in new:
        open(data, "a").write(w+"\n")
elif option == "-run":
    t_term = open(data).read().splitlines()[int(sys.argv[2])-1]
    command = (" ").join(sys.argv[3:])
    run_intterm(t_term, command)

Notes

• The script is set for gnome-terminal, but can be used for any terminal (or other program as well) by changing the application in the head section of the script:

  #--- set your terminal below
  application = "gnome-terminal"
  #---
  

• The commands above can (of course) be run from a script as well in case you'd lile to use it for some kind of a simulation.
• The script waits until both the targeted window has focus and the command is done typing, so the command will always land in the right terminal window.

• No need to say that the script only works with the terminal setup (windows) that was called by the command:

  target_term -set
  

  The terminal windows will then be "labelled" by the script, like you mention in your question.

• In case you start a new target_term session, the hidden file, created by the script will simply be overwritten, so there is no need to remove it otherwise.