Ask HN: Can I see your scripts?

   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

    $ 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

  git co-commit --thor ...

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

    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')))

    #!/usr/bin/sh

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

  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

  .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);
  }

    $cat ~/.gitidentities/github.com 
    
    [user]
            name = dom111
            email = [email protected]

    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)

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

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

    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");
    }

    #!/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}")

  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"

    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

  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(),
  ]));

    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 "$@"
  }

    #!/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 [ $# -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
}

    !`::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
    }

   #!/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

    #! /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

  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

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

  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"
    }

    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
    }

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

  $ sshcreen [email protected]

  $ 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`
    }

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

  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

    #!/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;

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

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

  #!/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))

    # 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
  }

  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/ \[[^]]\*\]/$/'
  }

    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

  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

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

    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
    }

    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...."

    wait $pid

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

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

  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'

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

    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

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

    $ qtime.bash
    It's nearly twenty-five past two.

    kubectl get pods --all-namespaces --sort-by=.metadata.creationTimestamp -o wide -Lapp \
        | grep -vP "Completed|Terminating|ContainerCreating|Running\s+[01234567]\s+"

  function rgs {
      rg --line-number --with-filename --color always "$@" | sort --stable --field-separator=: --key=1,1
  }

  # Recursively search for keyword in all files of current directory

  grr() {
    grep -rHIn --exclude-dir=.git --exclude-dir=node_modules --exclude=*.min.* --exclude=*.map "$@" . 2>&1 | grep -v "No such file"
  }

    #!/bin/bash
    # Perform a work-in-progress commit
    
    # Add everything
    git add $(git rev-parse --show-toplevel)
    
    # If the latest commit is already a WIP, amend it
    if [[ $(git show --pretty=format:%s -s HEAD) = "WIP" ]]; then
      git amend --no-edit --no-verify
    else
      git commit -m "WIP" --no-verify
    fi

  hist() {
    history | grep $1
  }

  #!/usr/bin/env sh
  set -o errtrace; set -o errexit; set -o pipefail
  
  if [ -n "${1}" ]; then filter="${1}"; else filter=''; fi
  jq ."${filter}" package.json

    function usage() {
        printf "\n%s\n" "$funcname : $version : $updated"
        printf "%s\n" ""
    }

    function sortdir() {
        Chars="$(printf "    %s" "inspecting " "$(pwd)" | wc -c)"
        divider=====================
        divider=$divider$divider$divider$divider
        format="    %-${Chars}.${Chars}s %35s\n"
        totalwidth="$(ls -1 | /usr/local/bin/gwc -L)"
        totalwidth=$(echo $totalwidth | grep -o [0-9]\\+)
        Chars=$(echo $Chars | grep -o [0-9]\\+)
        if [ "$totalwidth" -lt "$Chars" ]; then
            longestvar="$Chars"
        else
            longestvar="$totalwidth"
        fi
        shortervar=$(/Users/danyoung/bin/qc "$longestvar"*.8)
        shortervar=$(printf "%1.0f\n" "$shortervar")
        echo "$shortervar"
        printf "\n    %s\n" "inspecting $(pwd)"
        printf "    %$shortervar.${longestvar}s\n" "$divider"
        theOutput="$(du -hs "${theDir}"/* | gsort -hr)"
        Condensed="$(echo -n "$theOutput" | awk '{ print $1","$2 }')"
        unset arr
        declare -a arr
        arr=($(echo "$Condensed"))
        Count="$(echo "$(printf "%s\n" "${arr[@]}")" | wc -l)"
        Count=$((Count-1))
        for i in $(seq 1 $Count); do
        printf "   %5s    %-16s\n" "$var1" "${var2//\/*\//./}"
        done
        echo
    }

    case "$1" in
        -h|--help)
            usage
            return 0
            ;;
        *)
            :
            ;;
    esac

     if [ -z "$1" ]; then
             oldDir="$(pwd)"
             cd "${1}"
             local theDir="$(pwd)"
             sortdir
             cd "$oldDir"
             return 0
     else
            :
             oldDir="$(pwd)"
             cd "${1}"
             local theDir="$(pwd)"
             sortdir
             cd "$oldDir"
             return 0
     fi


}

    $ cat $(which ,)
    #!/bin/sh
    
    #export DRI_PRIME=1
    
    cmd=mpv
    
    param='-fs --msg-level=all=no,cplayer=info'
    filter='/Playing/!d; s/^Playing: //'
    
    order='%C@' # by default, order by ctime
    sort=-n     # (which is a numeric sort)
    reverse=-r  # ... show newer videos first
    depth=      # ... and do it recursively
    loop=       # ... without looping
    
    [[ -n $MYT_MUTE ]] && set -- -u "$@"
    [[ -n $MYT_1 ]] && set -- -1 "$@"
    [[ -n $MYT_REC ]] && set -- -r "$@"
    
    while getopts 1rcmsaRnolugh o; do
        case "$o" in
        1) depth='-maxdepth 1';;  # just the current directory
        r) depth=;;               # recursively
    
            # a video uploaded in 2009 but downloaded in 2015 will have
            # mtime in 2009 and ctime in 2015
        #
        # (note: moving the video to another directory actually bumps
        # the ctime)
    
        c) order='%C@'; sort=-n;;    # order by ctime (download time)
        m) order='%T@'; sort=-n;;    # order by mtime (upload time)
    
        s) order='%s'; sort=-n;;     # order by size
        a) order='alpha'; sort=;;    # order lexicographically
        R) order='random'; sort=-n;; # order at random
    
        n) reverse=-r;; # newer first
        o) reverse=;;   # older first
    
            l) loop=--loop=inf;; # infinite loop
    
        u) mute=--mute=yes;; # no sound
    
        g) filter=; param=;;    # debug
    
        h) ${PAGER-less} "$0"; exit;;
        esac
    done
    shift $((OPTIND-1))
    
    find -L "$@" $depth -mindepth 0 \
         -not -path '*/\.*' \
         -type f \
         -name '*.*' \
         -printf "$order %p\0" \
        | awk 'BEGIN { RS="\0"; srand() } {
            if ($1 == "random")
              sub ($1, int(rand()*100000));
            printf "%s\0", $0
          }' \
        | sort -z $sort $reverse \
        | sed -zr 's/^[^ ]+ //' \
        | xargs -0 $cmd $loop $mute $param 2>&1 \
        | sed "$filter"
    
    
    #     -exec $cmd {} + | sed "$sed"

   alias editSeb="code ~/.sebrc"
   alias srcSeb="source ~/.sebrc"

   .sebrc

   # Download video from the given YouTube URL
   function ytdl() {
     youtube-dl -x --audio-format mp3 --prefer-ffmpeg $1
   }

   # Download audio from the given YouTube URL
   function ytmp3() {
     ytdl $1 | ffmpeg -i pipe:0 -b:a 320K -vn $2.mp3
   }

   # Shows total size of the given directory at $1
   function dus() {
     du -h -d 1 $1
   }

   # Used to opt-out of pre-commit autofixes
   export NO_COMMIT_CHECKS=true

   function cleanUSB() {
     volumeName=$1
     subdir=$2
     if [[ "$volumeName" != "" ]] && [[ "$subdir" = "" ]]; then
       rm -rfv /Volumes/$volumeName/.DS_Store
       rm -rfv /Volumes/$volumeName/.Spotlight-V100
       rm -rfv /Volumes/$volumeName/.fseventsd
       rm -rfv /Volumes/$volumeName/.Trashes
       rm -rfv /Volumes/$volumeName/._\*
       echo "Volume $volumeName is clean"
     elif [[ "$volumeName" != "" ]] && [[ "$subdir" != "" ]]; then
       rm -rfv /Volumes/$volumeName/$subdir/.DS_Store
       rm -rfv /Volumes/$volumeName/$subdir/.Spotlight-V100
       rm -rfv /Volumes/$volumeName/$subdir/.fseventsd
       rm -rfv /Volumes/$volumeName/$subdir/.Trashes
       rm -rfv /Volumes/$volumeName/$subdir/._\*
       echo "Volume $volumeName/$subdir is clean"
     else
       echo "No volume name given. Nothing to do."
     fi
   }

   function blogBackup() {
     rsync -avzh --progress -e ssh root@seb-nyc1-01:/root/blog/db /Users/seb/Documents/blog
   }

   alias showHiddenFiles='defaults write com.apple.finder AppleShowAllFiles YES; killall Finder /System/Library/CoreServices/Finder.app'
   alias hideHiddenFiles='defaults write com.apple.finder AppleShowAllFiles NO; killall Finder /System/Library/CoreServices/Finder.app'

   # Show ports currently listening
   function openPorts() {
     netstat -p tcp -van | grep '^Proto\|LISTEN'
   }

   # Create a RAM disk on macOS
   function ramDisk() {
     # https://eshop.macsales.com/blog/46348-how-to-create-and-use-a-ram-disk-with-your-mac-warnings-included/
     # 2048 = 1MB
     # 2097152 = 1G
     quantityOfBlocks=2097152
     diskutil erasevolume HFS+ "RAMDisk" `hdiutil attach -nomount ram://${quantityOfBlocks}`
   }

   # Tauri watcher for source file changes will not stop automatically.
   function killRollup() {
     ps aux | grep node | grep rollup | awk '{print  $2;}' | xargs kill -9 $1 
   }

   # X pet project required env var
   export X_TOKEN=blahValue

   function dockerCleanAll() {
       docker stop $(docker ps -aq)
       docker rm $(docker ps -aq)
       docker rmi $(docker images -q) -f
   }

   function dockerCleanVolumes() {
       docker volume rm $(docker volume ls -qf dangling=true)
   }

   alias ll='ls -lah'
   alias gg='git status -s'

   # Creates a timestamped backup of the current branch:
   alias gbk='git checkout -b "backup-$(git symbolic-ref -q HEAD --short)-$(date +%Y-%m-%d-%H.%M.%S)" && git checkout -'

    #!/usr/bin/env sh
    
    find | grep -- "$1"

    #!/usr/bin/env sh
    tr '\n' ' '; echo

    #!/bin/sh
    set -e

    CONFIG_FILE="${HOME}/.config/Ljournalrc";

    if [ ! -f "${CONFIG_FILE}" ]; then
        mkdir -p "$(dirname "$CONFIG_FILE")"
        printf 'JOURNAL_FILE="${HOME}/Documents/journal.txt"\n' >> "${CONFIG_FILE}"
        printf 'VIEWER=less\n'                                  >> "${CONFIG_FILE}"
        printf 'LESS='"'"'-~ -e +G'"'"'\n'                      >> "${CONFIG_FILE}"
    fi

    L=$(basename $0)

    usage() {
        cat <<HERE
    Usage:
        $L           - show the content of the journal
        $L message   - add message to the journal, with a date
        $L + message - add message to the previous entry in the journal
        $L -         - add stdin to the journal
        $L + -       - add stdin to the journal, without a date
        $L e         - edit the journal manually
        $L h, $L -h  - show this help

    Config file is in ${CONFIG_FILE}
    HERE
    }

    if [ "$1" = "h" ] || [ "$1" = "-h" ] || [ "$1" = "--help" ] || [ "$1" = "-help" ]; then
        usage
        exit
    fi

    . "${CONFIG_FILE}"


    if [ "$1" = "e" ]; then
        if [ -z "$EDITOR" ]; then
            if   [ -f "$(which nano)" ];  then
                EDITOR=nano
            elif [ -f "$(which vim)" ];   then
                EDITOR=vim
            elif [ -f "$(which emacs)" ]; then
                EDITOR=emacs
            fi
        fi
        exec "$EDITOR" "${JOURNAL_FILE}"
    fi


    # Don't add a new date line
    if [ "$1" = "+" ]; then
        append="+"
        shift
    fi

    if [ "$1" = "-" ]; then
            stdin="-"
            shift
    fi


    if [ -z "$stdin" ]; then
        msg="$@"
    else
        msg=""
        while read line; do
            msg=$(printf "%s\n%s" "$msg" "$line")
        done
    fi

    msg="$(printf %s "$msg" | sed 's|^|\t|g')"


    if [ -z "$msg" ] && [ -z "$append" ]; then
        if [ ! -f ${JOURNAL_FILE} ]; then
            exec usage
        else
            exec "${VIEWER}" -- "${JOURNAL_FILE}"
        fi
    fi

    if [ -z "$append" ]; then
        printf "\n%s:\n\n" "$(date -R)" >> ${JOURNAL_FILE}
    fi

    printf "%s\n" "$msg" >> ${JOURNAL_FILE}