Como iniciar um terminal com algum texto já inserido na linha de comando?

22

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: [email protected]:/$ my text to be posted

Isso pode ser feito?

    
por emf 08.10.2010 / 19:39

6 respostas

29

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
    
por ændrük 09.10.2010 / 01:06
8

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.

    
por Gilles 09.10.2010 / 02:02
8

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\""
    
por Gordon McCreight 10.12.2010 / 07:27
1
A resposta do

æ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 "[email protected]" >> $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 "[email protected]" é 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 [email protected] 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:

[email protected]:~$
    
por msw 09.10.2010 / 16:13
0

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.

    
por Brian Vandenberg 23.01.2015 / 19:37
-1

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.

    
por Karl Bielefeldt 08.10.2010 / 19:46