On first connect to a server, this sync all the dotfiles i want to a remote host and on subsequent connects, it updates the dotfiles.

Idk if this is "special", but I haven't seen anyone else do this really and it beats for example ansible playbooks by being dead simple.

   Match Host 192.168.123.*,another-example.org,*.example.com User myusername,myotherusername
      ForwardAgent yes
      PermitLocalCommand yes
      LocalCommand rsync -L --exclude .netrwhist --exclude .git --exclude .config/iterm2/AppSupport/ --exclude .vim/bundle/youcompleteme/ -vRrlptze "ssh -o PermitLocalCommand=no" %d/./.screenrc %d/./.gitignore %d/./.bash_profile %d/./.ssh/git_ed25519.pub %d/./.ssh/authorized_keys %d/./.vimrc %d/./.zshrc %d/./.config/iterm2/ %d/./.vim/ %d/./bin/ %d/./.bash/ %r@%n:/home/%r

What a shame!

I owe you a beer at least

I'm not crying, you are crying!

    apt-get update; apt-get install -y tmux git ncdu psmisc iproute2 net-tools curl zsh vim; curl -Ls install.ohmyz.sh | sh; chsh -s $(which zsh); exec zsh

    Match host 10400 exec "timeout 1 nc -z 192.168.1.101 22 2>/dev/null"
        Hostname 192.168.1.101
        Port 22

    Host 10400
        Hostname myhost.duckdns.org
        Port 564

Also: This will be great to combine with chezmoi for bootstrapping workstations - allowing you to do host-specific configuration, templating, and basic secrets injection without fiddling around with USB drives or whatnot.

Command help, inspired by http://explainshell.com/ to extract help text from builtin commands and man pages. Here's an example:

    $ ch ls -AXG
           ls - list directory contents

           -A, --almost-all
                  do not list implied . and ..

           -X     sort alphabetically by entry extension

           -G, --no-group
                  in a long listing, don't print group names

https://github.com/learnbyexample/regexp-cut/blob/main/rcut is another - uses awk to provide cut like syntax for field extraction. After writing this, I found commands like `hck`, `tuc` written in Rust that solves most of the things I wanted.

https://github.com/tpapastylianou/misc-updater

In full honesty, I'm as proud of the "MISC" acronym as of the script itself. :p

I'm secretly hoping the acronym catches on for referring to any stuff outside the control of a system's standard package management.

E.g., you may note that one of the packages the script checks for is zoom. Zoom is installed as a normal .deb file that I download from the zoom website, and install manually using dpkg, which installs it in the normal system directories. But it has its own cumbersome update check mechanism (which involves clicking a menu in the app), and is not picked up by apt-update because it's not a repo package. So this makes it a good candidate for a misc-updates check, even though it's installed as a normal .deb file. :)

What surprises me is that there seems to be no other way than hacking (cutting, grepping, etc.) each package separately. I wonder how this is handled in machines that use a lot of MISC packages (other than pulling+building every time to automatically have the latest version)?

Also, kudos on the acronym :)

I eventually got tired of writing that manually, so I wrote a small

  git co-commit --thor ...

Placing it in e.g. ~/bin/git-co-commit and having ~/bin in your $PATH will enable it as a git sub-command.

I've never had a use for this before, and I don't think I'll need it much beyond this team, but this was my first git sub-command that wasn't trivially solvable by existing command parameters (that I know of).

https://gist.github.com/sshine/d5a2986a6fc377b440bc8aa096037...

https://blog.sebastian-daschner.com/entries/custom-git-subco...

Many "built-in" Git commands are themselves separate executables. My Linux machine has them in `/usr/lib/git-core/`, and my macOS machine has them in `/Applications/Xcode.app/Contents/Developer/usr/libexec/git-core/`.

  !/bin/zsh

  alias git_my_branches="git for-each-ref --sort=committerdate refs/heads/ --format='%(HEAD) %(color:yellow)%(refname:short)%(color:reset) - %(color:red)%(objectname:short)%(color:reset) - %(contents:subject) - %(authorname) (%(color:green)%(committerdate:relative)%(color:reset))'"

  local selected_branch=$(git_my_branches --color | fzf --ansi --tac | awk '{print $1}')
  if [ "$selected_branch" != '*' ]; then
          git checkout $selected_branch
  fi

    [user@user ~]# cat > ~/bin/git-test-me <<'EOF'
    #!/bin/bash
    
    echo hi
    EOF
    [user@user ~]# chmod +x ~/bin/git-test-me
    [user@user ~]# git test-me
    hi

Many Linux tools do this. Rust's cargo is another.

In fact, `man` itself can take multiple positional arguments and will concatenate them with a hyphen to perform the lookup.

You configure a ~/.git-authors file with people with whom you regularly pair, and use `git duet [author-1] [author-2]` to set primary and secondary commit authors. Env variables set whether you want `Signed-off-by` or `Co-authored-by` trailers.

There seems to be at least these three advantages over my approach:

  - `git duet` has neat syntax for attributing more than two people.
  - `git duet` lets me enter a mode where it keeps attributing my co-authors.
  - `git duet` keeps the authors in a separata data file, not in the script.

    zstyle ':completion:*:*:git:*' user-commands ${${(M)${(k)commands}:#git-*}/git-/}

    zstyle ':completion:*:*:git:*' user-commands foo:'description for foo'

My .gitconfig has:

  [pretty]
  co-authored-by = Co-authored-by: %an <%ae>
  [alias]
  co-authored-by = log -1 --pretty=co-authored-by --regexp-ignore-case --author

To the OP: You might be able to simplify the script by using `git commit --trailer …`. Or maybe you tried that and it didn't display the message in the editor window satisfactorily?

For some reason `--trailer` is not available on my system, so I'd need to upgrade git, it seems.

  ~LButton up::
    if (GetKeyState("CapsLock", "P")) {
      while(!GetKeyState("LButton", "P")){
        MouseClick, left
        sleep 20      
      } 
    }
    return

Also a bookmarklet that you use to turn any page dark with a click:

    javascript:document.querySelectorAll('\*').forEach(e=>e.setAttribute('style','background-color:#222;background-image:none;color:#'+(/^A|BU/.test(e.tagName)?'36c;':'eee;')+e.getAttribute('style')))

    ~^s::
        WinGetActiveTitle, currentWinTitle
            If InStr(currentWinTitle, "AutoHotkey.ahk - Notepad")
                Reload
        Return

    !3::Send {alt down}a{alt up}{Tab}{Tab}{Tab}{Tab}{Tab}{Tab}Position{Shift down}{Down}{Shift up}{Del}{Tab}{Tab}

- have something mildly repetitive to do, notice how to do parts of it with keyboard only.

- right click AutoHotkey icon in taskbar, edit (opens Notepad).

- change some of these automations, alt+1, alt+2, alt+3, ...

- press ctrl+s to save and reload.

- switch back to the program and use the hotkey immediately to begin helping.

- repeat switching to AutoHotkey and the program, tweaking and adding more.

It's amenable to the kind of occasional task which has no easy proper automation, or is a one-off and isn't worth more time to do it through proper interfaces. Things like a vendor support telling you to "go through every affected record and toggle X field off and on again".

  <!k::Send {Up}
  <!j::Send {Down}
  Capslock::Esc

    #!/usr/bin/sh

    while true; do
        reset;
        "$@";
        inotifywait -e MODIFY --recursive .
    done

* entr(1) - http://eradman.com/entrproject/

* Watchexec - https://watchexec.github.io/

[0]https://github.com/cortesi/modd

# wait on a path and do something on change, e.g. `wait_do test/ run_tests.sh`

    wait_do() {
        local watch_file=${1}
        shift

        if [[ ! -e ${watch_file} ]]; then
            echo "${watch_file} does not exist!"
            return 1
        fi

        if [[ `uname` == 'Linux' ]] && ! command -v inotifywait &>/dev/null; then
            echo "inotifywait not found!"
            return 1
        elif [[ `uname` == 'Darwin' ]] && ! command -v fswatch &>/dev/null; then
            echo "fswatch not found, install via 'brew install fswatch'"
            return 1
        fi

        local exclude_list="(\.cargo-lock|\.coverage$|\.git|\.hypothesis|\.mypy_cache|\.pgconf*|\.pyc$|__pycache__|\.pytest_cache|\.log$|^tags$|./target*|\.tox|\.yaml$)"
        if [[ `uname` == 'Linux' ]]; then
            while inotifywait -re close_write --excludei ${exclude_list} ${watch_file}; do
                local start=$(\date +%s)
                echo "start:    $(date)"
                echo "exec:     ${@}"
                ${@}
                local stop=$(\date +%s)
                echo "finished: $(date) ($((${stop} - ${start})) seconds elapsed)"
            done
        elif [[ `uname` == 'Darwin' ]]; then
            fswatch --one-per-batch --recursive --exclude ${exclude_list} --extended --insensitive ${watch_file} | (
                while read -r modified_path; do
                    local start=$(\date +%s)
                    echo "changed:  ${modified_path}"
                    echo "start:    $(date)"
                    echo "exec:     ${@}"
                    ${@}
                    local stop=$(\date +%s)
                    echo "finished: $(date) ($((${stop} - ${start})) seconds elapsed)"
                done
            )
        fi
    }

    nevergonnagiveyouup() {
        false
        while [ $? -ne 0 ]; do
            ${@}

            if [ $? -ne 0 ]; then
                echo "[$(\date +%Y.%m.%d_%H%M)] FAIL: trying again in 60 seconds..."
                sleep 60
                false
            fi
        done
    }

So I use this script to give me a nice work environment, based on each day.

Every time you open bash, it'll drop you into today's directory. (~/work/year/month/day/)

When I think about stuff it's like.. oh yeah I worked on that last week, last year, etc - the folder structure makes this a lot easier, and you can just write 'notes' or 'meeting-with-joe' and you know the ref date.

For your bashrc:

  alias t='source /path/to/today'

  t

  # this is where you'll get dropped by default.

  calvin@bison:~/work/2022/07/10$

  calvin@bison:~/work/2022/07/10$ ls
  WardsPerlSimulator.pl

  calvin@bison:~/work/2022/07/10$ cd ..; ls;
  01  02  04  05  06  07  08  09  10
  calvin@bison:~/work/2022/07$ cd ..; ls
  01  02  03  04  05  06  07
 calvin@bison:~/work/2022$ cd ..; ls
  2021  2022

https://git.ceux.org/today.git/

Do you mean Nepomuk, that thing from KDE, which dead like 10+ years ago?

> Every time you open bash, it'll drop you into today's directory. (~/work/year/month/day/)

Ok, that's an interesting Idea, but isn't this more akin to Gnome Zeitgeist? When aimed Nepopmuk at journaling?

> https://git.ceux.org/today.git/

But where is the script? I only see the readme, no code for creating the folder.

Yeah. I mean I think the pitch when KDE4 launched was like... let's rethink how we deal with our files as less discrete paths and more like easily findable stuff.

> But where is the script? I only see the readme, no code for creating the folder.

whoops, I added it!

1. Preserve single newlines that people typed in: Often people hit Return only once, and their intended formatting becomes a wall of text. Hacker News preserves the newline in the HTML.

  .commtext {
    white-space: pre-wrap;
  }
  .commtext .reply {
    white-space: normal; /* fix extraneous whitespace caused by first rule */
  }

  .ind {
    background-image: repeating-linear-gradient(to right, transparent 0px 39px, rgba(204, 204, 204, 1.0) 39px 40px);
  }

https://github.com/dom111/dotfiles/blob/master/bin/git

which when combined with files like:

    $cat ~/.gitidentities/github.com 
    
    [user]
            name = dom111
            email = dom111@users.noreply.github.com

Also, not entirely related, but I wrote a small tool to add some animated GIFs to scripts: https://dom111.github.io/gif-to-ansi/

To use this alias, make an executable file called `git-recent` with the following contents and ensure it is in your `$PATH`

    git for-each-ref \
      --sort=-committerdate refs/heads/ \
      --format='%(HEAD) %(color:red)%(objectname:short)%(color:reset) %(color:yellow)%(refname:short)%(color:reset) - %(contents:subject) - %(authorname) (%(color:green)%(committerdate:relative)%(color:reset))'

    * fc924a7e68 team/name/feature-2 - save - My Name (4 days ago)
      2fed1acfac team/name/feature-1 - add test - My Name (3 weeks ago)
      4db4d4ac77 main - Remove changes (#22397) - My Name (6 weeks ago)

  # Branches
  2022-08-11 13:26:34 -0700 4 days ago    branch-1
  2022-07-13 07:49:36 -0700 5 weeks ago   branch-10
  2022-06-28 23:40:53 +0000 7 weeks ago   branch-8
  2022-06-28 22:47:31 +0000 7 weeks ago   main
  2022-06-28 19:24:10 +0000 7 weeks ago   branch-7
  # Stashes
  stash@{0}:Thu Aug 11 13:17:11 2022 -0700 WIP on branch-3: afa19e7444a Some changes based on morning sync
  stash@{1}:Tue Jul 26 13:25:37 2022 -0700 WIP on branch-5: bd6122e2dfa find() bugfix
  stash@{2}:Tue Jul 12 15:05:31 2022 -0700 WIP on branch-7: 1221d0640c5 linter

  recent() 
  { 
      echo -e "${PURPLE}# Branches${COLOR_END}";
      for k in $(git branch | perl -pe 's/^..(.*?)( ->.*)?$/\1/');
      do
          echo -e $(git show --pretty=format:"%Cgreen%ci %Cblue%cr%Creset " $k -- | head -n 1)\\\t$k;
      done | sort -r | head;
      _num_stashes=$(git stash list | wc -l | while read l; do echo "$l - 1"; done | bc);
      echo -e "${PURPLE}# Stashes${COLOR_END}";
      for i in $(seq 0 ${_num_stashes});
      do
          echo -en "${CYAN}stash@{${i}}:${GREEN}" && git show --format="%ad%Creset %s" stash@{$i} | head -n 1;
      done
  }

git alias:

  recent = "!f() { script -q /dev/null git for-each-ref --sort=-committerdate refs/heads/ --format='%(HEAD)%(color:yellow)%(refname:short)%(color:reset)|%(authordate:short)|%(color:red)%(objectname:short)%(color:reset)|%(subject) (%(color:green)%(committerdate:relative)%(color:reset))'|column -ts'|'; }; f"

  grecent() {
    local branch=$(git recent | fzf --ansi --no-multi --bind "q:abort")

    if [[ "$branch" = "" ]]; then
        echo "No branch selected."
        return
    fi

    local branch_name=$(echo "$branch" | awk '{print $1}')
    echo "git checkout $branch_name"
    git checkout "$branch_name"
  }

I made a CLI utility for automating certain operations I was doing all the time: rsync of sources (push or pull), db backup / rollback, copying the local db to the remote server or back, etc. The utility looked for a dotfile in the project directory to get things like the remote server address, remote project path, etc.

The tool served several purposes:

- Executing auxiliary tools (rsync, mysqldump, drush) with the right parameters, without requiring me to remember them.

- Storing (non-secret) information about the remote environment(s) in the project directory.

- Some dangerous operations (e.g. copying the local db to the remote server) were prohibited unless the dotfile explicitly enabled them. Some sites were only edited on dev and then pushed to production, but some had user data that should never be overwritten.

- When running rsync of sources the tool always did a dry-run first, and then required entering a randomly generated 4-letter code to execute them... so I would have to stop and think and didn't deploy by mistake.

This tool is too rough for sharing it with the general public... but I consider it one of my greatest professional achievements because it saved me a lot of mental effort and stress over the years, quite a bit of time, prevented me from shooting myself in the foot, and forced me to use proper workflows every time instead of winging it. It required a small investment of time and some foresight... but my philosophy is that my work should be to build tools to replace me, and that was a step in that direction.

I dream of doing freelance work (assuming this is what this was) and essentially automating 80% of the maintenance work. There's something just so neat about that to me.

    function ccd { mkdir -p "$1" && cd "$1" }

(Lots of us don't use OMZ)

DRY is a good guideline but a rubbish rule.

https://github.com/NARKOZ/hacker-scripts

For example, I have one script that uses rumps to show how many outdated homebrew packages I have (and also as a convenient shortcut to update those packages in the dropdown menu). I also have a second script that uses it to show a counter for open pull requests that I need to review (with links to individual PRs in the dropdown menu). It's great!

Result looks like this: https://imgur.com/yy6GlYk.jpg

My examples: https://imgur.com/a/SrjG1xe

I basically do all my local management from there, no need to run scripts manually, no need to click around in Finder manually, I even added a command to quickly copy my email, simply because it is so low friction to do it.

Hands down the best tool I've ever used

     git-move src/afile.c src/bfile.c src/cfile.c ../destination/repo

function go() {

    let line = document.querySelector('#statementLines .line');

    if (line) {

        let leftAndRight = line.querySelectorAll('.statement');

        let left = leftAndRight[0];
        let right = leftAndRight[1];

        if (right.hasClassName('matched')) {

            let leftDetails = left.querySelectorAll('.info .details-container .details span');
            let leftDate = leftDetails[0].textContent;
            let leftReference = leftDetails[1].textContent;

            let rightDetails = right.querySelectorAll('.info .details-container .details span');
            let rightDate = rightDetails[0].textContent;
            let rightReference = rightDetails[2].textContent;

            rightReference = rightReference.replace('Ref: ', '');

            if (Date.parse(leftDate).getTime() == Date.parse(rightDate).getTime() && leftReference.toLowerCase() == rightReference.toLowerCase()) {


                var okButton = line.querySelector(".ok .okayButton");

                console.log(leftReference);

                okButton.click();

                var waiter = function () {

                    if (line.parentNode == null) {

                        go();

                    }
                    else {
                        setTimeout(waiter, 50);
                    }


                };

                setTimeout(waiter, 50);



            }
            else {
                console.log("Details dont match");
            }


        }
        else {
            console.log("Line not matched");
        }

    }
    else {
        console.log("No line found");
    }

setTimeout(go, 100);

There are several different plaintext accounting tools, but they all support automation like this. I personally use Beancount because I work best in Python.

The other huge advantage is that the "state" of your finances isn't opaque like in Xero. If you realize you've been categorizing certain transactions incorrectly in Xero, it's a hassle to navigate Xero's interface to correct everything, whereas in plaintext accounting it's usually a 2-second find/replace.

The downside is that there's a steep learning curve and the documentation is kind of overwhelming, but once you learn it, it's extremely valuable.

[0] https://plaintextaccounting.org/

BUT, this thread is so special because it feels like this is the stuff you only get to see when you sit down at a co-worker's desk and watch them type something and then say "WHAT? HOW COOL!"

I miss that part now that it is all remote work. :(

    #!/usr/bin/python3

    battery_directory = "/sys/class/power_supply/BAT1/"

    with open(battery_directory + "status", "r") as f:
        state = f.read().strip()

    with open(battery_directory + "current_now", "r") as f:
        current = int(f.read().strip())

    with open(battery_directory + "voltage_now", "r") as f:
        voltage = int(f.read().strip())

    wattage = (voltage / 10**6) * (current / 10**6)
    wattage_formatted = f"{'-' if state == 'Discharging' else ''}{wattage:.2f}W"

    if state in ["Charging", "Discharging", "Not charging"]:
        print(f"{state}: {wattage_formatted}")

Charging: 32.15W

Discharging: -5.15W

I have in my shell history which I occasionally use:

  while true; do echo -n '^[[34m'; date --iso-8601=seconds | tr -d '\n'; echo -n '^[[m: battery contains ^[[31m'; echo "scale=3;$(cat /sys/class/power_supply/BAT0/energy_now)/1000000" | bc | tr -d '\n'; echo -n 'Wh^[[m, '; [ "$(cat /sys/class/power_supply/BAT0/status)" = "Discharging" ] && echo -n 'consuming' || echo -n 'charging at'; echo -n ' ^[[32m'; echo "scale=3;$(cat /sys/class/power_supply/BAT0/power_now)/1000000" | bc | tr -d '\n'; echo 'W^[[m'; sleep 60; done

It’ll show lines like this every minute (with nice colouring):

  2022-08-16T01:07:31+10:00: battery contains 76.968Wh, charging at 0W

https://github.com/sirikon/workstation/blob/master/src/cli/c...

For Linux, it can install and configure everything I need when launched on a clean Debian installation. apt repositories, pins and packages; X11, i3, networking, terminal, symlinking configuration of many programs to Dropbox or the repository itself... The idea is to have my whole setup with a single command.

For Mac, it installs programs using brew and sets some configurations. Mac isn't my daily driver so the scripts aren't as complete.

Also there are scripts for the terminal to make my life easier. Random stuff like killing any gradle process in the background, upgrading programs that aren't packetized on APT, backing up savegames from my Anbernic, etc. https://github.com/sirikon/workstation/tree/master/src/shell

And more programs for common use, like screenshots, copying Stripe test cards into the clipboard, launching android emulators without opening Android Studio, etc. https://github.com/sirikon/workstation/tree/master/src/bin

Use it everyday. Great because my company has multiple git submodules in any given project and I can use this to watch for pipeline failures and the like.

  x=$(git config --local remote.origin.url|sed -n 's#.*/\([^.]*\)\.git#\1#p')
  y=$(git symbolic-ref --short HEAD)
  url="https://git.thecompany.com/thecompany/$x/tree/$y"
  $(open -a "firefox developer edition" "$url"

    glo () {
      xdg-open https://git.thecompany.com/$(git config remote.origin.url |cut -f2 -d: |cut -f1 -d.)
    }

[1]: https://github.com/paulirish/git-open

    function alarm_forever() {
        # play one part of the track at a time so that this function can be killed any time
        while :; do
            afplay --time .72 ~/sounds/alarm.mp3;
        done
    }

    function alarm_until_input() {
        alarm_forever &
        pid=$!;
        read  -n 1 -p "$*";
        kill -9 $pid;
    }

    # pip install termdown
    function timer {
        termdown $@;
        alarm_until_input "[Press any key to stop]"
    }
    alias alarm="timer"

    # TODO: ask if user soaked the rice first
    function rice {
        echo "1. Wash rice. Place in pressure cooker with 1-1 water-rice ratio."
        echo "2. Place the pressure cooker on the stove on high."
        read  -n 1 -p "3. When the pressure pot starts whistling, press any key to start the timer."
        termdown --title "Tweet!" 2m
        alarm_until_input "4. Take pot off heat and press any key."
        termdown --title "RICE" 11m
        alarm_until_input "5. Open the pot and stir the rice immediately."
        alarm_until_input "6. Eat!"
    }

  clip_video () {
          ffmpeg -ss "$2" -i "$1" -t "$3" -c copy "$4"
  }

  clip_video filename.mp4 start_point duration output.mp4

    if [ -z $3 ] 
    then
        echo "usage: $0 file start_seconds duration [scale=600] [fps=15] [crop]"
        exit 1
    fi

    if [ -z $4 ]
    then
        SCALE=600
    else
        # w=iw/2:h=ih/2 half size
        SCALE="$4"
    fi

    if [ -z $5 ]
    then
        FPS=15
    else
        FPS=$5
    fi

    if [ -z $6 ]
    then 
        CROP="crop=iw:ih:0:0,"
    else
        # CROP="600:ih:250:0" full height
        CROP="setsar=1,crop=${6},"
    fi

    rm "${1}.gif" &> /dev/null

    ffmpeg -ss $2 -t $3 -i "$1" -vf  ${CROP}fps=${FPS},scale=${SCALE}:-1:flags=lanczos,palettegen palette.png -loglevel error
    ffmpeg -ss $2 -t $3 -i "$1" -i palette.png -filter_complex "${CROP}fps=${FPS},scale=${SCALE}:-1:flags=lanczos[x];[x][1:v]paletteuse" "${1}.gif" -loglevel error

https://github.com/trevorgross/installarch/blob/main/install...

It's a personal tool that just kept growing. Probably amateurish by HN standards, but then, I'm an amateur. Yes, I could simply copy a disk image, but that's no fun.

One I was particularly proud of/disgusted by was one that allowed me to jump around a network with a single command despite access being gated by regional jumphosts..

You are warned: https://git.drk.sc/-/snippets/107

Another script I wrote for our devs to get access to MySQL in production on GCP; the intent was for the script to be executable only by root and allow sudo access to only this script: that means also ''chmod ugo-rwx gcloud'' too though: https://git.drk.sc/-/snippets/98

I have another script to generate screenshots from grafana dashboards since that functionality was removed from grafana itself (https://github.com/grafana/grafana/issues/18914): https://git.drk.sc/-/snippets/66

Another time I got annoyed that Wayland/Sway would relabel my screens on successive disconnect/reconnects (IE my right screen could be DP-1 or DP-7 or anything in between randomly); so I wrote a docking script which moves the screens to the right place based on serial number: https://git.drk.sc/-/snippets/74

I can relate! I think it just reflects the nature of the problem space. The script is gnarly because the thing one is trying to do is gnarly. Utility is the driving force, as far as I'm concerned.

The following aren't as gnarly as yours, but served their purpose nicely in that little project's context. I like to put/accumulate project-related automations in a `./bin` in my projects.

https://gitlab.com/nilenso/cats/-/tree/master/bin

https://www.shellcheck.net/

    docker run --rm -v "$PWD:/mnt" koalaman/shellcheck:stable myscript

I have used these 2 on my machines for the last 4 years and writing tons of script for myself, here are a few:

- Displaying internet/internal ip and allow me to click it to put in clipboard

- taskwarrior

- Simple conversion script that take my clipboard & encode/decode in base64, hex, url encoding, convert epoch to UTC,

- "auto type" my clipboard by simulating keystrokes- particular useful for pasting text into terminal that disable clipboard

- An incident response switch that would trigger a script to take screenshot every 5 seconds when my mouse moves, reduce image quality and save it to a folder in my homedrive. Another script will GPG encrypt it at the end of the day so i can go back and get screenshot or look back at incident if needed.

After that, it's just the matter of putting a crontab job to run archive job every night. Note that i have no way yet to know when the mouse move in macosx as xdotool no longer work with mac so right now it takes screenshot of every monitor and resize it down... it might be too much and could eat up your HDD. i like the nix version since I did a dirty job with mouse location so whenever i take a break from incident or walk away from my desk, the screenshot script stops.

  var nodes = [...document.querySelectorAll('\*[aria-label="Number of times this review was rated helpful"]')];
  nodes.sort((a, b) => (parseInt(b.innerText) || 0) - (parseInt(a.innerText) || 0));
  nodes.map(e => ([
    parseInt(e.innerText) || 0,
    e.parentNode.parentNode.parentNode.parentNode.parentNode.children[1].textContent.toString().trimStart(),
  ]));

https://github.com/Mister-Meeseeks/subcmd/blob/master/subcmd

It can be configured to exclude certain directories (.cache and Downloads being likely contenders). Also, it can read in config files so it can backup other directories.

https://github.com/lordfeck/feckback

    cd ()
    {
        builtin cd "$@" || return $?
        ls --my-usual-flags
    }

  # Change to the Front Folder open in Finder
  function ff {
    osascript -e 'tell application "Finder"'\
    -e 'if (0 < (count Finder windows)) then'\
    -e 'set finderpath to get target of the front window as alias'\
    -e 'else'\
    -e 'set finderpath to get desktop as alias'\
    -e 'end if'\
    -e 'get POSIX path of finderpath'\
    -e 'end tell';};\
  function cdff { cd "`ff $@`" || exit; };

  git() {
    if [[ "$1" == 'checkout' ]]; then
      echo 'Reminder: Use `git switch` or `git restore` instead.' >&2
    fi

    command git "$@"
  }

Then I wrote a script that does that automatically:

    #!/usr/bin/env bash

    main() {
        local package="$1"

        if [ -z "$package" ]
        then
            echo "usage: $0 PACKAGE"
            exit 1
        fi

        install_package "$package"
    }

    install_package() {
        local package="$1"
        local subpackage

        if sudo apt-get -y install "$package"
        then exit 0
        else
            sudo apt-get -y install "$package" \
            |& grep '^ ' \
            | sed 's/[^:]*:[^:]*: //;s/ .*//;' \
            | {
                while read subpackage
                do install_package "$subpackage"
                done
            }
            sudo apt-get -y install "$package" \
                && echo "SUCCESS: $package" \
                || echo "FAILURE: $package"
        fi
    }

    main "$@"

If I recall correctly, I think there were some situations where --fix-broken did nothing for me, but the script did. I don't remember it nearly well enough to guarantee, though.

One difference I'm sure about is that the script marks all recursively installed dependencies as manually installed, which may not be favorable (e.g. if you wanted to remove the top-level package, all the dependencies would not be removed automatically).

#!/usr/bin/env bash

function shc() { #: cat for shell scripts, source code. #: prints text with line numbers and syntax highlighting. #: accepts input as argument or pipe.

    if [ $# -eq 0 ]; then
        # arguments equal zero; assume piped input
        nl | /usr/local/bin/pygmentize -l bash
        # accept piped input, process as source code
    else
        case "$1" in
            -h|--help)
                printf "%s\n" "shc usage:" "           shc [file]" "           type [function] | shc"
                ;;
            -v|--version)
                printf "%s\n" "vers 2"
                ;;
            *)
                if [ -f "$1" ]; then
                    # test anything that isn't expected flags for file
                    cat "$1" | nl | /usr/local/bin/pygmentize -l bash
                    # process file as source code
                else
                    # if not a file or expected flags, bail
                    printf "%s\n" "error; not the expected input. read shc_func source for more details"
                fi
        esac
    fi
}

---------

#!/bin/sh

echo "Store and retrieve session token AWS STS \n\n"

# Get source profile read -p "Source Profile [<profile_name>]: " source_profile source_profile=${source_profile:-'<profile_name>'} echo $source_profile

# Get destination profile read -p "Destination Profile [<profile_name>-mfa]: " destination_profile destination_profile=${destination_profile:-'<profile_name>-mfa'} echo $destination_profile

mfa_serial_number='arn:aws:iam::<id>:mfa/<name>'

echo "\nOTP: " read -p "One Time Password (OTP): " otp

echo "\nOTP:" $otp echo "\n"

output=$(aws sts get-session-token --profile <profile_name> --serial-number $mfa_serial_number --output json --token-code $otp)

echo $output

access_key_id=$(echo $output | jq .Credentials.AccessKeyId | tr -d '"') secret_access_key=$(echo $output | jq .Credentials.SecretAccessKey | tr -d '"') session_token=$(echo $output | jq .Credentials.SessionToken | tr -d '"')

aws configure set aws_access_key_id $access_key_id --profile=$destination_profile aws configure set aws_secret_access_key $secret_access_key --profile=$destination_profile aws configure set aws_session_token $session_token --profile=$destination_profile

echo "Configured AWS for profile" $destination_profile

    !`::CycleCurrentApplication(0)
    !+`::CycleCurrentApplication(1)


    WhichMonitorAppIsOn(winId) {
        WinGetPos, cX, cY, cW, cH, ahk_id %winId%
        xMid := cX + (cW / 2)
        yMid := cY + (cH / 2)
        SysGet, nMons, MonitorCount
        Loop, % nMons
        {
            ; MsgBox %A_Index%
            SysGet, tmp, Monitor, %A_Index%
            withinWidth := (xMid > tmpLeft) && (xMid < tmpRight)
            ; MsgBox % tmpLeft . " -> " . tmpRight . "`t" . xMid
            if (withinWidth == 1)
                return %A_Index%
        }
    }


    CycleCurrentApplication(same_desktop_only) {
        WinGet, curID, ID, A
        curMon := WhichMonitorAppIsOn(curID)

        WinGetClass, ActiveClass, A
        WinGet, WinClassCount, Count, ahk_class %ActiveClass%
        IF WinClassCount = 1
            Return
        Else
            WinGet, List, List, % "ahk_class " ActiveClass
        Loop, % List
        {
            index := List - A_Index + 1
            WinGet, State, MinMax, % "ahk_id " List%index%
            WinGet, nextID, ID, % "ahk_id " List%index%
            nextMon := WhichMonitorAppIsOn(nextID)

            if (same_desktop_only > 0 && (curMon != nextMon))
                continue

            if (State != -1)  ; if window not minimised
            {
                WinID := List%index%
                break
            }
        }
        WinActivate, % "ahk_id " WinID
    }

The reason I like it is also backs up the original in case I mess up the regex (happens sometimes...)

   #!/usr/bin/env bash
   perl -i.bak  -p -e 's/oldtext/newtext/g;' $1

  #!/bin/sh
  
  if [ $(tmux has-session 2>/dev/null; echo $?) -eq 0 ]; then
      if [ $(tmux list-windows -f '#{window_active_clients}') ]; then
          if [ $(tmux ls | head -n 1 | awk '{print $2}') -le 2 ]; then
              xterm -e "tmux new-session -f active-pane,ignore-size -t "0" \; new-window"
          else
              xterm -e "tmux new-session -f active-pane,ignore-size -t "0" \; select-window -t +2"
          fi
      else
          xterm -e "tmux attach -f active-pane,ignore-size -t "0""
      fi
  else
      xterm -e tmux new-session -f active-pane,ignore-size
  fi
  
  if [ $(tmux ls | wc -l) -gt 1 ]; then
      for i in $(tmux ls -F '#S' -f '#{?session_attached,,#S}' ); do
          tmux kill-session -t ${i}
      done
  fi

  --- newterm    Mon Aug 15 18:09:51 2022
  +++ .local/bin/newterm    Mon Aug 15 18:07:51 2022
  @@ -1,8 +1,8 @@
   #!/bin/sh
   
   if [ $(tmux has-session 2>/dev/null; echo $?) -eq 0 ]; then
  -    if [ $(tmux list-windows -f '#{window_active_clients}') ]; then
  -        if [ $(tmux ls | head -n 1 | awk '{print $2}') -le 2 ]; then
  +    if [ $(tmux list-windows -F '#I' -f '#{window_active_clients}' | wc -l) -gt 0 ]; then
  +        if [ $(tmux ls -F '#{session_windows}' | head -n 1) -le 2 ]; then
               xterm -e "tmux new-session -f active-pane,ignore-size -t "0" \; new-window"
           else
               xterm -e "tmux new-session -f active-pane,ignore-size -t "0" \; select-window -t +2"

This can be extended easily, even dynamically creating an account if the user is part of an org, or use libnss-ato to alias the user to a specific account.

    #! /bin/bash

    remote_file_path=$1

    wget --recursive --level=5 --convert-links --page-requisites --wait=1 --random-wait --timestamping --no-parent ${remote_file_path}

    MARKPATH=~/.marks
    function jump {
        cd -P ${MARKPATH}/$1 2> /dev/null || (echo "No such mark: $1" && marks)
    }
    function mark {
        mkdir -p ${MARKPATH}; ln -s $(pwd) $MARKPATH/$1
    }
    function unmark {
        rm -i ${MARKPATH}/$1
    }
    function marks {
        ls -l ${MARKPATH} | sed 's/  / /g' | cut -d' ' -f9- && echo
    }
    _jump()
    {
        local cur=${COMP_WORDS[COMP_CWORD]}
        COMPREPLY=( $(compgen -W "$( ls $MARKPATH )" -- $cur) )
    }
    complete -F _jump jump

  export CDPATH=.:~/.marks/
  function mark {
    ln -sv "$(pwd)" ~/.marks/"$1"
  }

  $ cd @

  function git-checkout-branch-by-search-string() {
    local maybe_branch_name
    maybe_branch_name=$(git branch --sort=-committerdate | grep $1 | head -n 1)
    if [ -n "$maybe_branch_name" ]; then
      git checkout "${maybe_branch_name:2}"
    else
      echo "Could not find branch matching $1"
    fi
  }
  alias gcos="git-checkout-branch-by-search-string"

  $ gcos 1234

I have a pair of fixup commit functions, which make it faster to target fixup commits prior to rebasing:

  function git-commit-fixup() {
    git commit --fixup ":/$*"
  }
  function git-add-all-then-git-commit-fixup() {
    git add .
    git commit --fixup ":/$*"
  }

$ alias | grep fixup

to see the list of relevant aliases and the functions they call.

I also have two functions I use like a linear git bisect:

  function git-checkout-parent-commit() {
    local prev
    prev=$(git rev-parse HEAD~1)
    git checkout "$prev"
  }
  function git-checkout-child-commit() {
    local forward
    forward=$(git-children-of HEAD | tail -1)
    git checkout "$forward"
  }
  function git-children-of() {
    for arg in "$@"; do
      for commit in $(git rev-parse $arg^0); do
        for child in $(git log --format='%H %P' --all | grep -F " $commit" | cut -f1 -d' '); do
          echo $child
        done
      done
    done
  }

    #!/usr/bin/env bash

    for file in `find . -name '*.md'`; do
        output=${file::-3}.html
        if [[ `date -r "$file" "+%s"` -le `date -r "../$output" "+%s"` ]]
        then
            echo "Skipping $file"
            continue
        fi
        mkdir -p ../$(dirname $output)
        echo Generating $output from $file
        cat << EOF > ../$output
    <!DOCTYPE html>
    `cat head.html`
    <body>
    `cat navigation.html`
    <main>
    `pandoc $file`
    </main>
    <footer>
        <span>The content on this page is licensed under the CC BY-ND 4.0</span>
        <a style="float:right" href="/md/$file">Source</a>
    </footer>
    </body>
    EOF
    done;

    # Simple calculator
    function calc() {
        local result=""
        result="$(printf "scale=10;$*\n" | bc --mathlib | tr -d '\\\n')"
        #                       └─ default (when `--mathlib` is used) is 20
        #
        if [[ "$result" == *.* ]]; then
                # improve the output for decimal numbers
                printf "$result" |
                sed -e 's/^\./0./'        `# add "0" for cases like ".5"` \
                    -e 's/^-\./-0./'      `# add "0" for cases like "-.5"`\
                    -e 's/0*$//;s/\.$//'   # remove trailing zeros
        else
                printf "$result"
        fi
        printf "\n"
    }

search_notes() { input=$(rg -v '(\-\-)|(^\s*$)' --line-number /home/user/some-dir | fzf --ansi --delimiter : --preview 'batcat --color=always {1} --highlight-line {2}' --preview-window 'up,60%,border-bottom,+{2}+3/3,~3' | choose -f : 0) if [[$input = ""]]; then else less $input fi }

It uses various linux utilities including fzf and batcat(https://github.com/sharkdp/bat) to open a terminal with all the places where my query comes up (supporting fuzzy search). Since the workhorses are fzf and ripgrep its is quite fast even for very large directories.

So i will do `search_notes postgres authentication`. I can select a line and it will open the file in less. Works like a charm!

1: https://gist.github.com/adewes/02e8a1f662d100a7ed80627801d0a...

The most recent was a script that parsed a financial report and generated multiple emails depending on a set of criteria. Then the user could manual review these emails and press send if everything checks out. The goal of the script was to reduce some of the menial work my financial co-worker was doing. I don't have it published on GitHub because it has some internal company info in it. But it worked cleanly, and regularly saves him hours of tedious work.

Also I highly recommend EasyGui library for those quick scripts that need user input from people who are not comfortable with a console/cmd. Helps make different types of popup windows for user input/selection with a few simple lines.

https://github.com/64kramsystem/openscripts

Missed the previous cheatsheet post :) I have a massive collection, which are large enough to be books more than cheatsheets (still, I access and use them as cheatsheets):

https://github.com/64kramsystem/personal_notes/tree/master/t...

[1] https://gitlab.com/victor-engmark/tilde/-/blob/master/.bash_...

    alias filter_repos_z="grep -ZzEv '/tags|/\.hg/|/\.svn/|/\.git/|/\.repo/|\.o$|\.o\.cmd$|\.depend|\.map$|\.dep$|\.js$|\.html$'"
    function findxgrep()
    {
    find . -type f -print0 | filter_repos_z | xargs -0 grep --color=auto "${@}" | grep -v "^Binary file" | sed 's/^\.\///' | less -F
    }

https://beyondgrep.com/

My "Bash Toolkit": https://github.com/adityaathalye/bash-toolkit

My (yak-shaving-in-progress :) "little hot-reloadin' static shite generator from shell": https://github.com/adityaathalye/shite

A subtle-ish aspect is, I like to write Functional Programming style Bash. I've been blogging about it here: https://www.evalapply.org/tags/bash/

  sshcreen () {
      ssh -t "$@" screen -xRR
  }

  $ sshcreen user@example.com

  $ sshcreen root@localhost -p 2222

    pman()
    {
        man -t "${1}" | open -f -a /System/Applications/Preview.app
    }

    pwgen()
    {
        length=${1:-64}
        charlist='0-9a-zA-Z~!@#$%^&*()_+-=:";<>?,./'
        echo `cat /dev/random | tr -dc $charlist | head -c$length`
    }

Oh man. I didn't know just how badly I needed this in my life, thank you!

It also uses my https://github.com/pcho/dotfiles, https://github.com/pcho/vimfiles and https://github.com/pcho/zshfiles

  alias makepw='cat /dev/urandom | LC_ALL=C tr -cd A-Za-z0-9,_- | head -c 25; echo'

With my son having opened an account over a year ago, but we didn’t sign up for Mint until this weekend, I ended up writing a new import script for the updated API:

https://github.com/jeradrose/mint-simple-import

- Scripts to test our rate limiting for both authenticated and unauthenticated users (was handy)

- API routes changed in a given PR (set of commits since the last interaction with master in reality)

- ssl-expiration-date - Checks the expiration date of a site's certificate

  domain="$1"
  
  echo "Checking the SSL certificate expiration date for: $domain"
  
  curl -vI "$domain" 2>&1 | grep -o 'expire date: .*$'

  domain="$1"
  curl_options=( "--tlsv${2}" --tls-max "$2" )
  
  curl "${curl_options[@]}"  -vI "$domain" 2>&1

Everything is too coupled to my work to be useful to others, and most of the automation scripts I've written for work are run as cron jobs now and send out emails to the appropriate emails. Most of these are written in PHP (we're a PHP shop).

It shows the current status, lists out the most recent tags, prompts for a new tag and message, and finally pushes.

Everything is colorized so it's easy to read and I use it quite often for Golang projects.

https://github.com/bbkane/dotfiles/blob/e30c12c11a61ccc758f7...

[1] https://github.com/kaelzhang/shell-safe-rm

    #!/bin/sh
    
    pdf_viewer="mupdf";
    latex_cmd="pdflatex -interaction=nonstopmode"
    
    if [[ $# -eq 0 ]]; then
        print "No arguments: filename required"
        exit
    fi
    
    filename=$1;
    pdfname=${filename%%.*}.pdf
    
    # inital compilation to make sure a pdf file exists
    ${latex_cmd} ${filename};
    
    ${pdf_viewer} ${pdfname} &
    
    # get pid of the pdf viewer
    pdf_viewer_pid=$!;
    
    while true; do
        # as long as the pdf viewer is open, continue operation, if it gets closed,
        # end script
        if kill -0 "${pdf_viewer_pid}" 2>/dev/null; then
            if [[ ${filename} -nt ${pdfname} ]]; then
                ${latex_cmd} ${filename};
    
                # reload pdf file, only works with mupdf
                kill -HUP ${pdf_viewer_pid};
                touch $pdfname
            fi
            sleep 1;
        else
            exit 0;
        fi
    done;

There are many ways to search for the process, but here's what I use:

   lsof -iTCP -sTCP:LISTEN -P | grep [PORT NUMBER]

   kill -9 [PID OF PROCESS YOU WANT TO KILL]

As a workaround, I wrote a small wrapper script that would enable multi-threading for SimpleHTTPServer.

~/bin/http-cwd , Python 2 version (original):

  #!/usr/bin/python
  import argparse
  import BaseHTTPServer
  import SimpleHTTPServer
  import SocketServer
  import sys

  class ThreadedHTTPServer(SocketServer.ThreadingMixIn, BaseHTTPServer.HTTPServer):
      pass

  def main(argv):
      parser = argparse.ArgumentParser()
      parser.add_argument(
          "--port", type = int, nargs = "?",
          action = "store", default = 8000,
          help = "Specify alternate port [default: 8000]",
      )
      parser.add_argument(
          "--iface", type = str, nargs = "?",
          action = "store", default = "127.0.0.1",
          help = "Specify iface [default: 127.0.0.1]",
      )
      args = parser.parse_args(argv[1:])
      server_address = (args.iface, args.port)
      srv = ThreadedHTTPServer(server_address, SimpleHTTPServer.SimpleHTTPRequestHandler)
      sa = srv.socket.getsockname()
      print "Serving http://%s:%r ..." % (sa[0], sa[1])
      srv.serve_forever()

  if __name__ == "__main__":
      sys.exit(main(sys.argv))

  #!/usr/bin/python3
  import argparse
  import http.server
  import socketserver
  import sys

  class ThreadedHTTPServer(socketserver.ThreadingMixIn, http.server.HTTPServer):
      pass

  def main(argv):
      parser = argparse.ArgumentParser()
      parser.add_argument(
          "--port", type = int, nargs = "?",
          action = "store", default = 8000,
          help = "Specify alternate port [default: 8000]",
      )
      parser.add_argument(
          "--iface", type = str, nargs = "?",
          action = "store", default = "127.0.0.1",
          help = "Specify iface [default: 127.0.0.1]",
      )
      args = parser.parse_args(argv[1:])
      server_address = (args.iface, args.port)
      srv = ThreadedHTTPServer(server_address, http.server.SimpleHTTPRequestHandler)
      sa = srv.socket.getsockname()
      print("Serving http://%s:%r ..." % (sa[0], sa[1]))
      srv.serve_forever()

  if __name__ == "__main__":
      sys.exit(main(sys.argv))

    python -m http.server 8080 --bind 127.0.0.1 --directory your_directory

It fixes an issue in the Python built-in HTTP server that causes it to hang under concurrent connections.

First, run the built-in Python web server:

  [term1]$ python -m SimpleHTTPServer 8080

  [term2]$ nc localhost 8080

  [term3]$ curl -v http://127.0.0.1:8080
  *   Trying 127.0.0.1:8080...
  * TCP_NODELAY set
  * Connected to 127.0.0.1 (127.0.0.1) port 8080 (#0)
  > GET / HTTP/1.1
  > Host: 127.0.0.1:8080
  > User-Agent: curl/7.68.0
  > Accept: */*
  > 

This issue appears to have been fixed: https://github.com/python/cpython/issues/75820

    # Search all directories for this directory name.
    dname() {
        [ $# -eq 0 ] && echo "$0 'dir_name'" && return 1
        fd --hidden --follow --exclude .git --type directory "$*"
    }

    # Search all files for this filename.
    fname() {
        [ $# -eq 0 ] && echo "$0 'file_name'" && return 1
        fd --hidden --follow --exclude .git --type file "$*"
    }

    # Find and replace with a pattern and replacement
    sub() {
        [ $# -ne 2 ] && echo "$0 'pattern' 'replacement'" && return 1
        pattern="$1"
        replace="$2"
        command rg -0 --files-with-matches "$pattern" --hidden --glob '!.git' | xargs -0 perl -pi -e "s|$pattern|$replace|g"
    }

    # Uses z and fzf, if there's a match then jump to it. If not, bring up a list via fzf to fuzzy search.
    unalias z 2> /dev/null
    z() {
        [ $# -gt 0 ] && _z "$*" && return
        cd "$(_z -l 2>&1 | sed 's/^[0-9,.]* *//' | fzf)"
    }

  fndi () 
  { 
      tgt="${1}";
      shift;
      echo find . -iname \*"${tgt}"\* "${@}";
      find . -iname \*"${tgt}"\* "${@}" 2> /dev/null;
      [[ -z $tgt ]] && { 
          echo;
          echo "No target was specified, did the results   surprise?"
      }
  }

  fndg () 
  { 
      binOpt="-I";
      wordOpt="";
      caseOpt="-i";
      while true; do
          if [[ -z $1 || $1 =~ ^[^-+] ]]; then
              break;
          fi;
          case $1 in 
              +i)
                  caseOpt=""
              ;;
              -B)
                  binOpt=""
              ;;
              -w)
                  wordOpt="-w"
              ;;
              *)
                  echo "Unrecognized option '${1}', cannot proceed.";
                  return 1
              ;;
          esac;
          shift;
      done;
      if [[ -z $2 ]]; then
          startIn=.;
      else
          startIn='';
          while [[ ! -z $2 ]]; do
              startIn+="$1 ";
              shift;
          done;
      fi;
      [[ -z $1 ]] && { 
          echo "No target specified, cannot proceed.";
          return
      };
      tgt=$1;
      echo find ${startIn} -type f -exec grep $binOpt $wordOpt $caseOpt -H "${tgt}" {} \;;
      find ${startIn} -type f -exec grep $binOpt $wordOpt $caseOpt -H "${tgt}" {} \; 2> /dev/null
  }

There is also a collection of more "obscure" scripts in my shellscripts repository documented here: https://masysma.lima-city.de/32/shellscripts.xhtml.

Another (probably niché) topic is my handling of scanned documents which arrive as PDFs from the scanner and that I want to number according to the stamped number on the document and convert to png at reduced color space: https://masysma.lima-city.de/32/scanning.xhtml

8<-----------------------------

  function prompt_func {
    CMDNUM=`history 1 | awk '{print $1}'`
    LAST_CMD=`history 1 | cut -f 3- -d ' '`

    if [ x$LAST_CMDNUM = xwho_knows ]; then
      LAST_CMDNUM=$CMDNUM
    fi

    if [ x$CMDNUM != x$LAST_CMDNUM ]; then
      FULL_CMD_LOG="$HOME/full-history/$(date "+%Y-%m-%d").log"
      echo "$(date '+%H:%M:%S') `munge_pwd` $LAST_CMD" >> $FULL_CMD_LOG
      LAST_CMDNUM=$CMDNUM
    fi
  }
  export PROMPT_COMMAND=prompt_func
  export LAST_CMDNUM=who_knows

  function fh() {
    grep -r --color=NEVER ${*} ~/full-history |
    sed 's/[^ ]* //' |
    sed 's/ \[[^]]\*\]/$/'
  }

`munge_pwd` is another script that does various substitutions on the prompt (specific to how my work directories are laid out) but mostly you can just substitute `pwd` if you don't care about deduplicating stuff like multiple checkouts of the same project.

https://github.com/djsamseng/cheat_sheet/blob/main/grep_for_...

#!/bin/bash

if [ $# -eq 0 ] then echo "Usage: ./grep_for_text.sh \"text to find\" /path/to/folder --include=*.{cpp,h}" exit fi

text=$1 location=$2

# Remove $1 and $2 to pass remaining arguments as $@ shift shift

result=$(grep -Ril "$text" "$location" \ $@ \ --exclude-dir=node_modules --exclude-dir=build --exclude-dir=env --exclude-dir=lib \ --exclude-dir=.data --exclude-dir=.git --exclude-dir=data --exclude-dir=include \ --exclude-dir=__pycache__ --exclude-dir=.cache --exclude-dir=docs \ --exclude-dir=share --exclude-dir=odas --exclude-dir=dependencies \ --exclude-dir=assets)

echo "$result"

https://github.com/BurntSushi/ripgrep

As a sibling comment mentioned, assuming you're .gitignore files exclude all of that stuff from your repo, you should be able to just run 'rg "text to find"' to replace all of that. And use 'rg "text to find" -tcpp' if you want to limit it to C++ files.

I had similar scripts for recursive grep like that too. ripgrep replaced all of them.

    json2yaml() {
        python3 -c "import json,sys,yaml; print(yaml.dump(json.load(sys.stdin)))"
    }
    export -f json2yaml

    yaml2json() {
        python3 -c "import json,sys,yaml; json.dump(yaml.safe_load(sys.stdin), sys.stdout, default=str)"
    }
    export -f yaml2json

    httping() {
        while true; do
            curl $@ -so /dev/null \
                -w "connected to %{remote_ip}:%{remote_port}, code=%{response_code} time=%{time_total}s\n" \
                || return $?
            sleep 1
        done
    }
    [[ ! $(>&/dev/null type httping) ]] && export -f httping

    redis-cli() {
        REDIS_HOST="${1:-127.0.0.1}"
        REDIS_PORT="${2:-6379}"  
        rlwrap -S "${REDIS_HOST}:${REDIS_PORT}> " socat tcp:${REDIS_HOST}:${REDIS_PORT} STDIO
    }
    [[ ! $(>&/dev/null type redis-cli) ]] && export -f redis-cli

https://gist.github.com/stuporglue/83714cdfa0e4b4401cb6

It's one of my favorites because it's pretty simple, and I wrote it when a lot of things were finally coming together for me (including GIS concepts, plpgsql programming, and a project I was working on at the time).

This is code which takes either two foci points and a distance, or two foci, a distance and the number of pointers per quadrant and generates a polygon representing an ellipse. Nothing fancy, but it made me happy when I finally got it working.

The use case was to calculate a naive estimate of how far someone could have ridden on a bike share bike. I had the locations they checked out the bike, and where they returned it, and the time they were gone. By assuming some average speed, I could make an ellipse where everywhere within the ellipse could have been reached during the bike rental.

And then I have different dotfile repos. I have a base one that I keep so clean I could get a job at Disney with it. That's where most of my scripts live. And then I have locale ones, like -home, -<employername>. Those have overlays so that I can have contextual extensions, such as a cheat database with work stuff. Also, I can keep that dotfile-employername hosted at my employer so that I'm not "crossing the streams". I don't even have to link them, they just autoload based on their location and name.

I don't have to hop systems too much, so grabbing fresh tooling is a twice a year problem. I'm a cli-as-ide dinosaur so I just hide all my seldom-used scripts under a double underscore prefix. __init_tooling will update vim and give me the 8 or 9 plugins I have grown dependent upon, give me a ruby and python environment, etc.

I have a function called "add_word". Every time I see a word I dont know, I learn it, and then I run "add_word <new word> <definition>". It creates a new file called <new word> with the definition and commits it to a git repo hidden away. Every couple years I'll work through the list and see which I remember. I have about a 30% success rate adopting new words, which again, dinosaur here, so, I'll take whatever I can get.

The dirtiest thing I have is a cheap vault that uses vim and shell automation. I have a grammar for descripting secrets, and I can pass a passphrase through automation to get secrets out. I'm sure it's 100% hackable. I know the first rule of security software is "dont ever try to make your own". So I don't put anything too good in there.

  > Every couple years I'll work through the list and see which I remember.

Desktop: https://apps.ankiweb.net/

Android: https://play.google.com/store/apps/details?id=com.ichi2.anki...

Long story short: you can use hard links + rsync to create delta snapshots of a directory tree. I use it to create a back up of my important directory trees.

Funny story about this: I had really old HP "Lance Armstrong" branded laptop that I used for years. The above above script was on it and was rsyincing to separate machine so it was fully backed up. Because of that, I was actually hoping for the laptop to die so I could get a new one (frugalness kicking in strong here).

My girlfriend at the time was using it and said "Oh, should I not eat or drink over your laptop?" and I responded: "No, please do! If you break it that means I can allow myself to order a new one."

  f0() {
    echo 'select moz_bookmarks.title || '"'"' = '"'"' || url from moz_places, moz_bookmarks on moz_places.id = moz_bookmarks.fk where parent = 2;' | sqlite3 /home/user/.mozilla/firefox/twht79zd.default/places.sqlite
  }
  f1() {
    firefox `echo 'select url from moz_places, moz_bookmarks on moz_places.id = moz_bookmarks.fk where moz_bookmarks.title = '"'$1'"';' | sqlite3 /home/user/.mozilla/firefox/twht79zd.default/places.sqlite`
  }
  f$# $1

  exec gs -P -dBATCH -dNODISPLAY -dNOEPS -dNOPAUSE -dNOSAFER -q -- "$@"

  curl -s 'http://icanhazip.com/' | cat -v

alias please='sudo zsh -c "$(fc -ln -1)"' # rerun the last command with sudo (because it failed )

Easier PATH management:

# nicer path configuration and lookup function path { if [[ $# -eq 0 ]]; then echo -e ${PATH//:/\\n} | sort elif [[ "$1" == "--save" ]]; then path $2 && echo "\npath $2" >> $HOME/.profile else if [[ -d "$1" ]] ; then if [[ -z "$PATH" ]] ; then export PATH=$1 else export PATH=$1:$PATH fi else echo "$1 does not exist :(" return 1 fi fi }

This is a bash one-liner that takes the place of an RSA/2FA token/AuthyApp

https://manpages.ubuntu.com/manpages/bionic/man1/oathtool.1....

Variables: $HOSTNAME - the computer hostname $TOBACKUPDIR - the local directory you want backed up $N_CORES - the number of cores you want to use for compression $REMOTEUSER - the ssh user login on the remote server $REMOTEHOST - the remote server's IP $BACKUPDIR - where you want the file to be backed up to

#!/bin/bash

bfile=`date +%F`.$HOSTNAME.tar.gz

    /usr/bin/tar cvpf - \
            # You can exclude local directories here with
            # --exclude="dir" \
            $TOBACKUPDIR | pigz -p $N_CORES | \
            ssh $REMOTEUSER@$REMOTEHOST "cat - > /$BACKUPDIR/$bfile"

#!/usr/bin/env bash

function cdf() { #: Change working directory to the top-most Finder window location cd "$(osascript -e 'tell app "Finder" to POSIX path of (insertion location as alias)')"; }

  # Open current working directory in Finder
  alias of='open -a Finder ./'

https://www.masteringemacs.org/article/fuzzy-finding-emacs-i...

    manps()
    {
     if [ -z "$1" ]; then
      echo usage: $FUNCNAME topic
      echo This will open a PostScript formatted version of the man page for \'topic\'.
     else
      man -t $1 | open -f -a /Applications/Preview.app
     fi
    }

Sorry, no Linux version as I rarely have a graphical desktop open on Linux. It should be easy to rig something up with Ghostscript or similar.

Thanks for this tip!

This will fork it and wait until it ends.

#!/bin/bash

TOTAL=`ps aux | grep YOUR_CRONJOB.php | grep -v grep | wc -l`

echo "TOTAL PROCESSES ALREADY RUNNING :"$TOTAL

MAX_THREADS=20

TOTAL_MODS="$(($MAX_THREADS-1))"

echo "TOTAL MODS: "$TOTAL_MODS

if [ $TOTAL -eq 0 ]

then

    echo "RUNNING..."

    for i in $(seq 0 $TOTAL_MODS)

    do 
        echo "Starting thread $i"
        timeout 10000 php YOUR_CRONJOB.php $i $MAX_THREADS  & 

        pids[${i}]=$!

    done

    echo "FINISHED FORKING"  

    echo "NOT RUNNING...."

for pid in ${pids[*]}; do

    wait $pid

echo "OK FINISHED"

https://github.com/noahbailey/kvmgr/blob/master/kvmgr.sh

[1]: https://github.com/axelf4/nixos-config/blob/e90e897243e1d135...

https://github.com/cednore/dotfiles/blob/master/.functions#L... https://github.com/cednore/dotfiles/blob/master/.aliases#L46...

Use gnuplot to plot one or more files directly from the command line: https://github.com/RhysU/gplot/blob/master/gplot

  mkcd() {
      mkdir -p "$1" && cd "$1"
  }

  mkcdtmp() {
      mkcd ~/tmp/$(date "+%y%m%d")
  }

When I read it today I miss those soo oversimplified solutions to do stuff :'-)

Here are some selected scripts folks might find interesting.

Here's my backup script that I use to encrypt my data at rest before shipping it off to s3. Runs every night and is idempotent. I use s3 lifecycle rules to keep data around for 6 months after it's deleted. That way, if my script goofs, I can recover: https://github.com/BurntSushi/dotfiles/blob/2f58eedf3b7f7dae...

I have so many machines running Archlinux that I wrote my own little helper for installing Arch that configures the machine in the way I expect: https://github.com/BurntSushi/dotfiles/blob/2f58eedf3b7f7dae...

A tiny little script to recover the git commit message you spent 10 minutes writing, but "lost" because something caused the actual commit to fail (like a gpg error): https://github.com/BurntSushi/dotfiles/blob/2f58eedf3b7f7dae...

A script that produces a GitHub permalink from just a file path and some optional file numbers. Pass --clip to put it on your clipboard: https://github.com/BurntSushi/dotfiles/blob/2f58eedf3b7f7dae... --- I use it with this vimscript function to quickly generate permalinks from my editor: https://github.com/BurntSushi/dotfiles/blob/2f58eedf3b7f7dae...

A wrapper around 'gh' (previously: 'hub') that lets you run 'hub-rollup pr-number' and it will automatically rebase that PR into your current branch. This is useful for creating one big "rollup" branch of a bunch of PRs. It is idempotent. https://github.com/BurntSushi/dotfiles/blob/2f58eedf3b7f7dae...

Scale a video without having to memorize ffmpeg's crazy CLI syntax: https://github.com/BurntSushi/dotfiles/blob/2f58eedf3b7f7dae...

Under X11, copy something to your clipboard using the best tool available: https://github.com/BurntSushi/dotfiles/blob/2f58eedf3b7f7dae...

[1] https://github.com/benwinding/dotfiles

[2] https://zachholman.com/2010/08/dotfiles-are-meant-to-be-fork...

https://github.com/ianmiell/bash-template

It's a 'cut and paste' starter for shell scripts that tries to be as robust as possible while not going crazy with the scaffolding. Useful for "I want to quickly cut a script and put it into our source but don't want it to look totally hacky" situations.

  autoload -U add-zsh-hook

  add-zsh-hook chpwd source_env

  source_env() {
        if [[ -f .env && -r .env  ]]; then
                source .env
        fi
  }

    ## coding analysis
    function lines_coded {
        perl -ne'print unless /^\s*$/ || /^\s*(?:#|\/\*|\*)/' $* | wl
    }
    function lines_commented {
        perl -ne'print if /^\s*(?:#|\/\*|\*)/' $* | wl
    }

    wl='wc -l'

https://rtnf.prose.sh/prose-sublime-text-integration

https://rtnf.prose.sh/pandoc-sublime-text-integration

  replace() {
      grep -rl "$1" . | xargs gsed -i "s/$1/$2/g"
  }

Jesus that foot-gun would make Bjarne Stroustrup blush.

zfsnapr, a ZFS recursive snapshot mounter - I run borg-backup.sh using this to make consistent backups: https://github.com/Freaky/zfsnapr

mkjail, an automatic minimal FreeBSD chroot environment builder: https://github.com/Freaky/mkjail

run-one, a clone of the Ubuntu scripts of the same name, which provides a slightly friendlier alternative to running commands with flock/lockf: https://github.com/Freaky/run-one

ioztat, a Python script that basically provides what zfs-iostat(8) would if it existed: https://github.com/jimsalterjrs/ioztat

I replaced Plone for my personal use with about 1000 lines of Python. A object oriented database. The interface is awkward but if you get past that the goal was to produce pictures of trees with graphviz.

https://github.com/maulware/maulstuff

    playMeSomeMusicMan() { rg --files -tmusic ~/Music | shuf | mpv --playlist=- }

    kp() { ps aux | fzy | awk '{ print $2 }' | xargs kill }

  TASKKILL /IM outlook.exe
  TASKKILL /IM teams.exe
  TASKKILL /IM onedrive.exe

  timeout /t 2

  TASKKILL /F /IM outlook.exe
  TASKKILL /F /IM teams.exe
  TASKKILL /F /IM onedrive.exe
  TASKKILL /F /IM Microsoft.AAD.BrokerPlugin.exe
  timeout /t 2

  start outlook.exe
  start "" %LOCALAPPDATA%\Microsoft\Teams\Update.exe --processStart "Teams.exe"
  start "" "C:\Program Files\Microsoft OneDrive\OneDrive.exe"  /background

So I dropped the batch above on my desktop, and click it while the VPN is starting up. In the 4 seconds it takes to kill everything, the network works as it should.

#!/bin/bash echo |\ openssl s_client -connect ${1:?Usage: $0 HOSTNAME [PORT] [x509 OPTIONS]}:${2:-443} 2>&1 |\ sed -ne '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/p' |\ openssl x509 ${3:--text} ${@:4} 2>/dev/null |\ sed '/-BEGIN CERTIFICATE-/,/-END CERTIFICATE-/d'

https://github.com/ericfitz/dominfo

Dependencies: sublist3r (Python) pv (used for progress bars)

The junk I haven't touched in 10 years: https://github.com/psypete/public-bin/src

# M1 compatibility switches

arm() { arch -arm64 "${@:-$SHELL}" }

x86() { arch -x86_64 "${@:-$SHELL}" }

This with the addition of `$(uname -m)` in my $PROMPT, has saved me a lot of time by letting me switch between arm and x86_64 architecture.

  $ wat wat
  #!/usr/bin/env bash
  cat `which $1`

c:\Temp>tbt tbt @echo off

type c:\tools\%1.bat

c:\Temp>

Photoshop Layer Labeler: https://www.middleendian.com/pslayerlabeler