Em vez de reformular minha pergunta, deixe-me descrever o caso do usuário desejado:
Eu criei um script de shell curto para executar o comando "gnome-terminal --someoptionflagname 'meu texto a ser postado'", e execute este script.
Gnome-terminal aparece, com o prompt da linha de comando seguido pelo meu texto.
ou seja: fields@mycomputer:/$ my text to be posted
Isso pode ser feito?
Você pode fazer isso com esperar ( install ). Crie e torne executável ~/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
e execute o Gnome Terminal com:
gnome-terminal -e ~/bin/myprompt
Se bem entendi, você quer que sua primeira linha de entrada seja pré-preenchida para o conteúdo que você passa na linha de comando do gnome-terminal.
Eu não sei como fazer exatamente isso com o bash, mas aqui está algo que chega perto. No seu ~/.bashrc , adicione a seguinte linha no final:
history -s "$BASH_INITIAL_COMMAND"
Execute gnome-terminal -x env BASH_INITIAL_COMMAND='my text to be posted' bash e pressione Acima no prompt para recuperar o texto.
Note também que se você colocar set -o history seguido de comentários no final de seu .bashrc , eles serão inseridos no histórico assim que o bash começar, para que você possa usá-los como base para edição, alcançando-os com o Tecla Acima e remoção do # inicial.
A sugestão do ændrük é muito boa e funcionou para mim, no entanto, o comando é codificado dentro do script e, se você redimensionar a janela do terminal, ele não funcionará bem. Usando seu código como base, adicionei a capacidade de enviar o script myprompt como um argumento, e esse script lida corretamente com o redimensionamento da janela do terminal.
#!/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
e execute o Gnome Terminal com:
gnome-terminal -e "~/bin/myprompt \"my text to be posted\""
ændrük é boa, mas talvez um pouco pesada para a tarefa.
Aqui está um script que escreve um script com base em seus argumentos
#!/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
Se você não fez muita programação shell, parece haver mais mágica aqui do que existe. Primeiro, nomeio um arquivo temporário para manter o script em que $$ é o ID do processo do shell que está executando esse script. A metáfora /tmp/something.$$ é usada no caso de duas instâncias desse script serem executadas ao mesmo tempo, elas não tentarão usar o mesmo arquivo temporário.
A variável $SHELL é configurada para o nome do shell que está executando o script. Se você usar / usr / bin / bash, presumivelmente, você gostaria que o mini-script também fosse usado.
O "$@" é uma expressão de shell para "interpolar todos os meus argumentos, citando-os se necessário". Esta sintaxe peculiar faz com que
script.sh 'my file' your\ file
para interpolar os argumentos como dois elementos
"my file" "your file"
em vez dos quatro que $@ produziria
"my" "file" "your" "file"
As últimas linhas do script organizam um terminal gnome para começar a executar o mini-script e depois iniciar um shell interativo. Quando o gnome-terminal sai, o script temporário é removido porque a sujeira não é legal.
A última linha não faz parte do mini-script, demonstra que o mini-script funciona. Se o script de 11 linhas acima estiver em um arquivo chamado rt.sh , então o chmod o torna executável e, em seguida, é executado.
$ chmod +x rt.sh && ./rt.sh echo hello world
O resultado de tudo isso será um terminal do gnome que inicia, exibe
hello world
na primeira linha e, em seguida, inicia um shell interativo:
msw@myhost:~$
As duas respostas que eu mais gostei de resolver isso estão usando expect e este onde eles recomendam usar o sinalizador --init-file na shebang ou ao executar o terminal:
#!/bin/bash --init-file
commands to run
... e execute-o como:
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 é provavelmente a melhor solução (por motivos que descreverei), exceto que não posso controlar se ela está instalada no meu ambiente de destino.
O problema que eu tive com% bash --init-file e gnome-terminal --command como um hack para resolver isso é o shell não tem acesso a STDIN enquanto executa scripts de init. Se, por exemplo, eu quiser executar algo que exija a entrada do usuário (ftp, telnet, etc), mas deixar o shell pai em execução, isso não funcionará; a única exceção que eu vi até agora é ssh:
xterm -e /bin/bash --init-file <(echo 'ssh -X some-machine')
... mas o que eu preciso é mais complicado do que esse exemplo de brinquedo. De qualquer forma, espero que o material --init-file seja útil para qualquer pessoa que esteja lendo esta questão.
Você pode usar os argumentos -e ou -x para executar um comando dentro de um terminal recém-aberto, mas isso não é exatamente o que você deseja.