How to start a terminal with certain text already input on the command-line?

You can do this with expect (install). Create and make executable ~/bin/myprompt:

#!/usr/bin/expect -f

# Get a Bash shell
spawn -noecho bash

# Wait for a prompt
expect "$ "

# Type something
send "my text to be posted"

# Hand over control to the user
interact

exit

and run Gnome Terminal with:

gnome-terminal -e ~/bin/myprompt

ændrük's suggestion is very good and worked for me, however the command is hardcoded within the script, and if you resize the terminal window it doesn't work well. Using his code as the base, I've added the ability to send the myprompt script the command as an argument, and this script correctly handles resizing the terminal window.

#!/usr/bin/expect

#trap sigwinch and pass it to the child we spawned
#this allows the gnome-terminal window to be resized
trap {
 set rows [stty rows]
 set cols [stty columns]
 stty rows $rows columns $cols < $spawn_out(slave,name)
} WINCH

set arg1 [lindex $argv 0]

# Get a Bash shell
spawn -noecho bash

# Wait for a prompt
expect "$ "

# Type something
send $arg1

# Hand over control to the user
interact

exit

and run Gnome Terminal with:

gnome-terminal -e "~/bin/myprompt \"my text to be posted\""

If I understand correctly, you want your first input line to be prefilled to contents that you pass on the gnome-terminal command line.

I don't know how to do exactly this with bash, but here's something that comes close. In your ~/.bashrc, add the following line at the very end:

history -s "$BASH_INITIAL_COMMAND"

Run gnome-terminal -x env BASH_INITIAL_COMMAND='my text to be posted' bash, and press Up at the prompt to recall the text.

Note also that if you put set -o history followed by comments at the end of your .bashrc, they will be entered into the history as bash starts, so you can use them as a basis for editing by reaching them with the Up key and removing the initial #.

ændrük's answer is fine, but perhaps a little heavyweight for the task.

Here is a script that writes a script based on its arguments

#!/bin/sh
# terminal-plus-command: start a subordinate terminal which runs
# the interactive shell after first running the command arguments

tmpscript=/tmp/tmpscript.$$
echo "#!$SHELL" > $tmpscript
echo "$@" >> $tmpscript
echo exec "$SHELL" >> $tmpscript
chmod +x $tmpscript
gnome-terminal --command $tmpscript
rm -f $tmpscript

If you've not done much shell programming, there appears to be more magic here than there is. First, I name a temporary file for holding the script where $$ is the process ID of the shell running this script. The /tmp/something.$$ metaphor is used in case two instances of this script are run at the same time, they won't try to use the same temporary file.

The variable $SHELL is set to the name of the shell running the script. If you use /usr/bin/bash, presumably you'd like the mini-script to use it also.

The "$@" is a shell idiom for "interpolate all my arguments, quoting them if needed". This peculiar syntax causes

script.sh 'my file' your\ file

to interpolate the arguments as two elements

"my file" "your file"

instead of the four that $@ would yield

"my" "file" "your" "file"

The last lines of the script arrange for a gnome-terminal to start running the mini-script and then starting an interactive shell. When the gnome-terminal exits, the temporary script is removed because littering is uncool.

The last line is not a part of the mini-script, it demonstrates that the mini-script works. If the 11 line script above is in a file called rt.sh then the chmod makes it executable and then it is executed.

$ chmod +x rt.sh && ./rt.sh echo hello world

The result of all of this will be a gnome terminal which starts up, displays

hello world

on its first line and then starts an interactive shell:

msw@myhost:~$

The two answers I've liked best to solve this are using expect and this one where they recommend using the --init-file flag either in the shebang or when executing the terminal:

#!/bin/bash --init-file
commands to run

... and execute it as:

xterm -e /path/to/script
# or
gnome-terminal -e /path/to/script
# or
the-terminal -e bash --init-file /path/to/script/with/no/shebang

expect is probably the better solution (for reasons I'll outline), except that I cannot control whether it's installed in my target environment.

The problem I ran into with bash's --init-file and gnome-terminal's --command as a hack to solve this is the shell doesn't have access to STDIN while executing init scripts. If, for example, I want to run something that would require user input (ftp, telnet, etc) but leave the parent shell running afterward it won't work; the only exception I've seen to this so far is ssh:

xterm -e /bin/bash --init-file <(echo 'ssh -X some-machine')

... but what I need is more complicated than this toy example. Anyway, I hope the --init-file stuff is useful to anyone reading this question.

To start in interactive bash inside a gnome-terminal with some commands already executed I put those commands in a setup file and dynamically append the contents to my .bashrc file:

# my_startup_script.sh
export FOO=bar
echo "hello world"

gnome-terminal --tab -- bash -c "bash --rcfile <(cat ${HOME}/.bashrc my_startup_script.sh; )"
=> 
hello world
$ echo $FOO
bar

You can use the -e or -x arguments to run a command inside a newly popped up terminal, but that's not exactly what you want.