Learn Enough Command Line to be Dangerous! + ZSH

/ SprUng / 23 minutes of reading

https://make.wordpress.org/cli/handbook/

https://www.learnenough.com/command-line-tutorial/basics

SSH Command Explanation
ls Show directory contents (list the names of files).
cd Change Directory.
mkdir Create a new folder (directory).
touch Create a new file.
rm Remove a file.
cat Show contents of a file.
pwd Show current directory (full path to where you are right now).
cp Copy file/folder.
mv Move file/folder.
grep Search for a specific phrase in file/lines.
find Search files and directories.
vi/nano Text editors.
history Show last 50 used commands.
clear Clear the terminal screen.
tar Create & Unpack compressed archives.
wget Download files from the internet.
du Get file size.

# Shawn Cheaters #

https://www.ssh.com/ssh/command

ssh wpadmin@10.11.80.99

EVERYTHING – needs sudo before it

**SSH Command** **Explanation**

ls Show directory contents (list the names of files).
cd Change Directory.
mkdir Create a new folder (directory).
touch Create a new file.
rm Remove a file.
cat Show contents of a file.
pwd Show current directory (full path to where you are right now).
cp Copy file/folder.
mv Move file/folder.
grep Search for a specific phrase in file/lines.
find Search files and directories.
vi/nano Text editors.
history Show last 50 used commands.
clear Clear the terminal screen.
tar Create & Unpack compressed archives.
wget Download files from the internet.
du Get file size.

### EDITING:: ###

[server]$ vim test.html

Click the letter ‘i’ on your keyboard to enter INSERT mode in ‘vim’.

Start typing into the file.
When finished editing the file, click the ESC key.
This takes you out of INSERT mode and — INSERT — disappears from the bottom left of your terminal.

To save the file, type in a colon followed by wq.

:wq

### Download from server to local ###

scp -r user@host:/path/to/folder/ local-copy-of-folder

# Cheatsheet for SSH & Linux Shell commands

MASSMEDIUMS02 July 2015

Let’s face it, SSH is one of the most important tools any good web developer has. If efficiency is important to you (as it should be), SSH should be your primary means of interacting with your servers, whether working locally or on a remote server. Linux Shell commands allow you to quickly and easily perform system-wide tasks such as installing & updating software, executing GIT commands, site deployment , etc. SSH allows you to remotely connect to your server and command it via the shell. This page designed to help beginners starting out with SSH, by providing a usable SSH cheatsheet of common commands you will use commonly while working with your server.

## Basic SSH Commands

`ls` : list files/directories in a directory.
`ls -al` : shows all files including hidden files, directories and details for each file.

`cd` : change directory
`cd /path/to/directory` : go to /path/to/directory
`cd ~` : go to your home directory
`cd -` : go to the last directory you were in
`cd ..` : go up a directory

`cat` : print file contents to the screen
`cat filename.txt` : cat the contents of filename.txt to your screen

`tail` : like cat, but only reads the end of the file
`tail /var/log/messages` : see the last 20 (by default) lines of /var/log/messages
`tail -f /var/log/messages` : watch the file continuously, while it’s being updated
`tail -200 /var/log/messages` : print the last 200 lines of the file to the screen

`more` : like cat, but opens the file one screen at a time rather than all at once
`more /etc/userdomains` : browse through the userdomains file.

**more** : hit space to go to the next page, q to quit

### File Editing via SSH commands

`pico` : friendly, easy to use file editor
`pico /home/burst/public_html/index.html` : edit the index page for the user’s website.

`vi` : another editor, tons of features
`vi /home/burst/public_html/index.html` : edit the index page for the user’s website.

`grep` : looks for patterns in files
`grep root /etc/passwd` : shows all matches of root in /etc/passwd
`grep -v root /etc/passwd` : shows all lines that do not match root

`touch` : create an empty file
`touch /home/burst/public_html/404.html` : create an empty file called 404.html in the directory /home/burst/public_html/

`rm` : delete a file
`rm filename.txt` : deletes filename.txt, will more than likely ask if you really want to delete it
`rm -f filename.txt` : deletes filename.txt, will not ask for confirmation before deleting.
`rm -rf tmp/` : recursively deletes the directory tmp, and all files in it, including subdirectories.

Use extreme caution with rm. important content can be deleted that can never be recovered.

`cp` : copy a file
`cp sample sample.backup` : copies sample to sample.backup
`cp -a /home/backup/* /home/public_html/` : copies all files ∓ permissions to another directory.
`find * -type d|xargs -i cp –verbose php.ini {}` : copies php.ini into all directories recursively.

`wc` : word count
`wc -l filename.txt` : tells how many lines are in filename.txt

`last` : shows who logged in and when
`last -20` : shows only the last 20 logins
`last -20 -a` : shows last 20 logins, with the hostname in the last field

`ln` : create’s “links” between files and directories
`ln -s /home/username/tmp/webalizer webstats` : Now you can display http://www.yourdomain.com/webstats to show your webalizer stats online.

**ln** : you can delete the symlink (webstats) and it will not delete the original stats on the server

### Permissions and Ownership via SSH

`chmod:` changes file access permissions (USER – GROUP – EVERYONE)

“`
0 = — No permission
1 = –X Execute only
2 = -W- Write only
3 = -WX Write and execute
4 = R– Read only
5 = R-X Read and execute
6 = RW- Read and write
7 = RWX Read, write and execute

“`

`chmod 000` : No one can access
`chmod 644` : Usually for files, such as HTML, PHP
`chmod 755` : Usually for Directories and CGI scripts

`chown` : changes file ownership permissions (USER – GROUP)
`chown root myfile.txt` : Changes the owner of the file to root
`chown root.root myfile.txt` : Changes the owner and group of the file to root
`netstat -an` : shows all connections to the server, the source and destination ips and ports.
`netstat -rn` : shows routing table for all ips bound to the server.

`top` : shows live system processes in a nice table, memory information, uptime and other useful info.
`top Shift + M` : sort by memory usage
`top Shift + P` : sort by CPU usage/p>

`ps` : ps is short for process status. It’s used to show currently running processes and their PID.
`ps U username` : shows processes for a certain user
`ps aux` : shows all system processes
`ps aux –forest` : shows all system processes but organizes into a very useful hierarchy

`file` : attempts to guess what type of file a file is by looking at it’s content.
`file *` : prints out a list of all files/directories in a directory

`du` : shows disk usage.
`du -sh` : shows readable summary of total disk space used in current directory, including subdirectories.
`du -sh *` : same thing, but for each file and directory. helpful when finding large files taking up space.

`kill` : terminate a system process
`kill -9 PID EG` : kill -9 431
`kill PID EG` : kill 10550

## Copying & Moving Files via SSH

Often you will need to move one or more files/folders or copy them to a different location. You can do so easily using an SSH connection. The commands which you would need to use are `mv` (short for ‘move’) and `cp` (short for ‘copy’).

The mv command syntax looks like this:

“`
mv configuration.php-dist configuration.php

“`

By issuing the above command we will move (rename) the file configuration.php-dist to configuration.php.

You can also use mv to move a whole directory and its content:

“`
mv includes/* ./

“`

This will move all files (and folders) in the includes/ directory to the current working directory.

In some cases however, we will need to only update the files and move only files that were changed, which we can do by passing ‘-u’ as argument to the command:

“`
mv -u includes/* admin/includes

“`

The copy `cp` command works the same way as `mv`, but instead of moving the files/folders it copies them. For example:

“`
cp configuration.php-dist configuration.php

“`

The command will copy the `configuration.php-dist` file to `configuration.php` and will preserve the original file (the file will NOT be removed after it is copied).

`cp` also accepts various arguments:

“`
cp -R includes/ includes_backup/

“`

`-R` instructs `cp` to copy files recursively (for example, a whole directory). To overwrite already existing files you should use the `-f` argument:

“`
cp -Rf includes/ admin/includes/

“`

## Putting SSH Commands Together

Often you will find you need to use different commands on the same line. Here are some examples. Note that the `|` character is called a pipe, it takes date from one program and pipes it to another.
`>` : means create a new file, overwriting any content already there.
`>>` : means tp append data to a file, creating a newone if it doesn not already exist.
`<` : send input from a file back into a command.

“`
grep User /usr/local/apache/conf/httpd.conf | more

“`

This will dump all lines that match User from the httpd.conf, then print the results to your screen one page at a time.

“`
last -a > /root/lastlogins.tmp

“`

This will print all the current login history to a file called lastlogins.tmp in /root/

“`
tail -10000 /var/log/exim_mainlog | grep domain.com | more

“`

This will grab the last 10,000 lines from /var/log/exim_mainlog, find all occurances of domain.com

(the period represents ‘anything’, comment it out with a so it will be interpretted literally), then send it to your screen page by page.

“`
netstat -an | grep :80 | wc -l

“`

Show how many active connections there are to apache (httpd runs on port 80)

“`
mysqladmin processlist | wc -l

“`

Show how many current open connections there are to mysql

“`
mysqldump -u username -p dbname > file.sql

“`

MySQL Dump

“`
mysql -u username -p database_name “`

Importing MySQL database

“`
tar -zxvf file.tar.gz

“`

UnTAR file

## **Manage MySQL Database**

Another good technique to learn is how to manage your MySQL databases. There will be a time when your MySQL tables may go down, get corrupted, and needs to be repaired.

You can repair MySQL tables with [phpMyAdmin](https://www.phpmyadmin.net/). But there have been better success rates when repairing them through SSH.

The reason is when repairing it through a client side GUI. Visitors can still try to access your table while you are trying to repair it. In an SSH environment, you can deny visitors while you repair.

**MySQL Commands**

To login into your MySQL database use the following commands:

mysql -u username -ppassword

You need to put the -u space username space -p then password. If entered correctly it will bring into the MySQL status. Now choose your database using:

use database;

This should get you in where you can use your standard MySQL queries. Like show tables, select, insert, and repair.

Remember to end everything with a “;”.

## Creating a new pair of keys

Before working with SSH, you need to create a new pair of keys. Basically it is a pair of private/public keys. **To generate a new key pair on your computer**, run:

“`bash
$ ssh-keygen

“`

keys are created in `~/.ssh` directory. Two files will be created:

“`bash
➜ $ cd ~/.ssh
➜ $ ls -al
-rw——- 1 musikele musikele 1,8K feb 18 21:56 id_rsa
-rw-r–r– 1 musikele musikele 411 feb 18 21:56 id_rsa.pub

➜ $
“`

The private key is `id_rsa` and you should never share it with anybody. It is readable and writable only by the current user.

The public key is `id_rsa.pub` and it can be shared with others. As you can see the `id_rsa.pub` is also readable by anyone on the system.

## Set up SSH login to remote server without password

Now that we have SSH set up on our computer, let’s see how we can login to a remote server. (We assume that ssh is set up on the remote server too – if not, just lunch the previous command there too!).

There are two ways to log in to a remote server:

– by typing the remote user’s password,
– by using your private/public key.

We will talk about the second option from now on.

What we want to do now is to register our public key on the server. I want to remain practical in this article, but if you need some deep explanation of what happens during the login process I suggest you to [follow this link](https://www.digitalocean.com/community/tutorials/understanding-the-ssh-encryption-and-connection-process).

There’s a simple command to set up the ssh key on a remote server (run on your local computer):

“`bash
$ ssh-copy-id root@123.123.123.123

“`

once you hit enter, the remote server will ask for the password (at least for the first time). Once done, you can log in to a remote server by typing

“`bash
$ ssh root@123.123.123.123

“`

…and you’re in!

What is this command `ssh-copy-id` doing? This command will copy your public key (`~/.ssh/id_rsa.pub`) in the remote file `~/.ssh/authenticated_keys`. The server will use the your public key to authenticate you.

## Logging in as a different user

When we log in to a remote server, without using a username, we will log in with the same username of our local machine. My username is `musikele`, so if I try to login to a remote server that’s what happens:

“`bash
$ ssh 123.123.123.123
musikele@123.123.123.123’s password:

“`

… but if you’re logging in to a corporate machine you don’t have a user set up with your username. So we prefix the host address with the remote user, like this:

“`bash
$ ssh remote_user@123.123.123.123

“`

Other useful options:

– `-p 2222` is used to specify the port to use. Default port for SSH is 22.
– `-i /path/to/alternate/key` is used to speficy another *private* key you want to use instead of the default one. You can have as many public/private keys you want, and they an be in different files or in different paths.
– `-f` runs ssh in the background (you’ll see later when to use it)
– `-N` does not open a window.

to run only one command and exit, simply write the command after the ssh connection string:

“`bash
$ ssh -p 2222 remote_user@123.123.123.123 ls -al
drwxrwxrwx+ 3 root root 4096 Apr 3 10:02 #recycle
drwxr-xr-x 31 admin users 4096 Mar 13 07:41 .
drwxrwxrwx+ 13 root root 4096 Feb 6 09:54 ..
-rwxrwxrwx+ 1 admin users 14340 Jun 18 2017 .DS_Store

…
$

“`

We just lunched `ls -al` on a remote machine! (and the prompt at line 7 is our local prompt, again).

## Simplify connections with ssh config files

It may be tedious to write the same info (username, remote server address, port…) again and again. With ssh we can define an alias with some informations already set, so that we don’t have to type them again and again. Here’s an example:

“`bash
$ vi ~/.ssh/config
# use four spaces to indent
Host foo
Hostname 123.123.123.123
User root
IdentityFile ~/.ssh/id_rsa
Port 22

“`

And then we just log in with

“`bash
$ ssh foo
“`

This is a real time saver tip 😉

## Copy files to and from the remote host

One of the most common actions we want to do with our remote servers is to copy files from and to it. The handy command **scp** will help us doing this.

To transfer a file from local host to a remote one:

“`bash
scp bar.txt mark@123.123.123.123:~/

“`

Here we are coping `bar.txt` file on the server, logging in as user `mark`.

Whatever is after the `:` is the path on the remote server. If the path starts with `/` it is an absolute path; otherwise it will be local to the user’s home folder.

Some other handy options for this command are:

– `-P` for the port (note that for the regular ssh we used `-p` lowercase)
– `-r` for a recursive copy of a folder

And of course, if you want to copy from a remote host to your local pc:

“`bash
scp mark@123.123.123.123:~/bar.txt ./new.txt

“`

## Configure a ssh tunnel

With *tunneling* you can redirect traffic from one port of an ssh host to a remote server.

Let’s see an easy example:

“`bash
ssh -L 8000:yahoo.com:80 mark@myhost.com

“`

In this case:

– your computer will listen on port `localhost:8000`
– when a packet is sent at `localhost:8000` it will reach `myhost.com`
– ssh daemon at `myhost.com` will redirect to `yahoo.com:80`
– responses follow the same path.

This technique can be useful to access a server on a private network. The only problem is that we also log in to `myhost.com` and the connection stays open until we exit from the remote session.

Combining with options `-f -N` , we run the tunnel and return to the localhost computer:

“`bashV
ssh -f -N -L 8000:yahoo.com:80 mark@myhost.com

“`

Another great use for tunneling is to redirect traffic from the ssh server to your local host. Imagine to hit `myhost.com:8000` but the traffic is redirected to `localhost:3000`. This is useful for debugging, or to set up proxies, etc.

Remote tunneling is disabled by default; to enable, open the config file:

“`
$ vi etc/ssh/sshd_config

“`

set `GatewayPorts` option to `yes` and restart the service (for example with `service ssh restart` on Debian/Ubuntu systems).

Now we can explore the tunneling functionality by launching:

“`bash
ssh -R 8000:localhost:3000 mark@myhost.com

“`

What’s happening here:

– port `8000` on server `myhost.com` is exposed (be sure that it’s reachable, for example by setting port forwarding on gateways if you have)
– when you connect to port `myhost.com:8000` the data is sent to `localhost:3000`
– eventual responses will flow back on the same route.

## Escape sequences

– To stop a blocked ssh connection hit “ then write: `~.` (tilde fullstop).
– Another escape sequence is `~ CTRL-Z` (tilde character + CTRL + Z). The ssh connection will be moved to background. To resume, type `fg`. Remember to hit “ if you have written anything before.

## Verify SSH fingerprints

When you connect to a new machine, a new entry is created in the local file `~/.ssh/known_hosts` of your computer. This entry contains the fingerprint of the server, so next time it will be already trusted.

However, sometimes keys on remote servers will change and our machine will not be able to connect again.

In order to check the new fingerprint of a remote server:

– connect to the remote server (e.g. `ssh root@123.123.123.123`) with password
– on remote host, launch:

“`bash
$ ssh-keygen -l -f /etc/ssh/ssh_host_ecdsa_key.pub

“`

The output of the command is the fingerprint of the key.

– on localhost, launch:

“`bash
$ ssh-keygen -R 123.123.123.123

“`

This will remove the line associated with `123.123.123.123` in the `~/.ssh/known_hosts` file.

– finally, connect again to the remote server:

“`bash
$ ssh root@123.123.123.123

“`

The remote host will show its fingerprint, and it should match the one calculated before.

## Other cool SSH options

### Deny any root access

You can imagine why a ssh connection for the root account can be a bad thing. Fortunately It can be disabled.

– launch `vi /etc/ssh/sshd_config`. This file contains a bunch of options for ssh.
– Search for `PermitRootLogin` and set to `no` to avoid root login.

### Prohibit password access

Another value for this setting is `prohibit-password`. This way you can only connect via public/private key. You can disable password authentication by setting `PasswordAuthentication` option to `no`.

If you want to accept connections only for a specific set of users, or only users that come from a specific IP, you can set `AllowUsers` option like this:

“`
AllowUsers foo bar@1.2.3.4 *@2.3.4.5

“`

Remember to restart the server with `service ssh restart`.

## Monitoring connection attempts

To check malicious/suspicious activity we have some tools that come at help.

– `vi /var/log/auth.log` contains all the informations about who tried to log in the system, with other info like the IP, etc.
– command `lastlog` will show last logs from all users of the system.
– `lastlog -u mark` will display last logs for user `mark`.

For example, we may see that our employee `mark` is connecting to the server, but at strange hours. So we can ask mark to `cat ~/bash_history` and check his latest commands. We can use this info to check if he legitimately accessed the machine, or if it was a hacker.

About bash_profile and bashrc on macOS

Note: bash_profile is completely different from configuration profiles. Learn more about Configuration Profiles in my book: ‘Property Lists, Preferences and Profiles for Apple Administrators’

Note: please consider supporting the author of this site by purchasing one of my books! Thank you!

In this spontaneous series on the macOS Terminal I have often mentioned adding something as an alias or function to your bash_profile or bashrc. Obviously, you may wonder: how do I do that? And which file should I use?

Why?

When you work with the command line and the bash shell frequently, you will want to customize the environment. This can mean changing environment variables, such as where the shell looks for commands or how the prompt looks, or adding customized commands.

For example, macOS sets the PATH environment variable to /usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin by default. This is a list of directories (separated by a colon ‘:’) that the system searches through in order for commands. I like to add a folder in my home directory ~/bin to that list, so that I can execute certain tools without needing to type out the full path. (e.g. munkipkg, quickpkg and ssh-installer).

In bash you append to existing PATH do this with:

export PATH="$PATH:~/bin"

You could type this command every time you open a new Terminal window (i.e. shell), or you can configure your shell to do this automatically.

Depending on which shell you use and how you start the shell, then certain script files will be executed which allow you to set up these customizations.

This article will talk about customizing bash on macOS. Other shells and other operating systems may have other files or rules.

So, which file?

Thanks to the rich and long history of bash the answer to which file you should put your configuration in, is surprisingly confusing.

There are (mainly) two user level files which bash may run when a bash shell starts. ~/.bash_profile or ~/.bashrc.

Both these files are on the first level of your home directory ~/. Since the file names start with a . Finder and normal ls will not show them. You need to use ls -a to see if they are present. Read more about invisible and hidden files here.

The usual convention is that .bash_profile will be executed at login shells, i.e. interactive shells where you login with your user name and password at the beginning. When you ssh into a remote host, it will ask you for user name and password (or some other authentication) to log in, so it is a login shell.

When you open a terminal application, it does not ask for login. You will just get a command prompt. In other versions of Unix or Linux, this will not run the .bash_profile but a different file .bashrc. The underlying idea is that the .bash_profile should be run only once when you login, and the .bashrc for every new interactive shell.

However, Terminal.app on macOS, does not follow this convention. When Terminal.app opens a new window, it will run .bash_profile. Not, as users familiar with other Unix systems would expect, .bashrc.

Note: The Xterm application installed as part of Xquartz runs .bashrc when a new window opens, not .bash_profile. Other third-party terminal applications on macOS may follow the precedent set by Terminal.app or not.

This is all very confusing.

There are two main approaches:

  • When you are living mostly or exclusively on macOS and the Terminal.app, you can create a .bash_profile, ignore all the special cases and be happy.
  • If you want to have an approach that is more resilient to other terminal applications and might work (at least partly) across Unix/Linux platforms, put your configuration code in .bashrc and source .bashrc from .bash_profile with the following code in .bash_profile:
if [ -r ~/.bashrc ]; then
   source ~/.bashrc
fi

The if [ -r ... ] tests wether a file exists and is readable and the source command reads and evaluates a file in place. Sometimes you see

[ -r ~/.bashrc ] && . ~/.bashrc

(mind the spaces) Which is a shorter way to do the same thing.

Since either file can drastically change your environment, you want to restrict access to just you:

$ chmod 700 ~/.bash_profile
$ chmod 700 ~/.bashrc

That was confusing. Is that all?

No. There are more files which may be executed when a shell is created.

When bash cannot find .bash_profile it will look for .bash_login and if that does not exist either .profile. If .bash_profile is present the succeeding files will be ignored. (though you can source them in your .bash_profile)

There is also a file /etc/profile that is run for interactive login shells (and Terminal.app). This provides a central location to configure the shells for all users on a system. On macOS /etc/profilesets the default PATH with the path_helper tool and then sources /etc/bashrc which (you guessed) would be the central file for all users that is executed for non-login interactive shells. For macOS Terminal.app /etc/bashrc sets the default prompt and then itself sources /etc/bashrc_Apple_Terminal which sets up the session persistence across logins.

So in macOS Terminal.app, before you even see a prompt, these scripts will be run:

  • /etc/profile
    • /etc/bashrc
      • /etc/bashrc_Apple_Terminal
  • if it exists: ~/.bash_profile
    • when ~/.bash_profile does not exists, ~/.bash_login
    • when neither ~/.bash_profile nor ~/.bash_login exist, ~/.profile
  • ~/bash_profile can optionally source ~/.bashrc

There is also a file ~/.inputrc, where you can setup certain command line input options. One common example for this is to enable case-insensitive tab-completion. You can find a list of more options here.

Finally, there is ~/.bash_logout which is run when a shell exits or closes.

Ok, so I have the file, now what?

Whichever file you choose, (I went with option one and have everything in .bash_profile) now you want to put stuff in it.

Technically this is a script, so you can do anything you can code in bash. However, usually the contents of a .bash_profile or .bashrc fall into one of three categories:

I will show some examples for each in the next post!

https://www.freecodecamp.org/news/how-to-configure-your-macos-terminal-with-zsh-like-a-pro-c0ab3f3c1156/

# If you come from bash you might have to change your $PATH.
# export PATH=$HOME/bin:/usr/local/bin:$PATH

# Path to your oh-my-zsh installation.
export ZSH=”/Users/shawnpalmer/.oh-my-zsh”

# Set name of the theme to load — if set to “random”, it will
# load a random theme each time oh-my-zsh is loaded, in which case,
# to know which specific one was loaded, run: echo $RANDOM_THEME
# See https://github.com/ohmyzsh/ohmyzsh/wiki/Themes
ZSH_THEME=”robbyrussell”

# Set list of themes to pick from when loading at random
# Setting this variable when ZSH_THEME=random will cause zsh to load
# a theme from this variable instead of looking in ~/.oh-my-zsh/themes/
# If set to an empty array, this variable will have no effect.
# ZSH_THEME_RANDOM_CANDIDATES=( “robbyrussell” “agnoster” )

# Uncomment the following line to use case-sensitive completion.
# CASE_SENSITIVE=”true”

# Uncomment the following line to use hyphen-insensitive completion.
# Case-sensitive completion must be off. _ and – will be interchangeable.
# HYPHEN_INSENSITIVE=”true”

# Uncomment the following line to disable bi-weekly auto-update checks.
# DISABLE_AUTO_UPDATE=”true”

# Uncomment the following line to automatically update without prompting.
# DISABLE_UPDATE_PROMPT=”true”

# Uncomment the following line to change how often to auto-update (in days).
# export UPDATE_ZSH_DAYS=13

# Uncomment the following line if pasting URLs and other text is messed up.
# DISABLE_MAGIC_FUNCTIONS=true

# Uncomment the following line to disable colors in ls.
# DISABLE_LS_COLORS=”true”

# Uncomment the following line to disable auto-setting terminal title.
# DISABLE_AUTO_TITLE=”true”

# Uncomment the following line to enable command auto-correction.
# ENABLE_CORRECTION=”true”

# Uncomment the following line to display red dots whilst waiting for completion.
# COMPLETION_WAITING_DOTS=”true”

# Uncomment the following line if you want to disable marking untracked files
# under VCS as dirty. This makes repository status check for large repositories
# much, much faster.
# DISABLE_UNTRACKED_FILES_DIRTY=”true”

# Uncomment the following line if you want to change the command execution time
# stamp shown in the history command output.
# You can set one of the optional three formats:
# “mm/dd/yyyy”|”dd.mm.yyyy”|”yyyy-mm-dd”
# or set a custom format using the strftime function format specifications,
# see ‘man strftime’ for details.
# HIST_STAMPS=”mm/dd/yyyy”

# Would you like to use another custom folder than $ZSH/custom?
# ZSH_CUSTOM=/path/to/new-custom-folder

# Which plugins would you like to load?
# Standard plugins can be found in ~/.oh-my-zsh/plugins/*
# Custom plugins may be added to ~/.oh-my-zsh/custom/plugins/
# Example format: plugins=(rails git textmate ruby lighthouse)
# Add wisely, as too many plugins slow down shell startup.
plugins=(git)

source $ZSH/oh-my-zsh.sh

# User configuration

# export MANPATH=”/usr/local/man:$MANPATH”

# You may need to manually set your language environment
# export LANG=en_US.UTF-8

Scroll to Top