Prevent macos automator Terminal ssh script from opening two windows - macos

I use a small macOS Automator script to ssh into a remote host so I can add it to the Dock:
tell application "Terminal"
activate
do script ("ssh robot#example.com;")
end tell
When used the first time, I get the expected remote Terminal window, but also an extra local Terminal window. All subsequent uses only generate a single window to the remote host.
I've tried some small alternatives like:
set currentWindow to do script...
and:
set currentTab to do script...
with the same result. Is there any way to prevent the initial local Terminal window?

I found a post that has the answer:
tell application "Terminal"
if not application "Terminal" is running then launch
do script ("ssh robot#example.com;")
activate
end tell

Related

can i run the terminal in the background from applescript

I have an applescript that calls the terminal to run some functions every time my mac wakes up from a sleep. I am getting a bit annoyed of the terminal constantly popping up everytime I open up the laptop. is there a way i can set it so that the terminal can run in the background or in a minimised window and not keep popping up?
My AppleScript is as follows:
set desktop_folder to "$HOME/Desktop"
tell application "Terminal"
activate
do script "cd desktop;cd project34;python3 main.py"
end tell
You can use this by itself, with out the Terminal block:
do shell script "cd ~/Desktop/project34; python3 main.py"
Note that you may need to include the path to python3.

OSX bash minimize window

In the Mac and using the bash shell, I want to execute a file that contains a single command (to start Jupyter Lab) and immediately minimize the terminal window.
Is there a way to do this WITHOUT installing third party software?
Yes, just use osascript and Applescript:
osascript -e 'tell application "Terminal" to set visible of front window to false'
Building on Paul R's answer, which in my testing appears to make the window fully hidden and unrecoverable, you can use the following to minimise the window to the dock if access is required again later:
osascript -e 'tell application "Terminal" to set miniaturized of every window to true'
You can create a file that with the command extension, for example jupiter-lab.command.
You add execution rights on it (chmod +x jupiter-lab.command). You edit the file and insert commands like in a bash script.
For example to open App Store, you could insert :
open "/Application/App Store.app"
The first time you double click on it, you will get a popup that tells you that the command has ended quickly. Just check the Suppress this message permanently not to see it anymore.
Note : the terminal will not be minimised but will be closed.

Check whether there is an active application using osascript

I have a script that is run from an application (in my case macvim) that performs a certain command in an available Terminal window or opens a new window if terminal is not used
However, if the terminal is open and it has something running in window 1 (e.g. vim), the script just put the command into the buffer.
Is there a way to check whether window 1 has a running application in it?
Here is the script
#!/usr/bin/osascript
tell application "Terminal"
if (count of windows) is 0 then
do script "ls"
else
#how do I check that window 1 doesn't have a running application?
do script "ls" in window 1
end if
end tell
Ok, answering my own question. This can be done with
if window 1 is busy then

Close Terminal window from within shell script (Unix)?

Is there a way to close a Terminal window from within a shell script? I have a .command file that should just get out of the way once it's done.
Using exit 0 will cleanly terminate the script.
Whether Terminal window stays open is user-configurable. The default is to always stay open. To change this:
Terminal.app > Preferences > Profiles > Shell
- "When the shell exists:"
> Close if the shell exited cleanly
- "Ask before closing:"
(•) Never
-- OR --
(•) Only if there are....
When "Close if shell exited cleanly" is used, the script will close the window if the exit result is 0, which is the default if nothing went wrong.
Since you don't want to delete all Terminal windows, first change the name of your window from "Terminal" to something else:
echo -n -e "\033]0;My Window Name\007"
Then at the end of the script, use:
osascript -e 'tell application "Terminal" to close (every window whose name contains "My Window Name")' &
You can use apple script to quit the terminal app. Add the following to your script -
osascript -e 'tell application "Terminal" to quit'
This will give you a popup confirming to close the app. You can disable this in Terminal preferences.
Alternatively, you can also use killall command to quit the app. The following would work just as well.
killall Terminal
Note:
Just as a side note, you can freely add the above commands to your script and it would work as you want. However, there are few caveats. First being you will limit the ability of your script to work on different boxes. Secondly, it would be safer to use nohup so that any commands that are currently running won't quit due to quitting of the Terminal app.
This works for me:
#!/bin/sh
{your script here}
osascript -e 'tell application "Terminal" to close (every window whose name contains ".command")' &
exit
This will work for closing just your windows opened with a .command file but leave things already running in other terminal windows. I know that I almost always have either sass or grunt watch something so I don't want to quit terminal totally.
closeWindow() {
/usr/bin/osascript << _OSACLOSE_
tell application "Terminal"
close (every window whose name contains "YourScriptName")
end tell
delay 0.3
tell application "System Events" to click UI element "Close" of sheet 1 of window 1 of application process "Terminal"
_OSACLOSE_
}
This will close the Terminal window for your script and keep any other Terminal windows open as long as their window titles don't match. For it to work Terminal will have to be added to the list of applications permitted to use the Accessibility framework. You can also cycle through Terminal windows with a repeat command and close every window x that contains a UI element "Close" on sheet 1.
I find the best solution for this is to use Automator to create a true OSX application which will work the same way regardless of how your system is configured. You can have the Automator run your shell script, or you can embed the shell script itself in Automator.
Here is how you do it:
Run Automator (in Applications).
Choose "New Document" and when it
asks "Choose a type for your document" choose "Application"
In the
left panel, select "Utilities" then "Run Shell Script".
Type in your
script commands in the workflow item in the right panel. You can either call another
shell script, or just put your commands in their directly.
Save the
Application, which will be a full-fledged Mac App. You can even
cut-and-paste icons from other apps to give your script some
personality.
#!/bin/bash -x
{your script here}
. exit 0
kill -9 $PPID
you can also create a shortcut for your script:
cp yourscript.sh ~/bin/yourshortcutnamewhateveryouwant
then type
yourshortcutnamewhateveryouwant
will run whatever is writen into script at any directory.

Run a script in an existing Terminal window when the current line already contains some text

If the current line in the frontmost Terminal tab contained the text aa, this would run the command aauptime:
set cmd to "uptime"
tell application "Terminal"
try
do script cmd in window 1
on error
do script cmd
end try
activate
end tell
You could obviously add something like tell app "System Events" to keystroke "ku" using control down before do script, but does anyone know any better solutions?
You know you can call a shell script without targeting the terminal, right?

Resources