How to run a shell script in OS X by double-clicking?

Question

I have a shell script that has user execution permission on OS X, but when I double click on it, it opens in a text editor. How can I get it to run by double-clicking it?

Poniard

Answer 1

• First in terminal make the script executable by typing the following command:

    chmod a+x yourscriptname
  

• Then, in Finder, right-click your file and select "Open with" and then "Other...".

• Here you select the application you want the file to execute into, in this case it would be Terminal. To be able to select terminal you need to switch from "Recommended Applications" to "All Applications". (The Terminal.app application can be found in the Utilities folder)

• NOTE that unless you don't want to associate all files with this extension to be run in terminal you should not have "Always Open With" checked.

• After clicking OK you should be able to execute you script by simply double-clicking it.

Statvolt

thanks i got it, I didn't know to associate with terminal, I thought need to associate with /bin/sh – Poniard

I couldn't find Terminal.app in the list until I realized that I had to look in the "Utilities" folder. Hopefully this will save somebody some time. – Idiosyncrasy

On OSX 10.8 and higher, an executable script whose names has either no suffix or suffix .command is by default executable from Finder, without the need to instruct Finder how to open it. – Equidistant

Terminal.app was greyed out as a possibility even after I chmod'ed it. – Fortitude

"All Applications" is the setting I was missing...probably what Cheruvim experienced as well. As for Glenn's comment: you can simply use the build-in Search feature at the upper-right corner of the window; make sure you type in the full name of the app, i.e. Terminal.app. – Maddux

Thank you so much for adding the details on how to get it to run with Terminal. I wasted 30-40mins on it before I searched stackoverflow :( – Shuping

@mklement0, On OSX 10.12.5 (Sierra, clean install) with the .command suffix, I needed to chmod a+x to make the script executable in the Finder, otherwise permission denied (I had read and write privileges). That was a Miniconda3-latest-MacOSX-x86_64.sh with extension changed to .command. – Skippy

@PatrickT: Yes, that's why I said (emphasis added): "an executable script ...". Executable means: a script with the executable bit(s) set and the calling user - relative to the ownership to the file - therefore possibly being allowed to invoke it. If you use chmod a+x (which is typical), anyone can invoke it (assuming they're also allowed to read the file). In other words: my comment wasn't about chmod a+x, it was about not needing to also tell Finder how to open such scripts. – Equidistant

Not the clean way to do it. Rename your script to the .command file extension. – Nudi

This works, but it always brings my Terminal window to the front. Is there any way to do this without the Terminal window being brought to the front? Maybe a way to have the script backgrounded from the start? – Ruching

Answer 2

Have you tried using the .command filename extension?

Pentatomic

This is better. In the @Statvolt answer the working folder isn't the same you open the script. – Pastime

Is there a way to launch "background" tasks with no console window? – Munniks

Please note, that current directory may not be the one your script located in. Take a look at this question to set it right: #60395 – Spheroidal

You still need to have execution permission (chmod +x) but the .command extension is already linked with Terminal. Great solution, thank you – Voracity

Apparently the user can't interact with the terminal program with this method - unless I am mistaken? – Wainscoting

@Pastime Is there a way to prevent the terminal from opening? – Rafa

is there a way to use this without the need to do chmod +x – Staffard

Answer 3

As of OSX 10.10 (Yosemite) and since at least OS X 10.8 (Mountain Lion), the behavior is as follows when you open (double-click) executable scripts from Finder:

• Executable scripts^[1] with either NO suffix or suffix .command:

  • are executed by default - no setup required:

    • a new Terminal window opens in which the script runs.
    • by default, the window will remain open after the script terminates so you can inspect the output (though at that point the shell that ran the script has exited and you cannot interact with it any longer).
      However, via Terminal's Preferences... > Profiles you can opt to automatically close the window when the script exits.

  • Caveat: the working folder is invariably the current user's home folder, NOT the folder in which the script is located.

    • To make a shell script change to the folder in which it is located, place
      • cd -- "$(dirname "$BASH_SOURCE")" right after the shebang line
      • or, if you must remain POSIX-compliant, cd -- "$(dirname "$0")".
      • For edge cases, such as finding a symlinked script's true source directory, see this answer.

  • If the script is unexpectedly not executable:

    • Make it executable by running chmod +x <script> in Terminal; otherwise, you'll see the following symptoms:

      • .command: Finder displays a misleading error message that suggests the problem can be fixed via File > Get Info, which is not true - use the chmod +x method suggested above.

      • no suffix:

        • with a shebang line (e.g., #!/bin/bash): behavior is as if the suffix were .sh - see below.
        • with no shebang line: opens in your default text editor (which is TextEdit by default).

• Scripts with suffix .sh, whether executable or not:

  • are opened for editing in TextEdit.app or, if installed, with Xcode.app.

• Scripts with suffix .scpt or .applescript (even if they're themselves marked as executable, which is not normally the case):

  • opened for editing in [Apple]Script Editor
  • Note that the JXA source-code files seem to have no distinct suffix (yet).

• Scripts with a custom suffix (a suffix not yet known to the system), whether executable or not (in fact, applies to any kind of file):

  • prompt you for the app to open them with when you first open them, and remember that choice.

---

^{[1] Executable means: a script with the executable permission bit(s) set and the calling user - relative to the ownership to the file - therefore potentially being allowed to execute it.
If you use chmod a+x to set all permission bits (which is typical), anyone can invoke it (assuming they're also allowed to read the file based on the read permission bit(s) and the file's ownership).}

Equidistant

It's possible to close the opened Terminal window when the script exits with a simple osascript you can include in within the .command file instead of manually messing with the profile. – Colbert

@I'L'I: Do you mean adding a osascript -e '...' command to the end of one's script? What's the specific command, and does it ensure that the right tab is closed even when the script is not running in the frontmost tab? – Equidistant

@mklement0: Yes, I haven't tested it more than a few minutes, but the basic idea is to include on the last line of the .command script: osascript -e 'tell application "Terminal" to close front window' > /dev/null 2>&1 & ... It might not work in every scenario, although the redirect at the end is really the key — the osascript can otherwise be adapted easily (eg. window may need to be changed to tab if that is your terminal default behavior, etc.). – Colbert

Is it possible to not let the Terminal window/tab close after .command script file has been ran despite the profile setting? – Pease

@CyberMew: If you can modify the script, add a command that waits for a keystroke at the end; e.g., if it's a bash script, add read -p 'Press Return to close this window.' as the last statement. – Equidistant

Is there a way to make the window of the .command not to close? I mean I want to create a .command file which when executed opens a terminal with pre defined PATH variable. – Arabia

@Royi: In your .command file, first set up PATH as desired, then invoke bash - without arguments - to start an interactive session that will keep the window open. – Equidistant

@Royi: Make sure that your .command file has a valid shebang line (e.g., #!/bin/bash); if it still doesn't work, please create a new question with an MCVE (Minimal, Complete, and Verifiable Example); feel free to ping me here once you have done so. – Equidistant

@mklement0, Have a look at apple.stackexchange.com/questions/335608. Thank You. – Arabia

Answer 4

Alternatively, you could create a regular Mac OS X application from your script using Platypus

Lodi

This is a really great app. But I have some problem here. I have a python script that I want to convert into an .app file. My script includes a line where the user has to type some input (raw_input()), when the .app reaches this line of code, it throws an EOF (end of file) error. What can I do about it? – Barbershop

It's not an interactive terminal. Platypus merely presents script output. There's no bidirectional communication. – Lodi

Or create an OS X application with Automator using the Run Shell Script action. – Pandarus

Answer 5

The easy way is to change the extension to .command or no extension.

But that will open the Terminal, and you will have to close it. If you don't want to see any output, you can use Automator to create a Mac Application that you can double click, add to the dock, etc.

1. Open Automator application
2. Choose "Application" type
3. Type "run" in the Actions search box
4. Double click "Run Shell Script"
5. Click the Run button in upper right corner to test it.
6. File > Save to create the Application.

Glaciology

Great ! How can we automate this workflow to run daily at 1 PM ? – Mithridate

or you can do 3rd step in this article after changing the extension to .commandhttps://medium.com/@nooneypradeep/double-click-to-execute-a-shell-script-in-mac-os-monterey-3-steps-2f6f80939f48 – Kimkimball

Make sure you change the file format to "Application"; otherwise you'll get a "Workflow" which will just open up Automator. – Haemostatic

Answer 6

No need to use third-party apps such as Platypus.

Just create an Apple Script with Script Editor and use the command do shell script "shell commands" for direct command calls or executable shell script files, keep the editable script file safe somewhere then export it to create an Application script. the app script is launch-able by double click or selection in bar folder.

Acuity

Even better, use Automator and use the Run Shell Script action directly rather than going through Apple Script. – Pandarus

Answer 7

You can also set defaults by file extension using RCDefaultApp:

http://www.rubicode.com/Software/RCDefaultApp/

potentially you could set .sh to open in iTerm/Terminal etc. it would need user execute permissions, eg

chmod u+x filename.sh

Classified

Answer 8

chmod 774 filename

Note: The file with name 'filename' that has the bash script has no extension

Central