Update docker!

.gitignore

@@ -1,5 +1,7 @@
 zsh/extraconfig.zsh
 zsh/env.zsh
 bash/extraconfig.bash
+nushell/history.*
+nushell/config/extra.nu
 .data
 bin-extra

alacritty.yml

@@ -0,0 +1,501 @@
+# Configuration for Alacritty, the GPU enhanced terminal emulator.
+
+# Any items in the `env` entry below will be added as
+# environment variables. Some entries may override variables
+# set by alacritty itself.
+#env:
+  # TERM variable
+  #
+  # This value is used to set the `$TERM` environment variable for
+  # each instance of Alacritty. If it is not present, alacritty will
+  # check the local terminfo database and use 'alacritty' if it is
+  # available, otherwise 'xterm-256color' is used.
+  #TERM: xterm-256color
+
+window:
+  # Window dimensions (changes require restart)
+  #
+  # Specified in number of columns/lines, not pixels.
+  # If both are `0`, this setting is ignored.
+  dimensions:
+    columns: 0
+    lines: 0
+
+  # Window padding (changes require restart)
+  #
+  # Blank space added around the window in pixels. This padding is not scaled
+  # by DPI and the specified value is always added at both opposing sides.
+  padding:
+    x: 0
+    y: 0
+
+  # Window decorations
+  #
+  # Values for `decorations`:
+  #     - full: Borders and title bar
+  #     - none: Neither borders nor title bar
+  decorations: none
+
+  dynamic_title: false
+  opacity: 0.8
+
+scrolling:
+  # Maximum number of lines in the scrollback buffer.
+  # Specifying '0' will disable scrolling.
+  history: 10000
+
+  # Number of lines the viewport will move for every line scrolled when
+  # scrollback is enabled (history > 0).
+  multiplier: 3
+
+# Font configuration (changes require restart)
+#
+# Important font attributes like antialiasing, subpixel aa, and hinting can be
+# controlled through fontconfig. Specifically, the following attributes should
+# have an effect:
+#   - hintstyle
+#   - antialias
+#   - lcdfilter
+#   - rgba
+#
+# For instance, if you wish to disable subpixel antialiasing, you might set the
+# rgba property to `none`. If you wish to completely disable antialiasing, you
+# can set antialias to `false`.
+#
+# Please see these resources for more information on how to use fontconfig:
+#   - https://wiki.archlinux.org/index.php/font_configuration#Fontconfig_configuration
+#   - file:///usr/share/doc/fontconfig/fontconfig-user.html
+font:
+  # Normal (roman) font face
+  normal:
+    # family: Ubuntu Mono Nerd Font
+    family: custom monospace
+    # family: Ubuntu Mono derivative Powerline
+    # family: Inconsolata for Powerline
+    # The `style` can be specified to pick a specific face.
+    #style: Regular
+
+  # # Bold font face
+  # bold:
+  #   family: Inconsolata for Powerline
+  #   # The `style` can be specified to pick a specific face.
+  #   #style: Bold
+
+  # # Italic font face
+  # italic:
+  #   family: Inconsolata for Powerline
+  #   # The `style` can be specified to pick a specific face.
+  #   #style: Italic
+
+  # Point size
+  size: 8.0
+
+  # Offset is the extra space around each character. `offset.y` can be thought of
+  # as modifying the line spacing, and `offset.x` as modifying the letter spacing.
+  offset:
+    x: 0
+    y: 0
+
+  # Glyph offset determines the locations of the glyphs within their cells with
+  # the default being at the bottom. Increasing `x` moves the glyph to the right,
+  # increasing `y` moves the glyph upwards.
+  glyph_offset:
+    x: 0
+    y: 0
+
+# If `true`, bold text is drawn using the bright color variants.
+draw_bold_text_with_bright_colors: true
+
+# Colors (Tomorrow Night Bright)
+colors:
+  # Default colors
+  primary:
+    background: '0x000000'
+    foreground: '0xeaeaea'
+
+    # Bright and dim foreground colors
+    #
+    # The dimmed foreground color is calculated automatically if it is not present.
+    # If the bright foreground color is not set, or `draw_bold_text_with_bright_colors`
+    # is `false`, the normal foreground color will be used.
+    #dim_foreground: '0x9a9a9a'
+    #bright_foreground: '0xffffff'
+
+  # Cursor colors
+  #
+  # Colors which should be used to draw the terminal cursor. If these are unset,
+  # the cursor color will be the inverse of the cell color.
+  #cursor:
+  #  text: '0x000000'
+  #  cursor: '0xffffff'
+
+  # Normal colors
+  normal:
+
+    black:   '0x000000'
+    red:     '0xcd0000'
+    green:   '0x00cd00'
+    yellow:  '0xcdcd00'
+    blue:    '0x7aa6da'
+    magenta: '0xcd00cd'
+    cyan:    '0x3465a4'
+    white:   '0xe5e5e5'
+
+  # Bright colors
+  bright:
+    black:   '0x666666'
+    red:     '0xff0000'
+    green:   '0x00ff00'
+    yellow:  '0xffff00'
+    blue:    '0x5c5cff'
+    magenta: '0xff00ff'
+    cyan:    '0x00ffff'
+    white:   '0xffffff'
+
+  # Dim colors
+  #
+  # If the dim colors are not set, they will be calculated automatically based
+  # on the `normal` colors.
+  dim:
+    black:   '0x333333'
+    red:     '0xf2777a'
+    green:   '0x99cc99'
+    yellow:  '0xffcc66'
+    blue:    '0x6699cc'
+    magenta: '0xcc99cc'
+    cyan:    '0x66cccc'
+    white:   '0xdddddd'
+
+# # Colors (Tomorrow Night Bright)
+# colors:
+#   # Default colors
+#   primary:
+#     background: '0xffffff'
+#     foreground: '0x000000'
+#
+#     # Bright and dim foreground colors
+#     #
+#     # The dimmed foreground color is calculated automatically if it is not present.
+#     # If the bright foreground color is not set, or `draw_bold_text_with_bright_colors`
+#     # is `false`, the normal foreground color will be used.
+#     #dim_foreground: '0x9a9a9a'
+#     #bright_foreground: '0xffffff'
+#
+#   # Cursor colors
+#   #
+#   # Colors which should be used to draw the terminal cursor. If these are unset,
+#   # the cursor color will be the inverse of the cell color.
+#   #cursor:
+#   #  text: '0x000000'
+#   #  cursor: '0xffffff'
+#
+#   # Normal colors
+#   normal:
+#
+#     black:   '0x000000'
+#     red:     '0xcd0000'
+#     green:   '0x00cd00'
+#     yellow:  '0xcdcd00'
+#     blue:    '0x0000cd'
+#     magenta: '0xcd00cd'
+#     cyan:    '0x00cdcd'
+#     white:   '0xfaebd7'
+#
+#   # Bright colors
+#   bright:
+#     black:   '0x000000'
+#     red:     '0xcd0000'
+#     green:   '0x00cd00'
+#     yellow:  '0xcdcd00'
+#     blue:    '0x0000cd'
+#     magenta: '0xcd00cd'
+#     cyan:    '0x00cdcd'
+#     white:   '0xfaebd7'
+#
+#   # Dim colors
+#   #
+#   # If the dim colors are not set, they will be calculated automatically based
+#   # on the `normal` colors.
+#   dim:
+#     black:   '0x333333'
+#     red:     '0xf2777a'
+#     green:   '0x99cc99'
+#     yellow:  '0xffcc66'
+#     blue:    '0x6699cc'
+#     magenta: '0xcc99cc'
+#     cyan:    '0x66cccc'
+#     white:   '0xdddddd'
+#
+# background_opacity: 1.0
+
+# Visual Bell
+#
+# Any time the BEL code is received, Alacritty "rings" the visual bell. Once
+# rung, the terminal background will be set to white and transition back to the
+# default background color. You can control the rate of this transition by
+# setting the `duration` property (represented in milliseconds). You can also
+# configure the transition function by setting the `animation` property.
+#
+# Values for `animation`:
+#   - Ease
+#   - EaseOut
+#   - EaseOutSine
+#   - EaseOutQuad
+#   - EaseOutCubic
+#   - EaseOutQuart
+#   - EaseOutQuint
+#   - EaseOutExpo
+#   - EaseOutCirc
+#   - Linear
+#
+# Specifying a `duration` of `0` will disable the visual bell.
+bell:
+  animation: EaseOutExpo
+  duration: 0
+
+# Mouse bindings
+#
+# Available fields:
+#   - mouse
+#   - action
+#   - mods (optional)
+#
+# Values for `mouse`:
+#   - Middle
+#   - Left
+#   - Right
+#   - Numeric identifier such as `5`
+#
+# All available `mods` and `action` values are documented in the key binding
+# section.
+mouse_bindings:
+  - { mouse: Middle, action: PasteSelection }
+
+mouse:
+  # Click settings
+  #
+  # The `double_click` and `triple_click` settings control the time
+  # alacritty should wait for accepting multiple clicks as one double
+  # or triple click.
+  double_click: { threshold: 300 }
+  triple_click: { threshold: 300 }
+
+  # If this is `true`, the cursor is temporarily hidden when typing.
+  hide_when_typing: false
+
+selection:
+  semantic_escape_chars: ",│`|:\"' ()[]{}<>"
+
+  # When set to `true`, selected text will be copied to both the primary and
+  # the selection clipboard. Otherwise, it will only be copied to the selection
+  # clipboard.
+  save_to_clipboard: false
+
+cursor:
+  # Cursor style
+  #
+  # Values for 'style':
+  #   - ▇ Block
+  #   - _ Underline
+  #   - | Beam
+  style: Block
+
+  # If this is `true`, the cursor will be rendered as a hollow box when the
+  # window is not focused.
+  unfocused_hollow: true
+
+# Live config reload (changes require restart)
+live_config_reload: true
+
+# Shell
+#
+# You can set `shell.program` to the path of your favorite shell, e.g. `/bin/fish`.
+# Entries in `shell.args` are passed unmodified as arguments to the shell.
+#shell:
+#  program: /bin/bash
+#  args:
+#    - --login
+
+# Key bindings
+#
+# Key bindings are specified as a list of objects. Each binding will specify
+# a key and modifiers required to trigger it, terminal modes where the binding
+# is applicable, and what should be done when the key binding fires. It can
+# either send a byte sequnce to the running application (`chars`), execute
+# a predefined action (`action`) or fork and execute a specified command plus
+# arguments (`command`).
+#
+# Example:
+#   `- { key: V, mods: Command, action: Paste }`
+#
+# Available fields:
+#   - key
+#   - mods (optional)
+#   - chars | action | command (exactly one required)
+#   - mode (optional)
+#
+# Values for `key`:
+#   - `A` -> `Z`
+#   - `F1` -> `F12`
+#   - `Key1` -> `Key0`
+#
+#   A full list with available key codes can be found here:
+#   https://docs.rs/glutin/*/glutin/enum.VirtualKeyCode.html#variants
+#
+#   Instead of using the name of the keys, the `key` field also supports using
+#   the scancode of the desired key. Scancodes have to be specified as a
+#   decimal number.
+#   This command will allow you to display the hex scancodes for certain keys:
+#     `showkey --scancodes`
+#
+# Values for `mods`:
+#   - Command
+#   - Control
+#   - Shift
+#   - Alt
+#
+#   Multiple `mods` can be combined using `|` like this: `mods: Control|Shift`.
+#   Whitespace and capitalization is relevant and must match the example.
+#
+# Values for `chars`:
+#   The `chars` field writes the specified string to the terminal. This makes
+#   it possible to pass escape sequences.
+#   To find escape codes for bindings like `PageUp` ("\x1b[5~"), you can run
+#   the command `showkey -a` outside of tmux.
+#   Note that applications use terminfo to map escape sequences back to
+#   keys. It is therefore required to update the terminfo when
+#   changing an escape sequence.
+#
+# Values for `action`:
+#   - Paste
+#   - PasteSelection
+#   - Copy
+#   - IncreaseFontSize
+#   - DecreaseFontSize
+#   - ResetFontSize
+#   - ScrollPageUp
+#   - ScrollPageDown
+#   - ScrollToTop
+#   - ScrollToBottom
+#   - ClearHistory
+#   - Hide
+#   - Quit
+#
+# Values for `command`:
+#   The `command` field must be a map containing a `program` string and
+#   an `args` array of command line parameter strings.
+#
+#   Example:
+#       `command: { program: "alacritty", args: ["-e", "vttest"] }`
+#
+# Values for `mode`:
+#   - ~AppCursor
+#   - AppCursor
+#   - ~AppKeypad
+#   - AppKeypad
+key_bindings:
+    # Custom
+  - { key: E,        mods: Control|Shift,    action: SpawnNewInstance    }
+    # Already present
+  - { key: V,        mods: Control|Shift,    action: Paste               }
+  - { key: C,        mods: Control|Shift,    action: Copy                }
+  - { key: Paste,                   action: Paste                        }
+  - { key: Copy,                    action: Copy                         }
+  - { key: Insert,   mods: Shift,   action: PasteSelection               }
+  - { key: Key0,     mods: Control, action: ResetFontSize                }
+  - { key: Equals,   mods: Control, action: IncreaseFontSize             }
+  - { key: Home,                    chars: "\x1bOH",   mode: AppCursor   }
+  - { key: Home,                    chars: "\x1b[H",   mode: ~AppCursor  }
+  - { key: End,                     chars: "\x1bOF",   mode: AppCursor   }
+  - { key: End,                     chars: "\x1b[F",   mode: ~AppCursor  }
+  - { key: PageUp,   mods: Shift,   chars: "\x1b[5;2~"                   }
+  - { key: PageUp,   mods: Control, chars: "\x1b[5;5~"                   }
+  - { key: PageUp,                  chars: "\x1b[5~"                     }
+  - { key: PageDown, mods: Shift,   chars: "\x1b[6;2~"                   }
+  - { key: PageDown, mods: Control, chars: "\x1b[6;5~"                   }
+  - { key: PageDown,                chars: "\x1b[6~"                     }
+  - { key: Tab,      mods: Shift,   chars: "\x1b[Z"                      }
+  - { key: Back,                    chars: "\x7f"                        }
+  - { key: Back,     mods: Alt,     chars: "\x1b\x7f"                    }
+  - { key: Insert,                  chars: "\x1b[2~"                     }
+  - { key: Delete,                  chars: "\x1b[3~"                     }
+  - { key: Left,     mods: Shift,   chars: "\x1b[1;2D"                   }
+  - { key: Left,     mods: Control, chars: "\x1b[1;5D"                   }
+  - { key: Left,     mods: Alt,     chars: "\x1b[1;3D"                   }
+  - { key: Left,                    chars: "\x1b[D",   mode: ~AppCursor  }
+  - { key: Left,                    chars: "\x1bOD",   mode: AppCursor   }
+  - { key: Right,    mods: Shift,   chars: "\x1b[1;2C"                   }
+  - { key: Right,    mods: Control, chars: "\x1b[1;5C"                   }
+  - { key: Right,    mods: Alt,     chars: "\x1b[1;3C"                   }
+  - { key: Right,                   chars: "\x1b[C",   mode: ~AppCursor  }
+  - { key: Right,                   chars: "\x1bOC",   mode: AppCursor   }
+  - { key: Up,       mods: Shift,   chars: "\x1b[1;2A"                   }
+  - { key: Up,       mods: Control, chars: "\x1b[1;5A"                   }
+  - { key: Up,       mods: Alt,     chars: "\x1b[1;3A"                   }
+  - { key: Up,                      chars: "\x1b[A",   mode: ~AppCursor  }
+  - { key: Up,                      chars: "\x1bOA",   mode: AppCursor   }
+  - { key: Down,     mods: Shift,   chars: "\x1b[1;2B"                   }
+  - { key: Down,     mods: Control, chars: "\x1b[1;5B"                   }
+  - { key: Down,     mods: Alt,     chars: "\x1b[1;3B"                   }
+  - { key: Down,                    chars: "\x1b[B",   mode: ~AppCursor  }
+  - { key: Down,                    chars: "\x1bOB",   mode: AppCursor   }
+  - { key: F1,                      chars: "\x1bOP"                      }
+  - { key: F2,                      chars: "\x1bOQ"                      }
+  - { key: F3,                      chars: "\x1bOR"                      }
+  - { key: F4,                      chars: "\x1bOS"                      }
+  - { key: F5,                      chars: "\x1b[15~"                    }
+  - { key: F6,                      chars: "\x1b[17~"                    }
+  - { key: F7,                      chars: "\x1b[18~"                    }
+  - { key: F8,                      chars: "\x1b[19~"                    }
+  - { key: F9,                      chars: "\x1b[20~"                    }
+  - { key: F10,                     chars: "\x1b[21~"                    }
+  - { key: F11,                     chars: "\x1b[23~"                    }
+  - { key: F12,                     chars: "\x1b[24~"                    }
+  - { key: F1,       mods: Shift,   chars: "\x1b[1;2P"                   }
+  - { key: F2,       mods: Shift,   chars: "\x1b[1;2Q"                   }
+  - { key: F3,       mods: Shift,   chars: "\x1b[1;2R"                   }
+  - { key: F4,       mods: Shift,   chars: "\x1b[1;2S"                   }
+  - { key: F5,       mods: Shift,   chars: "\x1b[15;2~"                  }
+  - { key: F6,       mods: Shift,   chars: "\x1b[17;2~"                  }
+  - { key: F7,       mods: Shift,   chars: "\x1b[18;2~"                  }
+  - { key: F8,       mods: Shift,   chars: "\x1b[19;2~"                  }
+  - { key: F9,       mods: Shift,   chars: "\x1b[20;2~"                  }
+  - { key: F10,      mods: Shift,   chars: "\x1b[21;2~"                  }
+  - { key: F11,      mods: Shift,   chars: "\x1b[23;2~"                  }
+  - { key: F12,      mods: Shift,   chars: "\x1b[24;2~"                  }
+  - { key: F1,       mods: Control, chars: "\x1b[1;5P"                   }
+  - { key: F2,       mods: Control, chars: "\x1b[1;5Q"                   }
+  - { key: F3,       mods: Control, chars: "\x1b[1;5R"                   }
+  - { key: F4,       mods: Control, chars: "\x1b[1;5S"                   }
+  - { key: F5,       mods: Control, chars: "\x1b[15;5~"                  }
+  - { key: F6,       mods: Control, chars: "\x1b[17;5~"                  }
+  - { key: F7,       mods: Control, chars: "\x1b[18;5~"                  }
+  - { key: F8,       mods: Control, chars: "\x1b[19;5~"                  }
+  - { key: F9,       mods: Control, chars: "\x1b[20;5~"                  }
+  - { key: F10,      mods: Control, chars: "\x1b[21;5~"                  }
+  - { key: F11,      mods: Control, chars: "\x1b[23;5~"                  }
+  - { key: F12,      mods: Control, chars: "\x1b[24;5~"                  }
+  - { key: F1,       mods: Alt,     chars: "\x1b[1;6P"                   }
+  - { key: F2,       mods: Alt,     chars: "\x1b[1;6Q"                   }
+  - { key: F3,       mods: Alt,     chars: "\x1b[1;6R"                   }
+  - { key: F4,       mods: Alt,     chars: "\x1b[1;6S"                   }
+  - { key: F5,       mods: Alt,     chars: "\x1b[15;6~"                  }
+  - { key: F6,       mods: Alt,     chars: "\x1b[17;6~"                  }
+  - { key: F7,       mods: Alt,     chars: "\x1b[18;6~"                  }
+  - { key: F8,       mods: Alt,     chars: "\x1b[19;6~"                  }
+  - { key: F9,       mods: Alt,     chars: "\x1b[20;6~"                  }
+  - { key: F10,      mods: Alt,     chars: "\x1b[21;6~"                  }
+  - { key: F11,      mods: Alt,     chars: "\x1b[23;6~"                  }
+  - { key: F12,      mods: Alt,     chars: "\x1b[24;6~"                  }
+  - { key: F1,       mods: Super,   chars: "\x1b[1;3P"                   }
+  - { key: F2,       mods: Super,   chars: "\x1b[1;3Q"                   }
+  - { key: F3,       mods: Super,   chars: "\x1b[1;3R"                   }
+  - { key: F4,       mods: Super,   chars: "\x1b[1;3S"                   }
+  - { key: F5,       mods: Super,   chars: "\x1b[15;3~"                  }
+  - { key: F6,       mods: Super,   chars: "\x1b[17;3~"                  }
+  - { key: F7,       mods: Super,   chars: "\x1b[18;3~"                  }
+  - { key: F8,       mods: Super,   chars: "\x1b[19;3~"                  }
+  - { key: F9,       mods: Super,   chars: "\x1b[20;3~"                  }
+  - { key: F10,      mods: Super,   chars: "\x1b[21;3~"                  }
+  - { key: F11,      mods: Super,   chars: "\x1b[23;3~"                  }
+  - { key: F12,      mods: Super,   chars: "\x1b[24;3~"                  }

bashrc

@@ -62,9 +62,9 @@ if [ "$color_prompt" = yes ]; then
     else
         color="\033[1;35m"
     fi
-    PS1="${color}╭── \u\033[33m::\033[34m\w\033[0m\n${color}╰▶  \033[0m"
+    PS1="${color}┌── \u\033[33m@\033[32m\H\033[33m::\033[34m\w\033[0m\n${color}└▷  \033[0m"
 else
-    PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ '
+    PS1='${debian_chroot:+($debian_chroot)}\u@\H:\w\$ '
 fi
 unset color_prompt force_color_prompt color
 
@@ -88,6 +88,12 @@ alias ll='ls -alF'
 alias la='ls -A'
 alias l='ls -CF'
 
+bind '"\e[A": history-search-backward'
+bind '"\e[B": history-search-forward'
+
+export PATH=~/.config/dotfiles/bin/:$PATH
+alias u=update
+
 # Add an "alert" alias for long running commands.  Use like so:
 #   sleep 10; alert
 alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'

bin/lmount

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+if [ "$#" -ne 2 ]; then
+    echo -e >&2 "\x1B[1;31merror:\x1B[0;1m this program expects two arguments\x1B[0m"
+    echo -e >&2 "\x1B[1;33musage:\x1B[0;1m sudo lmount <drive> <mount point>"
+
+    exit 1
+fi
+
+if [ "$USER" != "root" ]; then
+    echo -e >&2 "\x1B[1;31merror:\x1B[0;1m this program must be run as root\x1B[0m"
+    echo -e >&2 "\x1B[1;33musage:\x1B[0;1m sudo lmount <drive> <mount point>"
+
+    exit 1
+fi
+
+# Mounts an encrypt external drive to a specified mount point
+cryptsetup luksOpen $1 external
+mount /dev/mapper/external $2

bin/lumount

@@ -0,0 +1,19 @@
+#!/usr/bin/env bash
+
+if [ "$#" -ne 1 ]; then
+    echo -e >&2 "\x1B[1;31merror:\x1B[0;1m this program expects one argument\x1B[0m"
+    echo -e >&2 "\x1B[1;33musage:\x1B[0;1m sudo lumount <mount point>"
+
+    exit 1
+fi
+
+if [ "$USER" != "root" ]; then
+    echo -e >&2 "\x1B[1;31merror:\x1B[0;1m this program must be run as root\x1B[0m"
+    echo -e >&2 "\x1B[1;33musage:\x1B[0;1m sudo lumount <mount point>"
+
+    exit 1
+fi
+
+# Mounts an encrypt external drive to a specified mount point
+umount $1
+cryptsetup luksClose external

bin/server

@@ -0,0 +1,262 @@
+#! /usr/bin/env python
+
+# Shamefully copied from this gist :
+# https://gist.github.com/pankajp/280596a5dabaeeceaaaa/
+
+# Standard library imports.
+import sys
+
+if sys.version_info[0] < 3:
+    from SocketServer import ThreadingMixIn
+    import BaseHTTPServer
+    from SimpleHTTPServer import SimpleHTTPRequestHandler
+    from urllib import quote, unquote
+    from cStringIO import StringIO
+else:
+    import http.server as BaseHTTPServer
+    from http.server import SimpleHTTPRequestHandler
+    from socketserver import ThreadingMixIn
+    from urllib.parse import quote, unquote
+    from io import BytesIO as cStringIO
+
+import os
+from os.path import (join, exists, abspath, split, splitdrive, isdir)
+from os import makedirs, unlink, getcwd, chdir, curdir, pardir, rename, fstat
+from shutil import copyfileobj, copytree
+import glob
+from zipfile import ZipFile
+from posixpath import normpath
+import re
+import cgi
+import threading
+import socket
+import errno
+
+DATA_DIR = getcwd()
+
+
+class ThreadingHTTPServer(ThreadingMixIn, BaseHTTPServer.HTTPServer):
+    pass
+
+
+class RequestHandler(SimpleHTTPRequestHandler):
+    """ Handler to handle POST requests for actions.
+    """
+
+    serve_path = DATA_DIR
+
+    def do_GET(self):
+        """ Overridden to handle HTTP Range requests. """
+        self.range_from, self.range_to = self._get_range_header()
+        if self.range_from is None:
+            # nothing to do here
+            return SimpleHTTPRequestHandler.do_GET(self)
+        f = self.send_range_head()
+        if f:
+            self.copy_file_range(f, self.wfile)
+            f.close()
+
+    def copy_file_range(self, in_file, out_file):
+        """ Copy only the range in self.range_from/to. """
+        in_file.seek(self.range_from)
+        # Add 1 because the range is inclusive
+        left_to_copy = 1 + self.range_to - self.range_from
+        buf_length = 64 * 1024
+        bytes_copied = 0
+        while bytes_copied < left_to_copy:
+            read_buf = in_file.read(min(buf_length, left_to_copy - bytes_copied))
+            if len(read_buf) == 0:
+                break
+            out_file.write(read_buf)
+            bytes_copied += len(read_buf)
+        return bytes_copied
+
+    def send_range_head(self):
+        """Common code for GET and HEAD commands.
+
+        This sends the response code and MIME headers.
+
+        Return value is either a file object (which has to be copied
+        to the outputfile by the caller unless the command was HEAD,
+        and must be closed by the caller under all circumstances), or
+        None, in which case the caller has nothing further to do.
+
+        """
+        path = self.translate_path(self.path)
+        f = None
+        if isdir(path):
+            if not self.path.endswith('/'):
+                # redirect browser - doing basically what apache does
+                self.send_response(301)
+                self.send_header("Location", self.path + "/")
+                self.end_headers()
+                return None
+            for index in "index.html", "index.htm":
+                index = join(path, index)
+                if exists(index):
+                    path = index
+                    break
+            else:
+                return self.list_directory(path)
+
+        if not exists(path) and path.endswith('/data'):
+            # FIXME: Handle grits-like query with /data appended to path
+            # stupid grits
+            if exists(path[:-5]):
+                path = path[:-5]
+
+        ctype = self.guess_type(path)
+        try:
+            # Always read in binary mode. Opening files in text mode may cause
+            # newline translations, making the actual size of the content
+            # transmitted *less* than the content-length!
+            f = open(path, 'rb')
+        except IOError:
+            self.send_error(404, "File not found")
+            return None
+
+        if self.range_from is None:
+            self.send_response(200)
+        else:
+            self.send_response(206)
+
+        self.send_header("Content-type", ctype)
+        fs = fstat(f.fileno())
+        file_size = fs.st_size
+        if self.range_from is not None:
+            if self.range_to is None or self.range_to >= file_size:
+                self.range_to = file_size - 1
+            self.send_header("Content-Range",
+                             "bytes %d-%d/%d" % (self.range_from,
+                                                 self.range_to,
+                                                 file_size))
+            # Add 1 because ranges are inclusive
+            self.send_header("Content-Length",
+                             (1 + self.range_to - self.range_from))
+        else:
+            self.send_header("Content-Length", str(file_size))
+        self.send_header("Last-Modified", self.date_time_string(fs.st_mtime))
+        self.end_headers()
+        return f
+
+    def list_directory(self, path):
+        """Helper to produce a directory listing (absent index.html).
+
+        Return value is either a file object, or None (indicating an
+        error).  In either case, the headers are sent, making the
+        interface the same as for send_head().
+
+        """
+        try:
+            list = os.listdir(path)
+        except os.error:
+            self.send_error(404, "No permission to list directory")
+            return None
+        list.sort(key=lambda a: a.lower())
+        f = StringIO()
+        displaypath = cgi.escape(unquote(self.path))
+        f.write('<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">')
+        f.write("<html>\n<title>Directory listing for %s</title>\n" % displaypath)
+        f.write("<body>\n<h2>Directory listing for %s</h2>\n" % displaypath)
+        f.write("<hr>\n<ul>\n")
+        for name in list:
+            fullname = os.path.join(path, name)
+            displayname = linkname = name
+            # Append / for directories or @ for symbolic links
+            if os.path.isdir(fullname):
+                displayname = name + "/"
+                linkname = name + "/"
+            if os.path.islink(fullname):
+                displayname = name + "@"
+                # Note: a link to a directory displays with @ and links with /
+            f.write('<li><a href="%s">%s</a>\n'
+                    % (quote(linkname), cgi.escape(displayname)))
+        f.write("</ul>\n<hr>\n</body>\n</html>\n")
+        length = f.tell()
+        f.seek(0)
+        self.send_response(200)
+        encoding = sys.getfilesystemencoding()
+        self.send_header("Content-type", "text/html; charset=%s" % encoding)
+        self.send_header("Content-Length", str(length))
+        self.end_headers()
+        return f
+
+    def translate_path(self, path):
+        """ Override to handle redirects.
+        """
+        path = path.split('?', 1)[0]
+        path = path.split('#', 1)[0]
+        path = normpath(unquote(path))
+        words = path.split('/')
+        words = filter(None, words)
+        path = self.serve_path
+        for word in words:
+            drive, word = splitdrive(word)
+            head, word = split(word)
+            if word in (curdir, pardir): continue
+            path = join(path, word)
+        return path
+
+    # Private interface ######################################################
+
+    def _get_range_header(self):
+        """ Returns request Range start and end if specified.
+        If Range header is not specified returns (None, None)
+        """
+
+        if sys.version_info[0] < 3:
+            range_header = self.headers.getheader("Range")
+        else:
+            range_header = self.headers.get("Range")
+
+        if range_header is None:
+            return (None, None)
+        if not range_header.startswith("bytes="):
+            return (None, None)
+        regex = re.compile(r"^bytes=(\d+)\-(\d+)?")
+        rangething = regex.search(range_header)
+        if rangething:
+            from_val = int(rangething.group(1))
+            if rangething.group(2) is not None:
+                return (from_val, int(rangething.group(2)))
+            else:
+                return (from_val, None)
+        else:
+            return (None, None)
+
+
+def get_server(port=8000, next_attempts=0, serve_path=None):
+    Handler = RequestHandler
+    if serve_path:
+        Handler.serve_path = serve_path
+    while next_attempts >= 0:
+        try:
+            httpd = ThreadingHTTPServer(("", port), Handler)
+            return httpd
+        except socket.error as e:
+            if e.errno == errno.EADDRINUSE:
+                next_attempts -= 1
+                port += 1
+            else:
+                raise
+
+
+def main(args=None):
+    if args is None:
+        args = sys.argv[1:]
+
+    PORT = 8000
+    if len(args) > 0:
+        PORT = int(args[-1])
+    serve_path = DATA_DIR
+    if len(args) > 1:
+        serve_path = abspath(args[-2])
+
+    httpd = get_server(port=PORT, serve_path=serve_path)
+
+    print("serving at port " + str(PORT))
+    httpd.serve_forever()
+
+
+if __name__ == "__main__":
+    main()

bin/update

@@ -162,8 +162,13 @@ update-system() {
         return
     fi
 
-    echo -e "\033[32;1m=== Starting system update, please enter your password ===\033[0m"
-    sudo true
+    if [ -z "$password" ]; then
+        echo -e "\033[32;1m=== Starting system update, please enter your password ===\033[0m"
+        read -sep "Password: " password
+    fi
+
+    echo $password | sudo -Sp "" true > /dev/null 2>&1
+
     if [ $? -ne 0 ]; then
         echo "Could not get sudo..."
         return 1
@@ -175,33 +180,48 @@ update-system() {
     # Debian based systems
     command -v apt > /dev/null 2>&1
     if [ $? -eq 0 ]; then
-        sudo apt update -y
+        echo $password | sudo -Sp "" apt update -y
         if [ $? -eq 0 ]; then
-            sudo apt upgrade -y
+            echo $password | sudo -Sp "" apt upgrade -y
             if [ $? -eq 0 ]; then
-                sudo apt autoremove -y
+                echo $password | sudo -Sp "" apt autoremove -y
             fi
         fi
     fi
 
+    command -v snap > /dev/null 2>&1
+    if [ $? -eq 0 ]; then
+        echo $password | sudo -Sp "" snap refresh
+    fi
+
     # Archlinux based systems
-    command -v yay > /dev/null 2>&1
+    command -v paru > /dev/null 2>&1
 
     if [ $? -eq 0 ]; then
-        yay -Syu --noconfirm
-        yay -Syua --noconfirm
+        paru -Syu --noconfirm
     else
-        command -v pacman > /dev/null 2>&1
+
+        command -v yay > /dev/null 2>&1
 
         if [ $? -eq 0 ]; then
-            sudo pacman -Syu --noconfirm
+            yay -Syu --noconfirm
+            yay -Syua --noconfirm
+        else
+
+            command -v pacman > /dev/null 2>&1
+
+            if [ $? -eq 0 ]; then
+                echo $password | sudo -Sp "" pacman -Syu --noconfirm
+            fi
+
         fi
+
     fi
 
     # Fedora based systems
     command -v dnf > /dev/null 2>&1
     if [ $? -eq 0 ]; then
-        sudo dnf upgrade
+        echo $password | sudo -Sp "" dnf upgrade
     fi
 
     local seconds=$((`date +%s` - $start))
@@ -463,6 +483,12 @@ partial-update() {
 
 main() {
 
+    if [ "$1" == "--pass" ]; then
+        shift
+        password=$1
+        shift
+    fi
+
     if [ $# -eq 0 ]; then
         _lock_or_error_message
         local error_code=$?
@@ -471,7 +497,7 @@ main() {
         fi
 
         local start=`date +%s`
-        echo -e "\033[32;1m=== Starting full update ===\033[0m"
+        echo -e "\033[32;1m=== Starting full update of $(whoami)@$(hostname) ===\033[0m"
 
         # Update the system
         _check_running

bin/video2gif

@@ -12,10 +12,10 @@ fi
 
 palette_dir=$(mktemp -d)
 
-ffmpeg -y -ss $2 -t $3 -i $1 \
+ffmpeg -y -ss $2 -to $3 -i $1 \
     -vf fps=30,scale=320:-1:flags=lanczos,palettegen $palette_dir/palette.png > /dev/null 2>&1
 
-ffmpeg -ss $2 -t $3 -i $1 -i $palette_dir/palette.png -filter_complex \
-    "fps=30,scale=320:-1:flags=lanczos[x];[x][1:v]paletteuse" -y output.gif > /dev/null 2>&1
+ffmpeg -ss $2 -to $3 -i $1 -i $palette_dir/palette.png -filter_complex \
+    "fps=30,scale=640:-1:flags=lanczos[x];[x][1:v]paletteuse" -y output.gif > /dev/null 2>&1
 
 rm -rf $palette_dir

coc-settings.json

@@ -0,0 +1,15 @@
+{
+    "languageserver": {
+        "rust": {
+            "command": "rustup",
+            "args": ["run", "stable", "rust-analyzer"],
+            "filetypes": ["rust"],
+            "rootPatterns": ["Cargo.toml"]
+        },
+        "elmLS": {
+            "command": "elm-language-server",
+            "filetypes": ["elm"],
+            "rootPatterns": ["elm.json"]
+        }
+    }
+}

init.vim

@@ -3,35 +3,25 @@ set nocompatible
 
 " PLUGNIS ###########################################################{{{
 call plug#begin()
-if has('nvim')
-  Plug 'Shougo/deoplete.nvim', { 'do': ':UpdateRemotePlugins' }
-else
-  Plug 'Shougo/deoplete.nvim'
-  Plug 'roxma/nvim-yarp'
-  Plug 'roxma/vim-hug-neovim-rpc'
-endif
+
+" Conquer of Completion
+Plug 'neoclide/coc.nvim', {'branch': 'release'}
 
 " General plugins
 Plug 'vim-airline/vim-airline'
 Plug 'vim-airline/vim-airline-themes'
 Plug 'https://gitea.tforgione.fr/tforgione/peach.git'
 Plug 'scrooloose/nerdtree'
-Plug 'w0rp/ale'
 Plug 'tpope/vim-abolish'
+Plug 'lambdalisue/suda.vim'
 
 " Language specific plugins
 
-" C++
-Plug 'Shougo/deoplete-clangx'
-
 " Rust
 Plug 'rust-lang/rust.vim'
-Plug 'racer-rust/vim-racer'
-Plug 'sebastianmarkow/deoplete-rust'
 
 " Elm
 Plug 'ElmCast/elm-vim'
-Plug 'antew/vim-elm-language-server'
 
 " Toml
 Plug 'cespare/vim-toml'
@@ -39,8 +29,8 @@ Plug 'cespare/vim-toml'
 " Pug
 Plug 'digitaltoad/vim-pug'
 
-" Spandex
-Plug 'rust-spandex/spandex.vim'
+" Typst
+Plug 'kaarmu/typst.vim'
 
 call plug#end()
 
@@ -56,6 +46,10 @@ set expandtab
 set tabstop=4
 set shiftwidth=4
 set autoindent
+set tw=120
+if !empty($NVIM_TEXT_WIDTH)
+    execute 'set tw=' . $NVIM_TEXT_WIDTH
+endif
 " }}}
 
 " UI CONFIG #########################################################{{{
@@ -89,6 +83,9 @@ elseif executable('make')
     vnoremap <silent><F12> :wa \|!make -p %:p<CR>
 endif
 
+" SudaWrite with W
+command W SudaWrite
+
 " Escape on F1
 map <F1> <Esc>
 imap <F1> <Esc>
@@ -157,31 +154,71 @@ let g:markdown_composer_browser = 'firefox'
 let g:instant_markdown_autostart = 0
 " }}}
 
-" CODE COMPLETION ###################################################{{{
+" COC CONFIG ########################################################{{{
 
-" Use deoplete
-let g:deoplete#enable_at_startup = 1
-autocmd FileType elm call deoplete#custom#buffer_option('auto_complete', v:false)
+" Use `[g` and `]g` to navigate diagnostics
+" Use `:CocDiagnostics` to get all diagnostics of current buffer in location list.
+nmap <silent> gp <Plug>(coc-diagnostic-prev)
+nmap <silent> gn <Plug>(coc-diagnostic-next)
+
+" GoTo code navigation.
+nmap <silent> gd <Plug>(coc-definition)
+nmap <silent> gy <Plug>(coc-type-definition)
+nmap <silent> gi <Plug>(coc-implementation)
+nmap <silent> gr <Plug>(coc-references)
+
+" Add `:Format` command to format current buffer.
+command! -nargs=0 Format :call CocAction('format')
+
+" Use K to show documentation in preview window.
+nnoremap <silent> K :call <SID>show_documentation()<CR>
+
+
+function! s:show_documentation()
+  if (index(['vim','help'], &filetype) >= 0)
+    execute 'h '.expand('<cword>')
+  elseif (coc#rpc#ready())
+    call CocActionAsync('doHover')
+  else
+    execute '!' . &keywordprg . " " . expand('<cword>')
+  endif
+endfunction
+
+" Having longer updatetime (default is 4000 ms = 4 s) leads to noticeable
+" delays and poor user experience.
+set updatetime=300
+
+" Highlight the symbol and its references when holding the cursor.
+autocmd CursorHold * silent call CocActionAsync('highlight')
+
+" Symbol renaming.
+nmap <leader>rn <Plug>(coc-rename)
+
+" Formatting selected code.
+xmap <leader>f  <Plug>(coc-format-selected)
+nmap <leader>f  <Plug>(coc-format-selected)
 
 " Autoclose preview
 autocmd CursorMovedI * if pumvisible() == 0|pclose|endif
 autocmd InsertLeave * if pumvisible() == 0|pclose|endif
 
 " Complete on tab
-inoremap <expr><TAB>  pumvisible() ? "\<C-n>" : "\<TAB>"
+" inoremap <expr><TAB>  pumvisible() ? "\<C-n>" : "\<TAB>"
+function! s:check_back_space() abort
+  let col = col('.') - 1
+  return !col || getline('.')[col - 1]  =~ '\s'
+endfunction
 
+" Insert <tab> when previous text is space, refresh completion if not.
+inoremap <silent><expr> <TAB>
+  \ coc#pum#visible() ? coc#pum#next(1):
+  \ <SID>check_back_space() ? "\<Tab>" :
+  \ coc#refresh()
+inoremap <expr><S-TAB> coc#pum#visible() ? coc#pum#prev(1) : "\<C-h>"
 " }}}
 
 " CUSTOM THINGS DEPENDING ON ENV ####################################{{{
 let g:rustfmt_autosave = 1
-let g:ale_linters = {}
-let g:ale_c_parse_compile_commands=1
-let g:ale_elm_ls_use_global = 1
-let g:ale_linters_ignore = { 'elm': ['make'] }
-let g:ale_lint_on_text_changed = 0
-if $NVIM_DISABLE_PYTHON_LINTER == '1'
-    let g:ale_linters.python = []
-endif
-if $NVIM_DISABLE_JAVA_LINTER == '1'
-    let g:ale_linters.java = []
-endif
+
+" Apprently some people don't use vim
+" set autoread | au CursorHold * checktime | call feedkeys("lh")

nushell/config.nu

@@ -0,0 +1,14 @@
+source ~/.config/nushell/config/init.nu
+source ~/.config/nushell/config/extra.nu
+source ~/.config/nushell/config/mount.nu
+source ~/.config/nushell/config/config.nu
+source ~/.config/nushell/config/aliases.nu
+source ~/.config/nushell/config/git.nu
+source ~/.config/nushell/config/ssh.nu
+source ~/.config/nushell/config/update.nu
+source ~/.config/nushell/config/gclone.nu
+source ~/.config/nushell/config/pass.nu
+source ~/.config/nushell/config/docker.nu
+source ~/.config/nushell/config/xrandr.nu
+source ~/.config/nushell/config/tfetch.nu
+

nushell/config/aliases.nu

@@ -0,0 +1,137 @@
+# replace /home/$USER by ~
+def tildize [] {
+    if ($in | path split | zip ($env.HOME | path split) | all { $in.0 == $in.1 }) {
+        ($in | str replace $env.HOME "~")
+    } else {
+        $in
+    }
+}
+
+# remove extension shortcut
+def rm-ext [] {
+    $in | path parse | udpate extension "" | get parent stem | str join "/"
+}
+
+# ls builtin
+alias _ls = ls
+
+# shortcut for ls builtin
+alias l = _ls
+
+def _ls_format_mode [mode: string] {
+    let chars = $mode | split chars
+    let r1 = if ($chars | get 0) == "r" { [(ansi yellow_bold), "r", (ansi reset)] } else { [(ansi grey), "-"] }
+    let w1 = if ($chars | get 1) == "w" { [(ansi red_bold), "w", (ansi reset)] } else { [(ansi grey), "-"] }
+    let x1 = if ($chars | get 2) == "x" { [(ansi green_bold), "x", (ansi reset)] } else { [(ansi grey), "-"] }
+    let r2 = if ($chars | get 3) == "r" { [(ansi yellow), "r", (ansi reset)] } else { [(ansi grey), "-"] }
+    let w2 = if ($chars | get 4) == "w" { [(ansi red), "w"] } else { [(ansi grey), "-"] }
+    let x2 = if ($chars | get 5) == "x" { [(ansi green), "x"] } else { [(ansi grey), "-"] }
+    let r3 = if ($chars | get 6) == "r" { [(ansi yellow), "r", (ansi reset)] } else { [(ansi grey), "-"] }
+    let w3 = if ($chars | get 7) == "w" { [(ansi red), "w"] } else { [(ansi grey), "-"] }
+    let x3 = if ($chars | get 8) == "x" { [(ansi green), "x"] } else { [(ansi grey), "-"] }
+    [$r1, $w1, $x1, $r2, $w2, $x2, $r3, $w3, $x3] | each { $in | str join } | str join
+}
+
+# quick and easy ls
+def ls [dir?: string] {
+    let output = _ls (if $dir == null { "" } else { $dir }) | sort-by type name -i
+    if ($output | length) == 0 { "" | cat } else { $output | grid -c -s "  " | cat }
+}
+
+# ls with hidden files
+def la [dir?: string] {
+    _ls -al (if $dir == null { "" } else { $dir })
+        | sort-by type name -i
+        | each { $in | update mode (_ls_format_mode $in.mode) }
+        | select mode name target user size modified
+}
+
+# ls with details
+def ll [dir?: string] {
+    _ls -l (if $dir == null { "" } else { $dir })
+        | each { $in | update mode (_ls_format_mode $in.mode) }
+        | sort-by type name -i
+        | select mode name target user size modified
+}
+
+# du builtin
+alias _du = du
+
+# non recursive du
+def du [...args] {
+    let parsed_args = if ($args | is-empty) { ["*"] } else { $args }
+    $parsed_args | each { _du -a $in | select path apparent physical } | flatten
+}
+
+# df
+def df [] {
+    ^df -h
+        | str replace "Sys. de fichiers" "@"
+        | str replace "Monté sur" "@"
+        | detect columns
+        | rename "filesystem" "size" "used" "available" "used%" "mountpoint"
+}
+
+# easy markdown formamtter
+def to-md [] {
+    let arg = $in
+    $env.config.table.mode = markdown;
+    echo $arg
+}
+
+# Useful aliases
+
+# colored ip
+alias ip = ip -c
+
+# neovim
+alias v = nvim
+
+# quit
+alias :q = exit
+
+# evince in background
+def pdf [arg: string] {
+    pueue add evince ($arg | str replace ' ' '\ ')
+}
+
+# ripgrep
+alias rg = rg -uu
+
+# mkdir && cd
+def --env mkcd [dir: string] { mkdir $dir; cd $dir }
+
+# run command in background
+alias pa = pueue add --immediate
+
+# show background commands
+def pst [] {
+    pueue status -j
+        | from json
+        | get tasks
+        | transpose
+        | each { $in | get column1 }
+        | each {
+            let stdin = $in
+
+            $stdin | update status (
+                if $stdin.status == "Running" {
+                    ((ansi yellow) + "Running")
+                } else if not (echo $stdin.status | get -i Done | is-empty) {
+                    let exit_value = $stdin.status | get "Done"
+
+                    if ($exit_value == "Success") {
+                        ((ansi green) + "Success")
+                    } else {
+                        (ansi red) + "Failed (" + ($exit_value | get "Failed" | into string) + ")"
+                    }
+                } else {
+                    "Unknown???"
+                }
+              )
+            | update path ($in.path | tildize)
+            | update start ((ansi magenta) + ($in.start | date humanize))
+            | update end ((ansi magenta) + ($in.end | date humanize))
+        }
+        | select status command path start end
+}

nushell/config/config.nu

@@ -0,0 +1,16 @@
+# Change default config
+$env.config.keybindings = (echo $env.config.keybindings | append {
+    name: newline_or_run_command_2
+    modifier: CONTROL
+    keycode: char_j
+    mode: emacs
+    event: {send: enter}
+})
+
+$env.config.show_banner = false
+$env.config.use_grid_icons = false
+$env.config.cursor_shape.emacs = block
+$env.config.history.max_size = 1_000_000_000_000_000
+$env.config.history.file_format = "sqlite"
+$env.config.history.isolation = true
+$env.config.filesize.metric = false

nushell/config/docker.nu

@@ -0,0 +1,81 @@
+# docker aliases
+
+# lazydocker
+alias ld = lazydocker
+
+# docker-compose
+alias dc = docker-compose
+
+# docker-compose build
+alias dcb = docker-compose build
+
+# docker-compose build and push
+def dcp [] { docker-compose build; docker-compose push }
+
+# docker-compose up with build and remove-orphans
+alias dcu = docker-compose up -d --build --remove-orphans
+
+# docker-compose down
+alias dcd = docker-compose down
+
+# docker-compose down and up
+def dcr [] { docker-compose down; docker-compose up -d --build --remove-orphans }
+
+# kubernetes aliases
+$env.KUBECONFIG = if ([$env.HOME, .kubes, current-cube] | path join | path exists) {
+    open ([$env.HOME, .kubes, current-cube] | path join)
+} else {
+    ""
+}
+
+def _kube_kubes [] {
+    _ls ~/.kubes | where type == dir | get name | path basename
+}
+
+# easily switch kube config
+def --env kube [name?: string@_kube_kubes] {
+    use assert
+
+    let kubes_path = [$env.HOME, .kubes] | path join
+
+    if $name == null {
+        rm ([$kubes_path, current-cube] | path join)
+        $env.KUBECONFIG = ""
+        return
+    }
+
+    let kube_config =  [$kubes_path, $name, config] | path join
+
+    if not ($kube_config | path exists) {
+        error make {msg: ($kube_config + " does not exist")}
+    }
+
+    $kube_config | save -f ([$kubes_path, current-cube] | path join)
+    $env.KUBECONFIG = $kube_config
+}
+
+# k9s
+alias kns = k9s -n all
+
+# lazydocker / k9s shortcut for each compose / cluster
+alias mnemosyne = ssh phoenix -t "cd infra && /home/polymny/.local/bin/lazydocker"
+alias zeus = k9s -n all --kubeconfig ($env.HOME + '/.kubes/zeus/config')
+alias safir = k9s -n all --kubeconfig ($env.HOME + '/.kubes/safir/config')
+
+# start minikube with test kube
+def "minikube start" [] {
+    $env.KUBECONFIG = ([$env.HOME, '.kubes', 'test', 'config'] | path join)
+    ^minikube start
+}
+
+# stop minikube with test kube
+def "minikube stop" [] {
+    $env.KUBECONFIG = ([$env.HOME, '.kubes', 'test', 'config'] | path join)
+    ^minikube stop
+}
+
+# delete minikube with test kube
+def "minikube delete" [] {
+    $env.KUBECONFIG = ([$env.HOME, '.kubes', 'test', 'config'] | path join)
+    ^minikube delete
+}

nushell/config/gclone.nu

@@ -0,0 +1,141 @@
+# gclone aliases
+
+def _gclone_dirs [] {
+    _ls ($env.GCLONE_PATH + "/*")
+        | append (_ls ($env.GCLONE_PATH + "/*/*"))
+        | append (_ls ($env.GCLONE_PATH + "/*/*/*"))
+        | each { $in.name | path basename }
+        | sort
+        | uniq
+}
+
+# cd to a git directory
+def --env cdg [key: string@_gclone_dirs] {
+    let dir = _ls ($env.GCLONE_PATH + "/*")
+        | append (_ls ($env.GCLONE_PATH + "/*/*"))
+        | append (_ls ($env.GCLONE_PATH + "/*/*/*"))
+        | where { $in != null and ($in.name | path basename) == $key }
+
+
+    match ($dir | length) {
+        0 => {
+            print (
+                (ansi red_bold) + "error" +
+                (ansi reset) + (ansi attr_bold) + ":" +
+                (ansi reset) + " no such file or directory"
+            )
+            return
+        }
+
+        1 => {
+            cd $dir.0.name
+        }
+
+        _ => {
+            print (
+                (ansi attr_bold) + "info:" +
+                (ansi reset) + " multiple entries found, please select one"
+            )
+
+            echo $dir
+
+            print (
+                (ansi --escape 'A') +
+                (ansi attr_bold) + "Enter your choice: " + (ansi reset)
+            )
+
+            let choice = input
+
+            if not ($choice =~ "^[0-9]*$") {
+                print (
+                    (ansi red_bold) + "error" +
+                    (ansi reset) + (ansi attr_bold) + ":" +
+                    (ansi reset) + " couldn't parse integer"
+                )
+                return
+            }
+
+            let choice = $choice | into int
+
+            if $choice >= ($dir | length) {
+                print (
+                    (ansi red_bold) + "error" +
+                    (ansi reset) + (ansi attr_bold) + ":" +
+                    (ansi reset) + " integer is outside range"
+                )
+                return
+            }
+
+            cd ($dir | get $choice | get name)
+        }
+    }
+}
+
+# clone repository in the right place
+def gclone [repo_url: string] {
+
+    let attr = if ($repo_url | str starts-with "https://") {
+        $repo_url | parse "https://{server}/{owner}/{repo}" | get 0
+    } else if ($repo_url | str starts-with "http://") {
+        $repo_url | parse "http://{server}/{owner}/{repo}" | get 0
+    } else if ($repo_url | str starts-with "ssh://") {
+        $repo_url | parse "ssh://git@{server}/{owner}/{repo}" | get 0
+    } else if ($repo_url | str starts-with "git@") {
+        $repo_url | parse "git@{server}:{owner}/{repo}" | get 0
+    } else {
+        print (
+            (ansi red_bold) + "error" +
+            (ansi reset) + (ansi attr_bold) + ":" +
+            (ansi reset) + " failed to parse repo url"
+        )
+        return
+    }
+
+    let server = $attr.server
+    let server_portless = $attr.server | split row ':' | get 0
+    let owner = $attr.owner
+    let repo = $attr.repo
+
+    let target = [$env.GCLONE_PATH, $server_portless, $owner, $repo] | path join
+    let target = if ($target | str ends-with '.git') {
+        $target | path parse | update extension "" | get parent stem | str join "/"
+    } else {
+        $target
+    }
+
+    if ($target | path exists) {
+        print (
+            (ansi red_bold) + "error" +
+            (ansi reset) + (ansi attr_bold) + ":" +
+            (ansi reset) + " clone target already exists"
+        )
+        return
+    }
+
+    let clone_url = if $env.GCLONE_FORCE_SSH {
+        $attr | format "ssh://git@{server}/{owner}/{repo}"
+    } else {
+        $repo_url
+    }
+
+    print -n (
+        (ansi attr_bold) + "info:" +
+        (ansi reset) + " cloning " + $clone_url + "..."
+    )
+
+    let clone = do { git clone --recurse-submodules $clone_url $target } | complete
+
+    if $clone.exit_code == 0 {
+        print " done!"
+    } else {
+        print (
+            "\n" + (ansi red_bold) + "error" +
+            (ansi reset) + (ansi attr_bold) + ":" +
+            (ansi reset) + " clone failed:"
+        )
+
+        print -n $clone.stderr
+    }
+
+}
+

nushell/config/git.nu

@@ -0,0 +1,46 @@
+# git aliases
+
+# git
+alias g = git
+
+# git add
+alias ga = git add
+
+# git add --all
+alias gaa = git add --all
+
+# git checkout
+alias gco = git checkout
+
+# git checkout -b
+alias gcb = git checkout -b
+
+# git commit
+alias gc = git commit --verbose
+
+# git commit --all
+alias gca = git commit --verbose --all
+
+# git diff
+alias gd = git diff
+
+# git log
+alias glog = git log --oneline --decorate --graph
+
+# git pull
+alias gl = git pull
+
+# git push
+alias gp = git push
+
+# git status
+alias gst = git status
+
+# git status
+alias gs = git status
+
+# git merge
+alias gm = git merge
+
+# git push --set-upstream ...
+def gpsup [] { git push --set-upstream origin (git rev-parse --abbrev-ref HEAD) }

nushell/config/init.nu

@@ -0,0 +1,757 @@
+# Nushell Config File
+#
+# version = "0.86.0"
+
+# For more information on defining custom themes, see
+# https://www.nushell.sh/book/coloring_and_theming.html
+# And here is the theme collection
+# https://github.com/nushell/nu_scripts/tree/main/themes
+let dark_theme = {
+    # color for nushell primitives
+    separator: white
+    leading_trailing_space_bg: { attr: n } # no fg, no bg, attr none effectively turns this off
+    header: green_bold
+    empty: blue
+    # Closures can be used to choose colors for specific values.
+    # The value (in this case, a bool) is piped into the closure.
+    # eg) {|| if $in { 'light_cyan' } else { 'light_gray' } }
+    bool: light_cyan
+    int: white
+    filesize: cyan
+    duration: white
+    date: purple
+    range: white
+    float: white
+    string: white
+    nothing: white
+    binary: white
+    cell-path: white
+    row_index: green_bold
+    record: white
+    list: white
+    block: white
+    hints: dark_gray
+    search_result: {bg: red fg: white}
+    shape_and: purple_bold
+    shape_binary: purple_bold
+    shape_block: blue_bold
+    shape_bool: light_cyan
+    shape_closure: green_bold
+    shape_custom: green
+    shape_datetime: cyan_bold
+    shape_directory: cyan
+    shape_external: cyan
+    shape_externalarg: green_bold
+    shape_filepath: cyan
+    shape_flag: blue_bold
+    shape_float: purple_bold
+    # shapes are used to change the cli syntax highlighting
+    shape_garbage: { fg: white bg: red attr: b}
+    shape_globpattern: cyan_bold
+    shape_int: purple_bold
+    shape_internalcall: cyan_bold
+    shape_list: cyan_bold
+    shape_literal: blue
+    shape_match_pattern: green
+    shape_matching_brackets: { attr: u }
+    shape_nothing: light_cyan
+    shape_operator: yellow
+    shape_or: purple_bold
+    shape_pipe: purple_bold
+    shape_range: yellow_bold
+    shape_record: cyan_bold
+    shape_redirection: purple_bold
+    shape_signature: green_bold
+    shape_string: green
+    shape_string_interpolation: cyan_bold
+    shape_table: blue_bold
+    shape_variable: purple
+    shape_vardecl: purple
+}
+
+let light_theme = {
+    # color for nushell primitives
+    separator: dark_gray
+    leading_trailing_space_bg: { attr: n } # no fg, no bg, attr none effectively turns this off
+    header: green_bold
+    empty: blue
+    # Closures can be used to choose colors for specific values.
+    # The value (in this case, a bool) is piped into the closure.
+    # eg) {|| if $in { 'dark_cyan' } else { 'dark_gray' } }
+    bool: dark_cyan
+    int: dark_gray
+    filesize: cyan_bold
+    duration: dark_gray
+    date: purple
+    range: dark_gray
+    float: dark_gray
+    string: dark_gray
+    nothing: dark_gray
+    binary: dark_gray
+    cell-path: dark_gray
+    row_index: green_bold
+    record: white
+    list: white
+    block: white
+    hints: dark_gray
+    search_result: {fg: white bg: red}
+    shape_and: purple_bold
+    shape_binary: purple_bold
+    shape_block: blue_bold
+    shape_bool: light_cyan
+    shape_closure: green_bold
+    shape_custom: green
+    shape_datetime: cyan_bold
+    shape_directory: cyan
+    shape_external: cyan
+    shape_externalarg: green_bold
+    shape_filepath: cyan
+    shape_flag: blue_bold
+    shape_float: purple_bold
+    # shapes are used to change the cli syntax highlighting
+    shape_garbage: { fg: white bg: red attr: b}
+    shape_globpattern: cyan_bold
+    shape_int: purple_bold
+    shape_internalcall: cyan_bold
+    shape_list: cyan_bold
+    shape_literal: blue
+    shape_match_pattern: green
+    shape_matching_brackets: { attr: u }
+    shape_nothing: light_cyan
+    shape_operator: yellow
+    shape_or: purple_bold
+    shape_pipe: purple_bold
+    shape_range: yellow_bold
+    shape_record: cyan_bold
+    shape_redirection: purple_bold
+    shape_signature: green_bold
+    shape_string: green
+    shape_string_interpolation: cyan_bold
+    shape_table: blue_bold
+    shape_variable: purple
+    shape_vardecl: purple
+}
+
+# External completer example
+# let carapace_completer = {|spans|
+#     carapace $spans.0 nushell $spans | from json
+# }
+
+# The default config record. This is where much of your global configuration is setup.
+$env.config = {
+    show_banner: true # true or false to enable or disable the welcome banner at startup
+
+    ls: {
+        use_ls_colors: true # use the LS_COLORS environment variable to colorize output
+        clickable_links: true # enable or disable clickable links. Your terminal has to support links.
+    }
+
+    rm: {
+        always_trash: false # always act as if -t was given. Can be overridden with -p
+    }
+
+    table: {
+        mode: rounded # basic, compact, compact_double, light, thin, with_love, rounded, reinforced, heavy, none, other
+        index_mode: always # "always" show indexes, "never" show indexes, "auto" = show indexes when a table has "index" column
+        show_empty: true # show 'empty list' and 'empty record' placeholders for command output
+        padding: { left: 1, right: 1 } # a left right padding of each column in a table
+        trim: {
+            methodology: wrapping # wrapping or truncating
+            wrapping_try_keep_words: true # A strategy used by the 'wrapping' methodology
+            truncating_suffix: "..." # A suffix used by the 'truncating' methodology
+        }
+        header_on_separator: false # show header text on separator/border line
+        # abbreviated_row_count: 10 # limit data rows from top and bottom after reaching a set point
+    }
+
+    error_style: "fancy" # "fancy" or "plain" for screen reader-friendly error messages
+
+    # datetime_format determines what a datetime rendered in the shell would look like.
+    # Behavior without this configuration point will be to "humanize" the datetime display,
+    # showing something like "a day ago."
+    datetime_format: {
+        # normal: '%a, %d %b %Y %H:%M:%S %z'    # shows up in displays of variables or other datetime's outside of tables
+        # table: '%m/%d/%y %I:%M:%S%p'          # generally shows up in tabular outputs such as ls. commenting this out will change it to the default human readable datetime format
+    }
+
+    explore: {
+        status_bar_background: {fg: "#1D1F21", bg: "#C4C9C6"},
+        command_bar_text: {fg: "#C4C9C6"},
+        highlight: {fg: "black", bg: "yellow"},
+        status: {
+            error: {fg: "white", bg: "red"},
+            warn: {}
+            info: {}
+        },
+        table: {
+            split_line: {fg: "#404040"},
+            selected_cell: {bg: light_blue},
+            selected_row: {},
+            selected_column: {},
+        },
+    }
+
+    history: {
+        max_size: 100_000 # Session has to be reloaded for this to take effect
+        sync_on_enter: true # Enable to share history between multiple sessions, else you have to close the session to write history to file
+        file_format: "plaintext" # "sqlite" or "plaintext"
+        isolation: false # only available with sqlite file_format. true enables history isolation, false disables it. true will allow the history to be isolated to the current session using up/down arrows. false will allow the history to be shared across all sessions.
+    }
+
+    completions: {
+        case_sensitive: false # set to true to enable case-sensitive completions
+        quick: true    # set this to false to prevent auto-selecting completions when only one remains
+        partial: true    # set this to false to prevent partial filling of the prompt
+        algorithm: "prefix"    # prefix or fuzzy
+        external: {
+            enable: true # set to false to prevent nushell looking into $env.PATH to find more suggestions, `false` recommended for WSL users as this look up may be very slow
+            max_results: 100 # setting it lower can improve completion performance at the cost of omitting some options
+            completer: null # check 'carapace_completer' above as an example
+        }
+    }
+
+    filesize: {
+        metric: true # true => KB, MB, GB (ISO standard), false => KiB, MiB, GiB (Windows standard)
+        format: "auto" # b, kb, kib, mb, mib, gb, gib, tb, tib, pb, pib, eb, eib, auto
+    }
+
+    cursor_shape: {
+        emacs: line # block, underscore, line, blink_block, blink_underscore, blink_line, inherit to skip setting cursor shape (line is the default)
+        vi_insert: block # block, underscore, line, blink_block, blink_underscore, blink_line, inherit to skip setting cursor shape (block is the default)
+        vi_normal: underscore # block, underscore, line, blink_block, blink_underscore, blink_line, inherit to skip setting cursor shape (underscore is the default)
+    }
+
+    color_config: $dark_theme # if you want a more interesting theme, you can replace the empty record with `$dark_theme`, `$light_theme` or another custom record
+    use_grid_icons: true
+    footer_mode: "25" # always, never, number_of_rows, auto
+    float_precision: 2 # the precision for displaying floats in tables
+    buffer_editor: "" # command that will be used to edit the current line buffer with ctrl+o, if unset fallback to $env.EDITOR and $env.VISUAL
+    use_ansi_coloring: true
+    bracketed_paste: true # enable bracketed paste, currently useless on windows
+    edit_mode: emacs # emacs, vi
+    shell_integration: false # enables terminal shell integration. Off by default, as some terminals have issues with this.
+    render_right_prompt_on_last_line: false # true or false to enable or disable right prompt to be rendered on last line of the prompt.
+    use_kitty_protocol: false # enables keyboard enhancement protocol implemented by kitty console, only if your terminal support this
+
+    hooks: {
+        pre_prompt: [{ null }] # run before the prompt is shown
+        pre_execution: [{ null }] # run before the repl input is run
+        env_change: {
+            PWD: [{|before, after| null }] # run if the PWD environment is different since the last repl input
+        }
+        display_output: "if (term size).columns >= 100 { table -e } else { table }" # run to display the output of a pipeline
+        command_not_found: { null } # return an error message when a command is not found
+    }
+
+    menus: [
+        # Configuration for default nushell menus
+        # Note the lack of source parameter
+        {
+            name: completion_menu
+            only_buffer_difference: false
+            marker: "| "
+            type: {
+                layout: columnar
+                columns: 4
+                col_width: 20     # Optional value. If missing all the screen width is used to calculate column width
+                col_padding: 2
+            }
+            style: {
+                text: green
+                selected_text: green_reverse
+                description_text: yellow
+            }
+        }
+        {
+            name: history_menu
+            only_buffer_difference: true
+            marker: "? "
+            type: {
+                layout: list
+                page_size: 10
+            }
+            style: {
+                text: green
+                selected_text: green_reverse
+                description_text: yellow
+            }
+        }
+        {
+            name: help_menu
+            only_buffer_difference: true
+            marker: "? "
+            type: {
+                layout: description
+                columns: 4
+                col_width: 20     # Optional value. If missing all the screen width is used to calculate column width
+                col_padding: 2
+                selection_rows: 4
+                description_rows: 10
+            }
+            style: {
+                text: green
+                selected_text: green_reverse
+                description_text: yellow
+            }
+        }
+    ]
+
+    keybindings: [
+        {
+            name: completion_menu
+            modifier: none
+            keycode: tab
+            mode: [emacs vi_normal vi_insert]
+            event: {
+                until: [
+                    { send: menu name: completion_menu }
+                    { send: menunext }
+                    { edit: complete }
+                ]
+            }
+        }
+        {
+            name: history_menu
+            modifier: control
+            keycode: char_r
+            mode: [emacs, vi_insert, vi_normal]
+            event: { send: menu name: history_menu }
+        }
+        {
+            name: help_menu
+            modifier: none
+            keycode: f1
+            mode: [emacs, vi_insert, vi_normal]
+            event: { send: menu name: help_menu }
+        }
+        {
+            name: completion_previous_menu
+            modifier: shift
+            keycode: backtab
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: menuprevious }
+        }
+        {
+            name: next_page_menu
+            modifier: control
+            keycode: char_x
+            mode: emacs
+            event: { send: menupagenext }
+        }
+        {
+            name: undo_or_previous_page_menu
+            modifier: control
+            keycode: char_z
+            mode: emacs
+            event: {
+                until: [
+                    { send: menupageprevious }
+                    { edit: undo }
+                ]
+            }
+        }
+        {
+            name: escape
+            modifier: none
+            keycode: escape
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: esc }    # NOTE: does not appear to work
+        }
+        {
+            name: cancel_command
+            modifier: control
+            keycode: char_c
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: ctrlc }
+        }
+        {
+            name: quit_shell
+            modifier: control
+            keycode: char_d
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: ctrld }
+        }
+        {
+            name: clear_screen
+            modifier: control
+            keycode: char_l
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: clearscreen }
+        }
+        {
+            name: search_history
+            modifier: control
+            keycode: char_q
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: searchhistory }
+        }
+        {
+            name: open_command_editor
+            modifier: control
+            keycode: char_o
+            mode: [emacs, vi_normal, vi_insert]
+            event: { send: openeditor }
+        }
+        {
+            name: move_up
+            modifier: none
+            keycode: up
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: menuup}
+                    {send: up}
+                ]
+            }
+        }
+        {
+            name: move_down
+            modifier: none
+            keycode: down
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: menudown}
+                    {send: down}
+                ]
+            }
+        }
+        {
+            name: move_left
+            modifier: none
+            keycode: left
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: menuleft}
+                    {send: left}
+                ]
+            }
+        }
+        {
+            name: move_right_or_take_history_hint
+            modifier: none
+            keycode: right
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: historyhintcomplete}
+                    {send: menuright}
+                    {send: right}
+                ]
+            }
+        }
+        {
+            name: move_one_word_left
+            modifier: control
+            keycode: left
+            mode: [emacs, vi_normal, vi_insert]
+            event: {edit: movewordleft}
+        }
+        {
+            name: move_one_word_right_or_take_history_hint
+            modifier: control
+            keycode: right
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: historyhintwordcomplete}
+                    {edit: movewordright}
+                ]
+            }
+        }
+        {
+            name: move_to_line_start
+            modifier: none
+            keycode: home
+            mode: [emacs, vi_normal, vi_insert]
+            event: {edit: movetolinestart}
+        }
+        {
+            name: move_to_line_start
+            modifier: control
+            keycode: char_a
+            mode: [emacs, vi_normal, vi_insert]
+            event: {edit: movetolinestart}
+        }
+        {
+            name: move_to_line_end_or_take_history_hint
+            modifier: none
+            keycode: end
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: historyhintcomplete}
+                    {edit: movetolineend}
+                ]
+            }
+        }
+        {
+            name: move_to_line_end_or_take_history_hint
+            modifier: control
+            keycode: char_e
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: historyhintcomplete}
+                    {edit: movetolineend}
+                ]
+            }
+        }
+        {
+            name: move_to_line_start
+            modifier: control
+            keycode: home
+            mode: [emacs, vi_normal, vi_insert]
+            event: {edit: movetolinestart}
+        }
+        {
+            name: move_to_line_end
+            modifier: control
+            keycode: end
+            mode: [emacs, vi_normal, vi_insert]
+            event: {edit: movetolineend}
+        }
+        {
+            name: move_up
+            modifier: control
+            keycode: char_p
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: menuup}
+                    {send: up}
+                ]
+            }
+        }
+        {
+            name: move_down
+            modifier: control
+            keycode: char_t
+            mode: [emacs, vi_normal, vi_insert]
+            event: {
+                until: [
+                    {send: menudown}
+                    {send: down}
+                ]
+            }
+        }
+        {
+            name: delete_one_character_backward
+            modifier: none
+            keycode: backspace
+            mode: [emacs, vi_insert]
+            event: {edit: backspace}
+        }
+        {
+            name: delete_one_word_backward
+            modifier: control
+            keycode: backspace
+            mode: [emacs, vi_insert]
+            event: {edit: backspaceword}
+        }
+        {
+            name: delete_one_character_forward
+            modifier: none
+            keycode: delete
+            mode: [emacs, vi_insert]
+            event: {edit: delete}
+        }
+        {
+            name: delete_one_character_forward
+            modifier: control
+            keycode: delete
+            mode: [emacs, vi_insert]
+            event: {edit: delete}
+        }
+        {
+            name: delete_one_character_forward
+            modifier: control
+            keycode: char_h
+            mode: [emacs, vi_insert]
+            event: {edit: backspace}
+        }
+        {
+            name: delete_one_word_backward
+            modifier: control
+            keycode: char_w
+            mode: [emacs, vi_insert]
+            event: {edit: backspaceword}
+        }
+        {
+            name: move_left
+            modifier: none
+            keycode: backspace
+            mode: vi_normal
+            event: {edit: moveleft}
+        }
+        {
+            name: newline_or_run_command
+            modifier: none
+            keycode: enter
+            mode: emacs
+            event: {send: enter}
+        }
+        {
+            name: move_left
+            modifier: control
+            keycode: char_b
+            mode: emacs
+            event: {
+                until: [
+                    {send: menuleft}
+                    {send: left}
+                ]
+            }
+        }
+        {
+            name: move_right_or_take_history_hint
+            modifier: control
+            keycode: char_f
+            mode: emacs
+            event: {
+                until: [
+                    {send: historyhintcomplete}
+                    {send: menuright}
+                    {send: right}
+                ]
+            }
+        }
+        {
+            name: redo_change
+            modifier: control
+            keycode: char_g
+            mode: emacs
+            event: {edit: redo}
+        }
+        {
+            name: undo_change
+            modifier: control
+            keycode: char_z
+            mode: emacs
+            event: {edit: undo}
+        }
+        {
+            name: paste_before
+            modifier: control
+            keycode: char_y
+            mode: emacs
+            event: {edit: pastecutbufferbefore}
+        }
+        {
+            name: cut_word_left
+            modifier: control
+            keycode: char_w
+            mode: emacs
+            event: {edit: cutwordleft}
+        }
+        {
+            name: cut_line_to_end
+            modifier: control
+            keycode: char_k
+            mode: emacs
+            event: {edit: cuttoend}
+        }
+        {
+            name: cut_line_from_start
+            modifier: control
+            keycode: char_u
+            mode: emacs
+            event: {edit: cutfromstart}
+        }
+        {
+            name: swap_graphemes
+            modifier: control
+            keycode: char_t
+            mode: emacs
+            event: {edit: swapgraphemes}
+        }
+        {
+            name: move_one_word_left
+            modifier: alt
+            keycode: left
+            mode: emacs
+            event: {edit: movewordleft}
+        }
+        {
+            name: move_one_word_right_or_take_history_hint
+            modifier: alt
+            keycode: right
+            mode: emacs
+            event: {
+                until: [
+                    {send: historyhintwordcomplete}
+                    {edit: movewordright}
+                ]
+            }
+        }
+        {
+            name: move_one_word_left
+            modifier: alt
+            keycode: char_b
+            mode: emacs
+            event: {edit: movewordleft}
+        }
+        {
+            name: move_one_word_right_or_take_history_hint
+            modifier: alt
+            keycode: char_f
+            mode: emacs
+            event: {
+                until: [
+                    {send: historyhintwordcomplete}
+                    {edit: movewordright}
+                ]
+            }
+        }
+        {
+            name: delete_one_word_forward
+            modifier: alt
+            keycode: delete
+            mode: emacs
+            event: {edit: deleteword}
+        }
+        {
+            name: delete_one_word_backward
+            modifier: alt
+            keycode: backspace
+            mode: emacs
+            event: {edit: backspaceword}
+        }
+        {
+            name: delete_one_word_backward
+            modifier: alt
+            keycode: char_m
+            mode: emacs
+            event: {edit: backspaceword}
+        }
+        {
+            name: cut_word_to_right
+            modifier: alt
+            keycode: char_d
+            mode: emacs
+            event: {edit: cutwordright}
+        }
+        {
+            name: upper_case_word
+            modifier: alt
+            keycode: char_u
+            mode: emacs
+            event: {edit: uppercaseword}
+        }
+        {
+            name: lower_case_word
+            modifier: alt
+            keycode: char_l
+            mode: emacs
+            event: {edit: lowercaseword}
+        }
+        {
+            name: capitalize_char
+            modifier: alt
+            keycode: char_c
+            mode: emacs
+            event: {edit: capitalizechar}
+        }
+    ]
+}

nushell/config/mount.nu

@@ -0,0 +1,65 @@
+# startx checks if disks are mounted
+def startx [] {
+    # I'm used to running startx right after I login, to this first mount my
+    # disks and then runs startx.
+    mount-disk
+
+    # Then I run startx
+    /bin/startx
+}
+
+# mount my encrypted disks
+def mount-disk [] {
+
+    # If there is no $env.PRIMARY_DISK_UUID, we don't have to decrypt / mount anything
+    if not ("PRIMARY_DISK_UUID" in $env) {
+        return
+    }
+
+    # In my home on my encrypted partition, I have an empty file in ~/.mounted,
+    # this way, I can easily check if my encrypted partition is mounted or not.
+    if ("~/.mounted"| path exists) {
+        print -en "already mounted\n"
+        return
+    }
+
+    mut passphrase = ""
+
+    # On my computer, I have two disks, one NVMe with my OS, and one HDD with
+    # more space. I want three attempts at typing the passphrase.
+    for retry in [1, 2, 3] {
+
+        # Because they're encrypted with the same passphrase, I read the
+        # passphrase once, and then decrypt both disks.
+        sudo echo -n
+        let local_passphrase = (input -s "Enter your passphrase: ")
+        print -en "\n"
+
+        # Mount the NVMe encrypted partition
+        let mounted = do { $local_passphrase | sudo cryptsetup luksOpen ("/dev/disk/by-uuid/" + $env.PRIMARY_DISK_UUID) luks } | complete
+
+        # If mounted correctly, break this loop and mount other partitions.
+        if $mounted.exit_code == 0 {
+            print -en (ansi green_bold) "Passphrase correct\n" (ansi reset)
+            $passphrase = $local_passphrase
+            break
+        } else if $retry == 3 {
+            # If the third attempt failed, exit
+            error make {msg: "couldn't decrypt disk"}
+        } else {
+            print -en (ansi red_bold) "Passphrase incorrect, please try again\n" (ansi reset)
+        }
+    }
+
+    sudo mount /dev/mapper/luks /home
+
+    if ("SECONDARY_DISK_UUID" in $env) {
+        $passphrase | sudo cryptsetup luksOpen ("/dev/disk/by-uuid/" + $env.SECONDARY_DISK_UUID) luks2
+        sudo mount /dev/mapper/luks2 /mnt
+    }
+
+    # Some services cannot be started on boot because my encrypted drives are
+    # not mounted yet, so I mount them here.
+    systemctl start --user pueued
+    sudo systemctl start docker
+}

nushell/config/pass.nu

@@ -0,0 +1,38 @@
+# pass aliases / completion
+
+def _pass_completion [] {
+    _ls ~/.password-store/**/* | each { |x|
+        if $x.type == "file" {
+            $x.name
+                | path parse
+                | update extension ""
+                | get parent stem
+                | str join "/"
+        } else {
+            $x.name + "/"
+        }
+        | split row '/'
+        | skip 4
+        | str join "/"
+    }
+    | prepend git
+    | prepend insert
+}
+
+export extern "pass" [ host?: string@_pass_completion ]
+
+# pass shortcut
+def p [ ...arg: string@_pass_completion ] {
+    for a in $arg {
+        pass $a
+    }
+}
+
+# pass with copy
+def pc [ arg: string@_pass_completion ] { pass --clip $arg }
+
+# open pdf encrypted file
+def ppdf [p: string] {
+    pc thomas/key/pdf
+    pueue add evince $p
+}

nushell/config/ssh.nu

@@ -0,0 +1,11 @@
+# ssh completion
+def _ssh_hosts [] {
+    open ~/.ssh/config
+        | lines
+        | find -ir "host "
+        | each { $in | split row " " | get 1 }
+}
+
+export extern "ssh" [
+    host?: string@_ssh_hosts
+]

nushell/config/tfetch.nu

@@ -0,0 +1,16 @@
+# nushell puts prompt at bottom of terminal on resize, so it's preferable to start on the bottom of the terminal
+
+let has_tfetch = not (which tfetch | is-empty)
+
+# tfetch takes 19 lines, 21 with prompt
+let height = (stty size | split row " " | get 0 | into int) - (if $has_tfetch { 21 } else { 0 })
+
+# skip lines so that the prompt starts at the bottom of the terminal
+for i in 0..<$height {
+    print -n "\n"
+}
+
+# Start tfetch
+if $has_tfetch {
+    tfetch
+}

nushell/config/update.nu

@@ -0,0 +1,25 @@
+# update completion
+def _update_args [] {
+    [
+        system
+        rust
+        wasm
+        npm
+        dotfiles
+        neovim
+        check
+        startup
+        last-update
+        postpone
+        force-unlock
+    ]
+}
+
+# update system
+def u [arg?: string@_update_args] {
+    if $arg == null {
+        ^update
+    } else {
+        ^update $arg
+    }
+}

nushell/config/xrandr.nu

@@ -0,0 +1,66 @@
+# xrandr wrapper for nushell
+def xrandr [] {
+    mut output = []
+    mut current_screen = {
+        name: ""
+        connected: false
+        on: false
+        primary: false
+        resolution: null
+        position: null
+        resolutions: []
+    }
+
+    let lines = ^xrandr | lines
+    let length = $lines | length
+
+    # We skip the first line
+    for i in 1..<$length {
+
+        let line = $lines | get $i
+        let split = $line | split row -r '\s+'
+
+        # This will be true whether the screen is connected or not
+        if $line =~ "connected" {
+
+            if $current_screen.name != "" {
+                $output = ($output | append $current_screen)
+                $current_screen.resolutions = []
+                $current_screen.on = false
+                $current_screen.resolution = null
+                $current_screen.position = null
+            }
+
+            $current_screen.name = ($split | get 0)
+            $current_screen.connected = (($split | get 1) != "disconnected")
+            $current_screen.primary = (($split | get 2) == "primary")
+
+            let resolution = if $current_screen.primary {
+                ($split | get 3 | split column -c '+' | get column1 | get 0)
+            } else {
+                ($split | get 2 | split column -c '+' | get column1 | get 0)
+            }
+
+            if not ($resolution | str starts-with "(") {
+                $current_screen.on = true
+                $current_screen.resolution = $resolution
+
+                $current_screen.position = if $current_screen.primary {
+                    ($split | get 3 | split column -c '+' | each { "+" + $in.column2 + "+" + $in.column3 } | get 0)
+                } else {
+                    ($split | get 2 | split column -c '+' | each { "+" + $in.column2 + "+" + $in.column3 } | get 0)
+                }
+            }
+
+
+        } else {
+            $current_screen.resolutions = ($current_screen.resolutions | append ($split | get 1))
+        }
+    }
+
+    if $current_screen.name != "" {
+        $output = ($output | append $current_screen)
+    }
+
+    $output
+}

nushell/env.nu

@@ -0,0 +1,257 @@
+# Nushell Environment Config File
+#
+# version = "0.86.0"
+
+def create_left_prompt [] {
+    let home =  $nu.home-path
+
+    # Perform tilde substitution on dir
+    # To determine if the prefix of the path matches the home dir, we split the current path into
+    # segments, and compare those with the segments of the home dir. In cases where the current dir
+    # is a parent of the home dir (e.g. `/home`, homedir is `/home/user`), this comparison will
+    # also evaluate to true. Inside the condition, we attempt to str replace `$home` with `~`.
+    # Inside the condition, either:
+    # 1. The home prefix will be replaced
+    # 2. The current dir is a parent of the home dir, so it will be uneffected by the str replace
+    let dir = (
+        if ($env.PWD | path split | zip ($home | path split) | all { $in.0 == $in.1 }) {
+            ($env.PWD | str replace $home "~")
+        } else {
+            $env.PWD
+        }
+    )
+
+    # Arrow of prompt
+    let arrow_color = if "SSH_CLIENT" in $env {
+        ansi green_bold
+    } else {
+        ansi magenta_bold
+    }
+
+    let first_line_arrow = "┌──"
+    let second_line_arrow = "└▷"
+
+    # Time
+    let time_color = ansi magenta_bold
+    let time_segment = date now | format date ' [%H:%M] '
+
+    # Name of the current user
+    let username_color = ansi magenta_bold
+    let username = $env.USER
+
+    # Delimiter between user and hostname, then hostname and cwd
+    let delimiter_color = ansi yellow_bold
+    let first_delimiter = "@"
+    let second_delimiter = "::"
+
+    # Hostname
+    let hostname_color = ansi green_bold
+    let hostname = (sys).host.hostname
+
+    # Current director
+    let dir_color = ansi blue_bold
+    let reset_ansi = ansi reset
+
+    # Current git branch, with * if things are not commited
+    let git_color = [(ansi reset), (ansi yellow)] | str join
+    let git_branch = do { git rev-parse --abbrev-ref HEAD }
+      | complete
+      | update stdout ($in.stdout | str trim -c "\n")
+
+    let git_status = do { git status -s } | complete | get stdout | str trim -c "\n"
+
+    let git_changed = if $git_status == "" {
+        ""
+    } else {
+        "*"
+    }
+
+    let git_branch_content = if $git_branch.exit_code == 0 {
+        [$git_color, " ‹", $git_branch.stdout, $git_changed, "›"] | str join
+    } else {
+        ""
+    }
+
+    # Current kube
+    let kube_color = ansi cyan_bold
+
+    let kube = if ("KUBECONFIG" in $env) {
+        let kube_name = $env.KUBECONFIG | path dirname | path basename
+        [$kube_color, " ‹", $kube_name, "›"] | str join
+
+    } else {
+        ""
+    }
+
+    [
+        $arrow_color
+        $first_line_arrow
+        $time_color
+        $time_segment
+        $username_color
+        $username
+        $delimiter_color
+        $first_delimiter
+        $hostname_color
+        $hostname
+        $delimiter_color
+        $second_delimiter
+        $dir_color
+        $dir
+        $git_branch_content
+        $kube
+        "\n"
+        $reset_ansi
+        $arrow_color
+        $second_line_arrow
+    ] | str join
+}
+
+def create_right_prompt [] {
+    let last_exit_code = if ($env.LAST_EXIT_CODE != 0) {([
+        "\e[B"
+        (ansi red_bold)
+        ($env.LAST_EXIT_CODE)
+        " ↵ "
+    ] | str join)
+    } else {([
+        "\e[B"
+        (ansi green_bold)
+        ($env.LAST_EXIT_CODE)
+        " ↵ "
+    ] | str join)
+    }
+
+    ([$last_exit_code] | str join)
+}
+
+# Use nushell functions to define your right and left prompt
+$env.PROMPT_COMMAND = {|| create_left_prompt }
+# FIXME: This default is not implemented in rust code as of 2023-09-08.
+$env.PROMPT_COMMAND_RIGHT = {|| create_right_prompt }
+
+# The prompt indicators are environmental variables that represent
+# the state of the prompt
+$env.PROMPT_INDICATOR = {|| "  " }
+$env.PROMPT_INDICATOR_VI_INSERT = {|| ": " }
+$env.PROMPT_INDICATOR_VI_NORMAL = {|| "> " }
+$env.PROMPT_MULTILINE_INDICATOR = {|| "::: " }
+
+# If you want previously entered commands to have a different prompt from the usual one,
+# you can uncomment one or more of the following lines.
+# This can be useful if you have a 2-line prompt and it's taking up a lot of space
+# because every command entered takes up 2 lines instead of 1. You can then uncomment
+# the line below so that previously entered commands show with a single `🚀`.
+# $env.TRANSIENT_PROMPT_COMMAND = {|| "🚀 " }
+# $env.TRANSIENT_PROMPT_INDICATOR = {|| "" }
+# $env.TRANSIENT_PROMPT_INDICATOR_VI_INSERT = {|| "" }
+# $env.TRANSIENT_PROMPT_INDICATOR_VI_NORMAL = {|| "" }
+# $env.TRANSIENT_PROMPT_MULTILINE_INDICATOR = {|| "" }
+# $env.TRANSIENT_PROMPT_COMMAND_RIGHT = {|| "" }
+
+# Specifies how environment variables are:
+# - converted from a string to a value on Nushell startup (from_string)
+# - converted from a value back to a string when running external commands (to_string)
+# Note: The conversions happen *after* config.nu is loaded
+$env.ENV_CONVERSIONS = {
+    "PATH": {
+        from_string: { |s| $s | split row (char esep) | path expand --no-symlink }
+        to_string: { |v| $v | path expand --no-symlink | str join (char esep) }
+    }
+    "Path": {
+        from_string: { |s| $s | split row (char esep) | path expand --no-symlink }
+        to_string: { |v| $v | path expand --no-symlink | str join (char esep) }
+    }
+}
+
+# Directories to search for scripts when calling source or use
+$env.NU_LIB_DIRS = [
+    # FIXME: This default is not implemented in rust code as of 2023-09-06.
+    ($nu.default-config-dir | path join 'scripts') # add <nushell-config-dir>/scripts
+]
+
+# Directories to search for plugin binaries when calling register
+$env.NU_PLUGIN_DIRS = [
+    # FIXME: This default is not implemented in rust code as of 2023-09-06.
+    ($nu.default-config-dir | path join 'plugins') # add <nushell-config-dir>/plugins
+]
+
+# LS_COLORS so that ls mimics the colors of exa
+$env.LS_COLORS = ([
+    # File types
+    "ex=1;32"            # Executables
+    "di=1;34"            # Directories
+    "ln=36"              # Links
+    "or=31"              # Orphan
+
+    # Media types
+    "*.pdf=32"           # PDF files
+
+    # Images
+    "*.webp=35"          # Webp image
+    "*.png=35"           # PNG image
+    "*.jpg=35"           # JPG image
+
+    # Music
+    "*.ogg=36"           # OGG sound
+    "*.mp3=36"           # MP3 sound
+
+    # Videos
+    "*.mp4=1;35"         # MP4 video
+    "*.avi=1;35"         # AVI video
+    "*.webm=1;35"        # WebM video
+
+    # Bold yellow: source code
+    "*.c=1;33"           # C source
+    "*.h=1;33"           # C header
+    "*.cpp=1;33"         # C++ source
+    "*.hpp=1;33"         # C++ header
+    "*.inl=1;33"         # C++ include
+    "*.cxx=1;33"         # C++ include
+    "*.py=1;33"          # Python
+    "*.js=1;33"          # JavaScript
+    "*.ts=1;33"          # TypeScript
+    "*.rs=1;33"          # Rust
+    "*.elm=1;33"         # Elm
+    "*.nu=1;33"          # Nushell
+
+    # Build / doc files
+    "*Makefile=1;4;33"   # Makefile
+    "*Dockerfile=1;4;33" # Dockerfile
+    "*.md=1;4;33"        # Markdown
+    "*.toml=1;4;33"      # Toml
+] | str join ":")
+
+# French by default
+$env.LANG = fr_FR.UTF-8
+
+# Gnome Keyring Daemon
+$env.GNOME_KEYRING_DAEMON = '/run/user/1000/keyring'
+
+# Text file editor
+$env.EDITOR = nvim
+
+# Backtrace for rust
+$env.RUST_BACKTRACE = full
+
+# Gclone env
+$env.GCLONE_PATH = $env.HOME + '/git'
+$env.GCLONE_FORCE_SSH = true
+
+# Python virtual env
+$env.VIRTUAL_ENV = $env.HOME + '/.venv'
+
+# Don't put ugly go directory in my home
+$env.GOPATH = $env.HOME + '/.go'
+
+# To add entries to PATH (on Windows you might use Path), you can use the following pattern:
+# $env.PATH = ($env.PATH | split row (char esep) | prepend '/some/path')
+$env.PATH = ($env.PATH
+    | split row (char esep)
+    | prepend ($env.HOME + '/.config/polymny/bin')
+    | prepend ($env.HOME + '/.config/dotfiles/bin')
+    | prepend ($env.HOME + '/.config/dotfiles/bin-extra')
+    | prepend ($env.HOME + '/.cargo/bin')
+    | prepend ($env.HOME + '/.npmbin/bin')
+    | prepend ($env.HOME + '/.venv/bin')
+)

zsh/aliases.zsh

@@ -51,11 +51,23 @@ alias bat="bat --paging=never"
 
 alias rg="rg -uu"
 
+# Aliases for pass
+alias p="pass"
+alias pc="pass --clip"
+
 # mkdir && cd
 mkcd() {
     mkdir $1 && cd $1
 }
 
+# which && cd
+cdw() {
+    f=`which $1`
+    if [ $? -eq 0 ]; then
+        cd `dirname $f`
+    fi
+}
+
 # Initialize thefuck
 command -v thefuck > /dev/null 2>&1
 
@@ -64,6 +76,80 @@ if [ $? -eq 0 ]; then
     eval $(thefuck --alias)
 fi
 
+# Docker and kubernetes aliases
+command -v k9s > /dev/null 2>&1
+if [ $? -eq 0 ]; then
+    kns() {
+        local kube_config
+        if [ -z $KUBECONFIG ]; then
+            kube_config=$HOME/.kube/config
+        else
+            kube_config=$KUBECONFIG
+        fi
+        if [ -f $kube_config ]; then
+            k9s
+        else
+            echo >&2 error: $kube_config does not exist
+            return 1
+        fi
+    }
+fi
+
+command -v lazydocker > /dev/null 2>&1
+if [ $? -eq 0 ]; then
+    alias ld="lazydocker"
+fi
+
+command -v docker-compose > /dev/null 2>&1
+if [ $? -eq 0 ]; then
+    alias dc="docker-compose"
+    alias dcb="docker-compose build"
+    alias dcp="docker-compose build && docker-compose push"
+    alias dcu="docker-compose up -d --build --remove-orphans"
+    alias dcd="docker-compose down"
+    alias dcr="docker-compose down && docker-compose up -d --build --remove-orphans"
+fi
+
+command -v kubectl > /dev/null 2>&1
+if [ $? -eq 0 ]; then
+
+    if [ -f $HOME/.kubes/current-cube ]; then
+        export KUBECONFIG=$(cat $HOME/.kubes/current-cube)
+    fi
+
+    # Sets the kube config
+    kube() {
+        local kube_config=$HOME/.kubes/$1/config
+        if [ $# -ne 1 ]; then
+            rm ~/.kubes/current-cube
+            export KUBECONFIG=""
+        elif [ ! -f $kube_config ]; then
+            echo >&2 error: no such kube config: $kube_config
+            return 1
+        else
+            echo $kube_config > ~/.kubes/current-cube
+            export KUBECONFIG=$kube_config
+        fi
+    }
+
+    # Shortcut for kubectl
+    kctl() {
+        local kube_config
+        if [ -z $KUBECONFIG ]; then
+            kube_config=$HOME/.kube/config
+        else
+            kube_config=$KUBECONFIG
+        fi
+        if [ -f $kube_config ]; then
+            kubectl $@
+        else
+            echo >&2 error: $kube_config does not exist
+            return 1
+        fi
+    }
+
+fi
+
 # change to git directory
 cdg() {
     local newdir

zsh/config.zsh

@@ -20,7 +20,7 @@ DISABLE_AUTO_TITLE="true"
 # Which plugins would you like to load? (plugins can be found in ~/.oh-my-zsh/plugins/*)
 # Custom plugins may be added to ~/.oh-my-zsh/custom/plugins/me
 # Example format: plugins=(rails git textmate ruby lighthouse)
-plugins=(git myjump)
+plugins=(git myjump pass $ZSH_EXTRA_PLUGINS)
 
 source $ZSH/oh-my-zsh.sh
 

zsh/exports.zsh

@@ -7,7 +7,7 @@ else
 fi
 
 # Parallel conpilation with make
-export MAKEFLAGS="+j`nproc`"
+export MAKEFLAGS="-j`nproc`"
 
 # I want clang as default compiler if it exists
 command -v clang > /dev/null 2>&1
@@ -27,3 +27,4 @@ export WINEDEBUG=-all
 export RUST_BACKTRACE=full
 
 export TERM=xterm-256color
+export REPORTTIME=5

zsh/ohmyzsh/themes/laptop-hostname.zsh-theme

@@ -17,20 +17,20 @@ eval PR_BOLD="%{$terminfo[bold]%}"
 if [[ $UID -ge 1000 ]]; then # normal user
     # If ssh
     if [[ -n "$SSH_CLIENT"  ||  -n "$SSH2_CLIENT" ]]; then
-        eval PR_USER='${PR_GREEN}%n@%M${PR_NO_COLOR}'
+        eval PR_USER='${PR_GREEN}%n${PR_YELLOW}@${PR_GREEN}%M${PR_NO_COLOR}'
         eval PR_USER_OP='${PR_GREEN}%#${PR_NO_COLOR}'
         local PR_ARROW_UP='${PR_GREEN}┌── ${PR_NO_COLOR}'
         local PR_ARROW_DOWN='${PR_GREEN}└${PR_NO_COLOR}'
         local PR_PROMPT='$PR_GREEN▷$PR_NO_COLOR'
     else
-        eval PR_USER='${PR_MAGENTA}%n@%M${PR_NO_COLOR}'
+        eval PR_USER='${PR_MAGENTA}%n${PR_YELLOW}@${PR_GREEN}%M${PR_NO_COLOR}'
         eval PR_USER_OP='${PR_BLUE}%#${PR_NO_COLOR}'
         local PR_PROMPT='$PR_MAGENTA▷$PR_NO_COLOR'
         local PR_ARROW_UP='$PR_MAGENTA┌── ${PR_NO_COLOR}'
         local PR_ARROW_DOWN='$PR_MAGENTA└${PR_NO_COLOR}'
     fi
 elif [[ $UID -eq 0 ]]; then # root
-    eval PR_USER='${PR_RED}%n${PR_NO_COLOR}'
+    eval PR_USER='${PR_RED}%n${PR_YELLOW}@${PR_GREEN}%M${PR_NO_COLOR}'
     eval PR_USER_OP='${PR_RED}%#${PR_NO_COLOR}'
     local PR_ARROW_UP='${PR_RED}┌── ${PR_NO_COLOR}'
     local PR_ARROW_DOWN='${PR_RED}└${PR_NO_COLOR}'
@@ -76,25 +76,36 @@ else
     fi
 fi
 
+git_prompt_info_no_space() {
+    local info=$(git_prompt_info)
+    if [ ! -z $info ]; then
+        echo " $info"
+    fi
+}
+
 local return_code=""
-local git_branch='$(git_prompt_info)'
-
-local PR_TEMP=""
-
-command -v vcgencmd > /dev/null && PR_TEMP=' ${PR_GREEN}‹$(vcgencmd measure_temp | cut -d = -f 2)›${PR_NO_COLOR}'
+local git_branch='$(git_prompt_info_no_space)'
 
 local PR_DATE='${PR_BOLD}${PR_MAGENTA}[%D{%H:%M}]${PR_NO_COLOR}'
 
+extract_kube() {
+    if [ ! -z $KUBECONFIG ]; then
+        echo " ${PR_BOLD}${PR_CYAN}‹$(echo $KUBECONFIG | rev | cut -d '/' -f 2 | rev)›${PR_NO_COLOR}"
+    fi
+}
+
+local kube='$(extract_kube)'
+
 #PROMPT="${user_host} ${current_dir} ${rvm_ruby}${git_branch}$PR_PROMPT  "
 separator='${PR_YELLOW}::${PR_NO_COLOR}'
 tty | read tty_value
 if [[ $tty_value == *pts* ]]; then # if in a tty
-    PROMPT="$PR_ARROW_UP${PR_DATE} ${user_host}${separator}${PR_NO_COLOR}${current_dir} ${rvm_ruby}${git_branch}${PR_TEMP}
+    PROMPT="$PR_ARROW_UP${PR_DATE} ${user_host}${separator}${PR_NO_COLOR}${current_dir}${rvm_ruby}${git_branch}${kube}
 $PR_ARROW_DOWN$PR_PROMPT  ${PR_NO_COLOR}"
     return_code="%(?.%{$PR_GREEN%}%? ↵%{$PR_NO_COLOR%}.%{$PR_RED%}%? ↵%{$PR_NO_COLOR%})"
 else
     eval PR_NO_COLOR="$PR_WHITE"
-    PROMPT="${user_host} ${current_dir} ${rvm_ruby} ${git_branch}> ${PR_NO_COLOR}"
+    PROMPT="${user_host} ${current_dir} ${rvm_ruby}${git_branch}> ${PR_NO_COLOR}"
     return_code="%(?.%{$PR_GREEN%}%? <%{$PR_NO_COLOR%}.%{$PR_RED%}%? <%{$PR_NO_COLOR%})"
 fi
 RPS1="  ${return_code}"

zsh/ohmyzsh/themes/laptop.zsh-theme

@@ -79,15 +79,13 @@ fi
 local return_code=""
 local git_branch='$(git_prompt_info)'
 
-local PR_TEMP=""
-
-command -v vcgencmd > /dev/null && PR_TEMP=' ${PR_GREEN}‹$(vcgencmd measure_temp | cut -d = -f 2)›${PR_NO_COLOR}'
+local PR_DATE='${PR_BOLD}${PR_MAGENTA}[%D{%H:%M}]${PR_NO_COLOR}'
 
 #PROMPT="${user_host} ${current_dir} ${rvm_ruby}${git_branch}$PR_PROMPT  "
 separator='${PR_YELLOW}::${PR_NO_COLOR}'
 tty | read tty_value
 if [[ $tty_value == *pts* ]]; then # if in a tty
-    PROMPT="$PR_ARROW_UP${user_host}${separator}${PR_NO_COLOR}${current_dir} ${rvm_ruby}${git_branch}${PR_TEMP}
+    PROMPT="$PR_ARROW_UP${PR_DATE} ${user_host}${separator}${PR_NO_COLOR}${current_dir} ${rvm_ruby}${git_branch}
 $PR_ARROW_DOWN$PR_PROMPT  ${PR_NO_COLOR}"
     return_code="%(?.%{$PR_GREEN%}%? ↵%{$PR_NO_COLOR%}.%{$PR_RED%}%? ↵%{$PR_NO_COLOR%})"
 else
@@ -98,3 +96,8 @@ fi
 RPS1="  ${return_code}"
 ZSH_THEME_GIT_PROMPT_PREFIX="%{$PR_YELLOW%}‹"
 ZSH_THEME_GIT_PROMPT_SUFFIX="›%{$PR_NO_COLOR%}"
+
+TMOUT=30
+TRAPALRM() {
+    zle reset-prompt
+}