jessebot/dot_files
1
0
Fork 0
mirror of https://github.com/jessebot/dot_files.git synced 2025-10-01 01:48:43 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions

remove iterm2 from default dot files; they have been moved to old_dotfiles

Browse source
This commit is contained in:
JesseBot 2023-03-16 08:28:48 +01:00
parent 6c2e1f77af
commit 7d0cf86072
No known key found for this signature in database
GPG key ID: C01D207CE04D55D9
17 changed files with 3 additions and 4333 deletions
Download patch file Download diff file Expand all files Collapse all files

651
.config/bash/iterm2_integration.sh
View file

@ -1,651 +0,0 @@
#!/bin/bash
# The iTerm2 customizations fall under the following license:
#
# This program is free software; you can redistribute it and/or
# modify it under the terms of the GNU General Public License
# as published by the Free Software Foundation; either version 2
# of the License, or (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program; if not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
# -- BEGIN ITERM2 CUSTOMIZATIONS --
if [[ "$ITERM_ENABLE_SHELL_INTEGRATION_WITH_TMUX""$TERM" != screen && "$ITERM_ENABLE_SHELL_INTEGRATION_WITH_TMUX""$TERM" != tmux-256color && "$ITERM_SHELL_INTEGRATION_INSTALLED" = "" && "$-" == *i* && "$TERM" != linux && "$TERM" != dumb ]]; then
if shopt extdebug | grep on > /dev/null; then
echo "iTerm2 Shell Integration not installed."
echo ""
echo "Your shell has 'extdebug' turned on."
echo "This is incompatible with shell integration."
echo "Find 'shopt -s extdebug' in bash's rc scripts and remove it."
return 0
fi
ITERM_SHELL_INTEGRATION_INSTALLED=Yes
# Saved copy of your PS1. This is used to detect if the user changes PS1
# directly. ITERM_PREV_PS1 will hold the last value that this script set PS1 to
# (including various custom escape sequences).
ITERM_PREV_PS1="$PS1"
# A note on execution. When you invoke a command at an interactive prompt the following steps are taken:
#
# 1. The DEBUG trap runs.
# It calls __bp_preexec_invoke_exec
# It runs any registered preexec_functions, including __iterm2_preexec
# 2. The command you executed runs.
# 3. PROMPT_COMMAND runs.
# It runs __bp_precmd_invoke_cmd, which is inserted as the first command in PROMPT_COMMAND.
# It calls any registered precmd_functions
# Then, pre-existing PROMPT_COMMANDs run
# 4. The prompt is shown.
#
# __iterm2_prompt_command used to be run from precmd_functions but then a pre-existing
# PROMPT_COMMAND could clobber the PS1 it modifies. Instead, add __iterm2_prompt_command as the last
# of the "preexisting" PROMPT_COMMANDs so it will be the very last thing done before the prompt is
# shown (unless someone amends PROMPT_COMMAND, but that is on them).
if [[ -n "$PROMPT_COMMAND" ]]; then
PROMPT_COMMAND+=$'\n'
fi;
PROMPT_COMMAND+='__iterm2_prompt_command'
# The following chunk of code, bash-preexec.sh, is licensed like this:
# The MIT License
#
# Copyright (c) 2015 Ryan Caloras and contributors (see https://github.com/rcaloras/bash-preexec)
#
# Permission is hereby granted, free of charge, to any person obtaining a copy
# of this software and associated documentation files (the "Software"), to deal
# in the Software without restriction, including without limitation the rights
# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
# copies of the Software, and to permit persons to whom the Software is
# furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice shall be included in
# all copies or substantial portions of the Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
# THE SOFTWARE.
# Wrap bash-preexec.sh in a function so that, if it exits early due to having
# been sourced elsewhere, it doesn't exit our entire script.
_install_bash_preexec () {
# -- END ITERM2 CUSTOMIZATIONS --
# -- BEGIN BASH-PREEXEC.SH --
# bash-preexec.sh -- Bash support for ZSH-like 'preexec' and 'precmd' functions.
# https://github.com/rcaloras/bash-preexec
#
#
# 'preexec' functions are executed before each interactive command is
# executed, with the interactive command as its argument. The 'precmd'
# function is executed before each prompt is displayed.
#
# Author: Ryan Caloras (ryan@bashhub.com)
# Forked from Original Author: Glyph Lefkowitz
#
# V0.4.1
#
# General Usage:
#
# 1. Source this file at the end of your bash profile so as not to interfere
# with anything else that's using PROMPT_COMMAND.
#
# 2. Add any precmd or preexec functions by appending them to their arrays:
# e.g.
# precmd_functions+=(my_precmd_function)
# precmd_functions+=(some_other_precmd_function)
#
# preexec_functions+=(my_preexec_function)
#
# 3. Consider changing anything using the DEBUG trap or PROMPT_COMMAND
# to use preexec and precmd instead. Preexisting usages will be
# preserved, but doing so manually may be less surprising.
#
# Note: This module requires two Bash features which you must not otherwise be
# using: the "DEBUG" trap, and the "PROMPT_COMMAND" variable. If you override
# either of these after bash-preexec has been installed it will most likely break.
# Make sure this is bash that's running and return otherwise.
if [[ -z "${BASH_VERSION:-}" ]]; then
return 1;
fi
# Avoid duplicate inclusion
if [[ -n "${bash_preexec_imported:-}" ]]; then
return 0
fi
bash_preexec_imported="defined"
# WARNING: This variable is no longer used and should not be relied upon.
# Use ${bash_preexec_imported} instead.
__bp_imported="${bash_preexec_imported}"
# Should be available to each precmd and preexec
# functions, should they want it. $? and $_ are available as $? and $_, but
# $PIPESTATUS is available only in a copy, $BP_PIPESTATUS.
# TODO: Figure out how to restore PIPESTATUS before each precmd or preexec
# function.
__bp_last_ret_value="$?"
BP_PIPESTATUS=("${PIPESTATUS[@]}")
__bp_last_argument_prev_command="$_"
__bp_inside_precmd=0
__bp_inside_preexec=0
# Initial PROMPT_COMMAND string that is removed from PROMPT_COMMAND post __bp_install
__bp_install_string=$'__bp_trap_string="$(trap -p DEBUG)"\ntrap - DEBUG\n__bp_install'
# Fails if any of the given variables are readonly
# Reference https://stackoverflow.com/a/4441178
__bp_require_not_readonly() {
local var
for var; do
if ! ( unset "$var" 2> /dev/null ); then
echo "bash-preexec requires write access to ${var}" >&2
return 1
fi
done
}
# Remove ignorespace and or replace ignoreboth from HISTCONTROL
# so we can accurately invoke preexec with a command from our
# history even if it starts with a space.
__bp_adjust_histcontrol() {
local histcontrol
histcontrol="${HISTCONTROL:-}"
histcontrol="${histcontrol//ignorespace}"
# Replace ignoreboth with ignoredups
if [[ "$histcontrol" == *"ignoreboth"* ]]; then
histcontrol="ignoredups:${histcontrol//ignoreboth}"
fi;
export HISTCONTROL="$histcontrol"
}
# This variable describes whether we are currently in "interactive mode";
# i.e. whether this shell has just executed a prompt and is waiting for user
# input. It documents whether the current command invoked by the trace hook is
# run interactively by the user; it's set immediately after the prompt hook,
# and unset as soon as the trace hook is run.
__bp_preexec_interactive_mode=""
# These arrays are used to add functions to be run before, or after, prompts.
declare -a precmd_functions
declare -a preexec_functions
# Trims leading and trailing whitespace from $2 and writes it to the variable
# name passed as $1
__bp_trim_whitespace() {
local var=${1:?} text=${2:-}
text="${text#"${text%%[![:space:]]*}"}" # remove leading whitespace characters
text="${text%"${text##*[![:space:]]}"}" # remove trailing whitespace characters
printf -v "$var" '%s' "$text"
}
# Trims whitespace and removes any leading or trailing semicolons from $2 and
# writes the resulting string to the variable name passed as $1. Used for
# manipulating substrings in PROMPT_COMMAND
__bp_sanitize_string() {
local var=${1:?} text=${2:-} sanitized
__bp_trim_whitespace sanitized "$text"
sanitized=${sanitized%;}
sanitized=${sanitized#;}
__bp_trim_whitespace sanitized "$sanitized"
printf -v "$var" '%s' "$sanitized"
}
# This function is installed as part of the PROMPT_COMMAND;
# It sets a variable to indicate that the prompt was just displayed,
# to allow the DEBUG trap to know that the next command is likely interactive.
__bp_interactive_mode() {
__bp_preexec_interactive_mode="on";
}
# This function is installed as part of the PROMPT_COMMAND.
# It will invoke any functions defined in the precmd_functions array.
__bp_precmd_invoke_cmd() {
# Save the returned value from our last command, and from each process in
# its pipeline. Note: this MUST be the first thing done in this function.
__bp_last_ret_value="$?" BP_PIPESTATUS=("${PIPESTATUS[@]}")
# Don't invoke precmds if we are inside an execution of an "original
# prompt command" by another precmd execution loop. This avoids infinite
# recursion.
if (( __bp_inside_precmd > 0 )); then
return
fi
local __bp_inside_precmd=1
# Invoke every function defined in our function array.
local precmd_function
for precmd_function in "${precmd_functions[@]}"; do
# Only execute this function if it actually exists.
# Test existence of functions with: declare -[Ff]
if type -t "$precmd_function" 1>/dev/null; then
__bp_set_ret_value "$__bp_last_ret_value" "$__bp_last_argument_prev_command"
# Quote our function invocation to prevent issues with IFS
"$precmd_function"
fi
done
}
# Sets a return value in $?. We may want to get access to the $? variable in our
# precmd functions. This is available for instance in zsh. We can simulate it in bash
# by setting the value here.
__bp_set_ret_value() {
return ${1:-}
}
__bp_in_prompt_command() {
local prompt_command_array
IFS=$'\n;' read -rd '' -a prompt_command_array <<< "${PROMPT_COMMAND:-}"
local trimmed_arg
__bp_trim_whitespace trimmed_arg "${1:-}"
local command trimmed_command
for command in "${prompt_command_array[@]:-}"; do
__bp_trim_whitespace trimmed_command "$command"
if [[ "$trimmed_command" == "$trimmed_arg" ]]; then
return 0
fi
done
return 1
}
# This function is installed as the DEBUG trap. It is invoked before each
# interactive prompt display. Its purpose is to inspect the current
# environment to attempt to detect if the current command is being invoked
# interactively, and invoke 'preexec' if so.
__bp_preexec_invoke_exec() {
# Save the contents of $_ so that it can be restored later on.
# https://stackoverflow.com/questions/40944532/bash-preserve-in-a-debug-trap#40944702
__bp_last_argument_prev_command="${1:-}"
# Don't invoke preexecs if we are inside of another preexec.
if (( __bp_inside_preexec > 0 )); then
return
fi
local __bp_inside_preexec=1
# Checks if the file descriptor is not standard out (i.e. '1')
# __bp_delay_install checks if we're in test. Needed for bats to run.
# Prevents preexec from being invoked for functions in PS1
if [[ ! -t 1 && -z "${__bp_delay_install:-}" ]]; then
return
fi
if [[ -n "${COMP_LINE:-}" ]]; then
# We're in the middle of a completer. This obviously can't be
# an interactively issued command.
return
fi
if [[ -z "${__bp_preexec_interactive_mode:-}" ]]; then
# We're doing something related to displaying the prompt. Let the
# prompt set the title instead of me.
return
else
# If we're in a subshell, then the prompt won't be re-displayed to put
# us back into interactive mode, so let's not set the variable back.
# In other words, if you have a subshell like
# (sleep 1; sleep 2)
# You want to see the 'sleep 2' as a set_command_title as well.
if [[ 0 -eq "${BASH_SUBSHELL:-}" ]]; then
__bp_preexec_interactive_mode=""
fi
fi
if __bp_in_prompt_command "${BASH_COMMAND:-}"; then
# If we're executing something inside our prompt_command then we don't
# want to call preexec. Bash prior to 3.1 can't detect this at all :/
__bp_preexec_interactive_mode=""
return
fi
local this_command
this_command=$(
export LC_ALL=C
HISTTIMEFORMAT= builtin history 1 | sed '1 s/^ *[0-9][0-9]*[* ] //'
)
# Sanity check to make sure we have something to invoke our function with.
if [[ -z "$this_command" ]]; then
return
fi
# Invoke every function defined in our function array.
local preexec_function
local preexec_function_ret_value
local preexec_ret_value=0
for preexec_function in "${preexec_functions[@]:-}"; do
# Only execute each function if it actually exists.
# Test existence of function with: declare -[fF]
if type -t "$preexec_function" 1>/dev/null; then
__bp_set_ret_value ${__bp_last_ret_value:-}
# Quote our function invocation to prevent issues with IFS
"$preexec_function" "$this_command"
preexec_function_ret_value="$?"
if [[ "$preexec_function_ret_value" != 0 ]]; then
preexec_ret_value="$preexec_function_ret_value"
fi
fi
done
# Restore the last argument of the last executed command, and set the return
# value of the DEBUG trap to be the return code of the last preexec function
# to return an error.
# If `extdebug` is enabled a non-zero return value from any preexec function
# will cause the user's command not to execute.
# Run `shopt -s extdebug` to enable
__bp_set_ret_value "$preexec_ret_value" "$__bp_last_argument_prev_command"
}
__bp_install() {
# Exit if we already have this installed.
if [[ "${PROMPT_COMMAND:-}" == *"__bp_precmd_invoke_cmd"* ]]; then
return 1;
fi
trap '__bp_preexec_invoke_exec "$_"' DEBUG
# Preserve any prior DEBUG trap as a preexec function
local prior_trap=$(sed "s/[^']*'\(.*\)'[^']*/\1/" <<<"${__bp_trap_string:-}")
unset __bp_trap_string
if [[ -n "$prior_trap" ]]; then
eval '__bp_original_debug_trap() {
'"$prior_trap"'
}'
preexec_functions+=(__bp_original_debug_trap)
fi
# Adjust our HISTCONTROL Variable if needed.
__bp_adjust_histcontrol
# Issue #25. Setting debug trap for subshells causes sessions to exit for
# backgrounded subshell commands (e.g. (pwd)& ). Believe this is a bug in Bash.
#
# Disabling this by default. It can be enabled by setting this variable.
if [[ -n "${__bp_enable_subshells:-}" ]]; then
# Set so debug trap will work be invoked in subshells.
set -o functrace > /dev/null 2>&1
shopt -s extdebug > /dev/null 2>&1
fi;
local existing_prompt_command
# Remove setting our trap install string and sanitize the existing prompt command string
existing_prompt_command="${PROMPT_COMMAND:-}"
existing_prompt_command="${existing_prompt_command//$__bp_install_string[;$'\n']}" # Edge case of appending to PROMPT_COMMAND
existing_prompt_command="${existing_prompt_command//$__bp_install_string}"
__bp_sanitize_string existing_prompt_command "$existing_prompt_command"
# Install our hooks in PROMPT_COMMAND to allow our trap to know when we've
# actually entered something.
PROMPT_COMMAND=$'__bp_precmd_invoke_cmd\n'
if [[ -n "$existing_prompt_command" ]]; then
PROMPT_COMMAND+=${existing_prompt_command}$'\n'
fi;
PROMPT_COMMAND+='__bp_interactive_mode'
# Add two functions to our arrays for convenience
# of definition.
precmd_functions+=(precmd)
preexec_functions+=(preexec)
# Invoke our two functions manually that were added to $PROMPT_COMMAND
__bp_precmd_invoke_cmd
__bp_interactive_mode
}
# Sets an installation string as part of our PROMPT_COMMAND to install
# after our session has started. This allows bash-preexec to be included
# at any point in our bash profile.
__bp_install_after_session_init() {
# bash-preexec needs to modify these variables in order to work correctly
# if it can't, just stop the installation
__bp_require_not_readonly PROMPT_COMMAND HISTCONTROL HISTTIMEFORMAT || return
local sanitized_prompt_command
__bp_sanitize_string sanitized_prompt_command "${PROMPT_COMMAND:-}"
if [[ -n "$sanitized_prompt_command" ]]; then
PROMPT_COMMAND=${sanitized_prompt_command}$'\n'
fi;
PROMPT_COMMAND+=${__bp_install_string}
}
# Run our install so long as we're not delaying it.
if [[ -z "${__bp_delay_install:-}" ]]; then
__bp_install_after_session_init
fi;
# -- END BASH-PREEXEC.SH --
}
_install_bash_preexec
unset -f _install_bash_preexec
# -- BEGIN ITERM2 CUSTOMIZATIONS --
# We don't care about whitespace, but users care about not changing their histcontrol variables.
# We overwrite the upstream __bp_adjust_histcontrol function whcih gets called from the next
# PROMPT_COMMAND invocation.
function __bp_adjust_histcontrol() {
true
}
function iterm2_begin_osc {
printf "\033]"
}
function iterm2_end_osc {
printf "\007"
}
function iterm2_print_state_data() {
local _iterm2_hostname="${iterm2_hostname}"
if [ -z "${iterm2_hostname:-}" ]; then
_iterm2_hostname=$(hostname -f 2>/dev/null)
fi
iterm2_begin_osc
printf "1337;RemoteHost=%s@%s" "$USER" "$_iterm2_hostname"
iterm2_end_osc
iterm2_begin_osc
printf "1337;CurrentDir=%s" "$PWD"
iterm2_end_osc
iterm2_print_user_vars
}
# Usage: iterm2_set_user_var key value
function iterm2_set_user_var() {
iterm2_begin_osc
printf "1337;SetUserVar=%s=%s" "$1" $(printf "%s" "$2" | base64 | tr -d '\n')
iterm2_end_osc
}
if [ -z "$(type -t iterm2_print_user_vars)" ] || [ "$(type -t iterm2_print_user_vars)" != function ]; then
# iterm2_print_user_vars is not already defined. Provide a no-op default version.
#
# Users can write their own version of this function. It should call
# iterm2_set_user_var but not produce any other output.
function iterm2_print_user_vars() {
true
}
fi
function iterm2_prompt_prefix() {
iterm2_begin_osc
printf "133;D;\$?"
iterm2_end_osc
}
function iterm2_prompt_mark() {
iterm2_begin_osc
printf "133;A"
iterm2_end_osc
}
function iterm2_prompt_suffix() {
iterm2_begin_osc
printf "133;B"
iterm2_end_osc
}
function iterm2_print_version_number() {
iterm2_begin_osc
printf "1337;ShellIntegrationVersion=18;shell=bash"
iterm2_end_osc
}
# If hostname -f is slow on your system, set iterm2_hostname before sourcing this script.
# On macOS we run `hostname -f` every time because it is fast.
if [ -z "${iterm2_hostname:-}" ]; then
if [ "$(uname)" != "Darwin" ]; then
iterm2_hostname=$(hostname -f 2>/dev/null)
# some flavors of BSD (i.e. NetBSD and OpenBSD) don't have the -f option
if [ $? -ne 0 ]; then
iterm2_hostname=$(hostname)
fi
fi
fi
iterm2_maybe_print_cr() {
if [ "$TERM_PROGRAM" = "iTerm.app" ]; then
printf "\r"
fi
}
# Runs after interactively edited command but before execution
__iterm2_preexec() {
# Save the returned value from our last command
__iterm2_last_ret_value="$?"
iterm2_begin_osc
printf "133;C;"
iterm2_maybe_print_cr
iterm2_end_osc
# If PS1 still has the value we set it to in iterm2_preexec_invoke_cmd then
# restore it to its original value. It might have changed if you have
# another PROMPT_COMMAND (like liquidprompt) that modifies PS1.
if [ -n "${ITERM_ORIG_PS1+xxx}" -a "$PS1" = "$ITERM_PREV_PS1" ]
then
export PS1="$ITERM_ORIG_PS1"
fi
iterm2_ran_preexec="yes"
# preexec functions can return nonzero to prevent user's command from running.
return 0
}
# Prints the current directory and hostname control sequences. Modifies PS1 to
# add the FinalTerm A and B codes to locate the prompt.
function __iterm2_prompt_command () {
__iterm2_last_ret_value="$?"
if [[ -z "${iterm2_ran_preexec:-}" ]]
then
# This code path is taken when you press ^C while entering a command.
# I observed this behavior in CentOS 7.2 and macOS "GNU bash, version 5.0.18(1)-release".
__iterm2_preexec ""
__bp_set_ret_value "$__iterm2_last_ret_value" "$__bp_last_argument_prev_command"
fi
iterm2_ran_preexec=""
# This is an iTerm2 addition to try to work around a problem in the
# original preexec.bash.
# When the PS1 has command substitutions, this gets invoked for each
# substitution and each command that's run within the substitution, which
# really adds up. It would be great if we could do something like this at
# the end of this script:
# PS1="$(iterm2_prompt_prefix)$PS1($iterm2_prompt_suffix)"
# and have iterm2_prompt_prefix set a global variable that tells precmd not to
# output anything and have iterm2_prompt_suffix reset that variable.
# Unfortunately, command substitutions run in subshells and can't
# communicate to the outside world.
# Instead, we have this workaround. We save the original value of PS1 in
# $ITERM_ORIG_PS1. Then each time this function is run (it's called from
# PROMPT_COMMAND just before the prompt is shown) it will change PS1 to a
# string without any command substitutions by doing eval on ITERM_ORIG_PS1. At
# this point ITERM_PREEXEC_INTERACTIVE_MODE is still the empty string, so preexec
# won't produce output for command substitutions.
# The first time this is called ITERM_ORIG_PS1 is unset. This tests if the variable
# is undefined (not just empty) and initializes it. We can't initialize this at the
# top of the script because it breaks with liquidprompt. liquidprompt wants to
# set PS1 from a PROMPT_COMMAND that runs just before us. Setting ITERM_ORIG_PS1
# at the top of the script will overwrite liquidprompt's PS1, whose value would
# never make it into ITERM_ORIG_PS1. Issue 4532. It's important to check
# if it's undefined before checking if it's empty because some users have
# bash set to error out on referencing an undefined variable.
if [ -z "${ITERM_ORIG_PS1+xxx}" ]
then
# ITERM_ORIG_PS1 always holds the last user-set value of PS1.
# You only get here on the first time iterm2_preexec_invoke_cmd is called.
export ITERM_ORIG_PS1="$PS1"
fi
# If you want to generate PS1 dynamically from PROMPT_COMMAND, the best way
# to do it is to define a function named iterm2_generate_ps1 that sets PS1.
# Issue 5964. Other shells don't have this issue because they don't need
# such extremes to get precmd and preexec.
if [ -n "$(type -t iterm2_generate_ps1)" ] && [ "$(type -t iterm2_generate_ps1)" = function ]; then
iterm2_generate_ps1
fi
if [[ "$PS1" != "$ITERM_PREV_PS1" ]]
then
export ITERM_ORIG_PS1="$PS1"
fi
# Get the value of the prompt prefix, which will change $?
\local iterm2_prompt_prefix_value="$(iterm2_prompt_prefix)"
# Add the mark unless the prompt includes '$(iterm2_prompt_mark)' as a substring.
if [[ $ITERM_ORIG_PS1 != *'$(iterm2_prompt_mark)'* && x$ITERM2_SQUELCH_MARK = x ]]
then
iterm2_prompt_prefix_value="$iterm2_prompt_prefix_value$(iterm2_prompt_mark)"
fi
# Send escape sequences with current directory and hostname.
iterm2_print_state_data
# Reset $? to its saved value, which might be used in $ITERM_ORIG_PS1.
__bp_set_ret_value "$__iterm2_last_ret_value" "$__bp_last_argument_prev_command"
# Set PS1 to various escape sequences, the user's preferred prompt, and more escape sequences.
export PS1="\[$iterm2_prompt_prefix_value\]$ITERM_ORIG_PS1\[$(iterm2_prompt_suffix)\]"
# Save the value we just set PS1 to so if the user changes PS1 we'll know and we can update ITERM_ORIG_PS1.
export ITERM_PREV_PS1="$PS1"
__bp_set_ret_value "$__iterm2_last_ret_value" "$__bp_last_argument_prev_command"
}
# Install my function
preexec_functions+=(__iterm2_preexec)
iterm2_print_state_data
iterm2_print_version_number
fi
# -- END ITERM2 CUSTOMIZATIONS --

722
.local/bin/iterm2/it2api
View file

@ -1,722 +0,0 @@
#!/usr/bin/env python3
import argparse
import asyncio
import iterm2
import logging
import re
import sys
import traceback
async def list_sessions(connection, args):
a = await iterm2.async_get_app(connection)
for w in a.terminal_windows:
for t in w.tabs:
sessions = t.sessions
for s in sessions:
print(s.pretty_str(), end='')
print("")
print("Buried sessions:")
for s in a.buried_sessions:
print(s.pretty_str(), end='')
async def show_hierarchy(connection, args):
a = await iterm2.async_get_app(connection)
print(a.pretty_str())
async def send_text(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
await s.async_send_text(args.text)
async def create_tab(connection, args):
a = await iterm2.async_get_app(connection)
if args.window is not None:
window_id = args.window
try:
window = next(window for window in a.terminal_windows if window.window_id == window_id)
tab = await window.async_create_tab(profile=args.profile, command=args.command, index=args.index)
except:
print("bad window id {}".format(window_id))
sys.exit(1)
else:
window = await iterm2.Window.async_create(connection, profile=args.profile, command=args.command)
if not window:
return
tab = window.tabs[0]
session = tab.sessions[0]
print(session.pretty_str())
async def split_pane(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
session = await s.async_split_pane(vertical=args.vertical, before=args.before, profile=args.profile)
print(session.pretty_str())
async def get_buffer(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
contents = await s.async_get_screen_contents()
for i in range(contents.number_of_lines):
line = contents.line(i)
print(line.string)
async def get_prompt(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
result = await iterm2.async_get_last_prompt(connection, s.session_id)
print("working_directory: \"{}\"".format(result.working_directory))
print("command: \"{}\"".format(result.command))
def profile_property_type_map():
map = {
"allow_title_reporting": "bool",
"allow_title_setting": "bool",
"ambiguous_double_width": "bool",
"ansi_0_color": "color",
"ansi_10_color": "color",
"ansi_11_color": "color",
"ansi_12_color": "color",
"ansi_13_color": "color",
"ansi_14_color": "color",
"ansi_15_color": "color",
"ansi_1_color": "color",
"ansi_2_color": "color",
"ansi_3_color": "color",
"ansi_4_color": "color",
"ansi_5_color": "color",
"ansi_6_color": "color",
"ansi_7_color": "color",
"ansi_8_color": "color",
"ansi_9_color": "color",
"answerback_string": "str",
"application_keypad_allowed": "bool",
"ascii_anti_aliased": "bool",
"ascii_ligatures": "bool",
"background_color": "color",
"background_image_is_tiled": "bool",
"badge_color": "color",
"badge_text": "str",
"blend": "float",
"blink_allowed": "bool",
"blinking_cursor": "bool",
"blur": "float",
"blur_radius": "float",
"bm_growl": "bool",
"bold_color": "color",
"character_encoding": "int",
"close_sessions_on_end": "bool",
"cursor_boost": "float",
"cursor_color": "color",
"cursor_guide_color": "color",
"cursor_text_color": "color",
"cursor_type": "int",
"disable_printing": "bool",
"disable_smcup_rmcup": "bool",
"disable_window_resizing": "bool",
"flashing_bell": "bool",
"foreground_color": "color",
"horizontal_spacing": "float",
"idle_code": "int",
"idle_period": "float",
"link_color": "color",
"minimum_contrast": "float",
"mouse_reporting": "bool",
"mouse_reporting_allow_mouse_wheel": "bool",
"name": "str",
"non_ascii_anti_aliased": "bool",
"non_ascii_ligatures": "bool",
"only_the_default_bg_color_uses_transparency": "bool",
"left_option_key_sends": "int",
"place_prompt_at_first_column": "bool",
"prompt_before_closing": "bool",
"reduce_flicker": "bool",
"right_option_key_sends": "int",
"scrollback_in_alternate_screen": "bool",
"scrollback_lines": "int",
"scrollback_with_status_bar": "bool",
"selected_text_color": "color",
"selection_color": "color",
"send_bell_alert": "bool",
"send_code_when_idle": "bool",
"send_idle_alert": "bool",
"send_new_output_alert": "bool",
"send_session_ended_alert": "bool",
"send_terminal_generated_alerts": "bool",
"session_close_undo_timeout": "float",
"show_mark_indicators": "bool",
"silence_bell": "bool",
"smart_cursor_color": "color",
"smart_cursor_color": "color",
"sync_title": "str",
"tab_color": "color",
"thin_strokes": "int",
"transparency": "float",
"underline_color": "color",
"unicode_normalization": "int",
"unicode_version": "int",
"unlimited_scrollback": "bool",
"use_bold_font": "bool",
"use_bright_bold": "bool",
"use_cursor_guide": "bool",
"use_italic_font": "bool",
"use_non_ascii_font": "bool",
"use_tab_color": "bool",
"use_underline_color": "bool",
"vertical_spacing": "float",
"visual_bell": "bool",
"triggers": "dict",
"smart_selection_rules": "list",
"semantic_history": "dict",
"automatic_profile_switching_rules": "list",
"advanced_working_directory_window_setting": "string",
"advanced_working_directory_window_directory": "string",
"advanced_working_directory_tab_setting": "string",
"advanced_working_directory_tab_directory": "string",
"advanced_working_directory_pane_setting": "string",
"advanced_working_directory_pane_directory": "string",
"normal_font": "string",
"non_ascii_font": "string",
"background_image_location": "string",
"key_mappings": "dict",
"touchbar_mappings": "dict" }
return map
def profile_properties():
return list(profile_property_type_map().keys())
def profile_property_type(key):
return profile_property_type_map()[key]
async def get_profile_property(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
profile = await s.async_get_profile()
if args.keys is not None:
keys = args.keys.split(",")
else:
keys = profile_properties()
for prop in keys:
fname = prop
value = getattr(profile, fname)
print("{}: {}".format(prop, value))
def encode_property_value(key, value):
type = profile_property_type(key)
if type == "bool":
assert value == "true" or value == "false"
return value == "true"
elif type == "str":
return value
elif type == "float":
return float(value)
elif type == "int":
return int(value)
elif type == "dict" or type == "list":
class TypeNotSupportedException(Exception): Pass
raise TypeNotSupportedException("this property's type is not supported")
elif type == "color":
# Accepted values look like: "(0,0,0,255 sRGB)"
regex = r"\(([0-9]+), *([0-9]+), *([0-9]+), *([0-9]+) *([A-Za-z]+)\)"
match = re.search(regex, value)
assert match is not None
return iterm2.Color(
float(match.group(1)),
float(match.group(2)),
float(match.group(3)),
float(match.group(4)),
iterm2.ColorSpace(match.group(5)))
async def set_profile_property(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
encoded_value = encode_property_value(args.key, args.value)
profile = await s.async_get_profile()
fname = "async_set_" + args.key
f = getattr(profile, fname)
await f(encoded_value)
async def read(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
if args.mode == "char":
async with iterm2.KeystrokeMonitor(connection) as mon:
keystroke = await mon.async_get()
print(keystroke)
elif args.mode == "line":
async with s.get_keystroke_reader() as reader:
eol = False
line = ""
while not eol:
k = await reader.get()
for e in k:
c = e.characters
if c == "\r" or c == "\n":
eol = True
break
line += c
print(line)
async def get_window_property(connection, args):
a = await iterm2.async_get_app(connection)
w = a.get_window_by_id(args.id)
if w is None:
print("bad window ID")
else:
if args.name == "frame":
frame = await w.async_get_frame()
print("{},{},{},{}".format(frame.origin.x,frame.origin.y,frame.size.width,frame.size.height))
elif args.name == "fullscreen":
print(await w.async_get_fullscreen(connection))
async def set_window_property(connection, args):
a = await iterm2.async_get_app(connection)
w = a.get_window_by_id(args.id)
if w is None:
print("bad window ID")
else:
if args.name == "frame":
parts = args.value.split(",")
frame = iterm2.Frame(iterm2.Point(int(parts[0]), int(parts[1])), iterm2.Size(int(parts[2]), int(parts[3])))
await w.async_set_frame(frame)
elif args.name == "fullscreen":
await w.async_set_fullscreen(args.value == "true")
async def inject(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
if s is None:
print("bad session ID")
else:
await s.async_inject(args.data.encode())
async def activate(connection, args):
a = await iterm2.async_get_app(connection)
if args.mode == "session":
s = a.get_session_by_id(args.id)
if s is None:
print("bad session ID")
else:
await s.async_activate()
elif args.mode == "tab":
t = a.get_tab_by_id(args.id)
if t is None:
print("bad tab ID")
else:
await t.async_select()
elif args.mode == "window":
w = a.get_window_by_id(args.id)
if w is None:
print("bad window ID")
else:
await w.async_activate()
async def activate_app(connection, args):
a = await iterm2.async_get_app(connection)
await a.async_activate(raise_all_windows=args.raise_all_windows, ignoring_other_apps=args.ignoring_other_apps)
async def set_variable(connection, args):
a = await iterm2.async_get_app(connection)
if args.session:
s = a.get_session_by_id(args.session)
if s is None:
print("bad session ID")
return
await s.async_set_variable(args.name, args.value)
elif args.tab:
t = a.get_tab_by_id(args.tab)
if t is None:
print("bad tab ID")
return
await t.async_set_variable(args.name, args.value)
else:
await a.async_set_variable(args.name, args.value)
async def get_variable(connection, args):
a = await iterm2.async_get_app(connection)
if args.session:
s = a.get_session_by_id(args.session)
if s is None:
print("bad session ID")
return
value = await s.async_get_variable(args.name)
print(value)
elif args.tab:
t = a.get_tab_by_id(args.tab)
if t is None:
print("bad tab ID")
return
value = await t.async_get_variable(args.name)
print(value)
else:
value = await a.async_get_variable(args.name)
print(value)
async def list_variables(connection, args):
a = await iterm2.async_get_app(connection)
if args.session:
s = a.get_session_by_id(args.session)
if s is None:
print("bad session ID")
return
value = await s.async_get_variable("*")
for name in value:
print(name)
elif args.tab:
t = a.get_tab_by_id(args.tab)
if t is None:
print("bad tab ID")
return
value = await t.async_get_variable("*")
for name in value:
print(name)
else:
value = await a.async_get_variable("*")
for name in value:
print(name)
async def saved_arrangement(connection, args):
if args.window is not None:
a = await iterm2.async_get_app(connection)
w = a.get_window_by_id(args.window)
if w is None:
print("bad window ID")
return
if args.action == "save":
await w.async_save_window_as_arrangement(args.name)
elif args.action == "restore":
await w.async_restore_window_arrangement(args.name)
else:
if args.action == "save":
await iterm2.Arrangement.async_save(connection, args.name)
elif args.action == "restore":
await iterm2.Arrangement.async_restore(connection, args.name)
async def show_focus(connection, args):
a = await iterm2.async_get_app(connection)
if a.app_active:
print("App is active")
w = a.current_terminal_window
print("Key window: {}".format(w.window_id))
print("")
for w in a.terminal_windows:
t = a.get_tab_by_id(w.selected_tab_id)
print("Selected tab in {}: {}".format(w.window_id, t.tab_id))
s = a.get_session_by_id(t.active_session_id)
print(" Active session is: {}".format(s.pretty_str()))
async def list_profiles(connection, args):
guids = args.guids.split(",") if args.guids is not None else None
properties = args.properties.split(",") if args.properties is not None else None
profiles = await iterm2.PartialProfile.async_query(connection, guids=guids, properties=properties)
for profile in profiles:
keys = list(profile.all_properties.keys())
keys.sort()
for k in keys:
v = profile.all_properties[k]
print("{}: {}".format(k, v))
print("")
async def set_grid_size(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
await s.async_set_grid_size(iterm2.Size(args.width, args.height))
async def list_tmux_connections(connection, args):
connections = await iterm2.async_get_tmux_connections(connection)
for connection in connections:
print("Connection ID: {}\nOwning session: {}".format(connection.connection_id, connection.owning_session))
async def send_tmux_command(connection, args):
connections = await iterm2.async_get_tmux_connections(connection)
ids = []
for connection in connections:
if connection.connection_id == args.connection_id:
print(await connection.async_send_command(args.command))
return;
ids.append(connection.connection_id)
print("No connection with id {} found. Have: {}".format(args.connection_id, ", ".join(ids)))
async def set_tmux_window_visible(connection, args):
connections = await iterm2.async_get_tmux_connections(connection)
ids = []
for connection in connections:
if connection.connection_id == args.connection_id:
await connection.async_set_tmux_window_visible(args.window_id, args.visible)
return;
ids.append(connection.connection_id)
print("No connection with id {} found. Have: {}".format(args.connection_id, ", ".join(ids)))
async def sort_tabs(connection, args):
app = await iterm2.async_get_app(connection)
for w in app.terminal_windows:
tabs = w.tabs
for t in tabs:
t.tab_name = await t.async_get_variable("currentSession.session.name")
def tab_name(t):
return t.tab_name
sorted_tabs = sorted(tabs, key=tab_name)
await w.async_set_tabs(sorted_tabs)
async def list_color_presets(connection, args):
presets = await iterm2.ColorPreset.async_get_list(connection)
for preset in presets:
print(preset)
async def set_color_preset(connection, args):
preset = await iterm2.ColorPreset.async_get(connection, args.preset)
profiles = await iterm2.PartialProfile.async_query(connection, properties=['Guid', 'Name'])
for partial in profiles:
if partial.name == args.profile:
profile = await partial.async_get_full_profile()
await profile.async_set_color_preset(preset)
async def monitor_variable(connection, args):
if args.session:
scope = iterm2.VariableScopes.SESSION
identifier = args.session
elif args.tab:
scope = iterm2.VariableScopes.TAB
identifier = args.tab
elif args.window:
scope = iterm2.VariableScopes.WINDOW
identifier = args.window
elif args.app:
scope = iterm2.VariableScopes.APP
identifier = ''
else:
assert False
async with iterm2.VariableMonitor(connection, scope, args.name, identifier) as monitor:
value = await monitor.async_get()
print(f"New value: {value}")
async def monitor_focus(connection, args):
async with iterm2.FocusMonitor(connection) as monitor:
update = await monitor.async_get_next_update()
print("Update: {}".format(update))
async def set_cursor_color(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
partial = iterm2.LocalWriteOnlyProfile()
r, g, b = list(map(int, args.color.split(",")))
c = iterm2.Color(r, g, b)
partial.set_cursor_color(c)
await s.async_set_profile_properties(partial)
async def monitor_screen(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
async with s.get_screen_streamer() as streamer:
done = False
while not done:
contents = await streamer.async_get()
for i in range(contents.number_of_lines):
line = contents.line(i)
if args.query in line.string:
return
async def show_selection(connection, args):
a = await iterm2.async_get_app(connection)
s = a.get_session_by_id(args.session)
selection = await s.async_get_selection()
for sub in selection.subSelections:
print("Sub selection: {}".format(await sub.async_get_string(connection, s.session_id)))
print("Text: {}".format(await selection.async_get_string(connection, s.session_id, s.grid_size.width)))
def make_parser():
parser = argparse.ArgumentParser(description='iTerm2 CLI')
subparsers = parser.add_subparsers(help='Commands')
list_sessions_parser = subparsers.add_parser("list-sessions", help="List sessions")
list_sessions_parser.set_defaults(func=list_sessions)
show_hierarchy_parser = subparsers.add_parser("show-hierarchy", help="Show all windows, tabs, and sessions")
show_hierarchy_parser.set_defaults(func=show_hierarchy)
send_text_parser = subparsers.add_parser("send-text", help="Send text as though the user had typed it")
send_text_parser.add_argument('session', type=str, help='Session ID')
send_text_parser.add_argument("text", type=str, help='Text to send')
send_text_parser.set_defaults(func=send_text)
create_tab_parser = subparsers.add_parser("create-tab", help="Create a new tab or window")
create_tab_parser.add_argument('--profile', type=str, nargs='?', help='Profile name')
create_tab_parser.add_argument('--window', type=str, nargs='?', help='Window ID')
create_tab_parser.add_argument('--index', type=int, nargs='?', help='Desired tab index')
create_tab_parser.add_argument('--command', type=str, nargs='?', help='Command')
create_tab_parser.set_defaults(func=create_tab)
split_pane_parser = subparsers.add_parser("split-pane", help="Split a pane into two")
split_pane_parser.add_argument('session', type=str, help='Session ID')
split_pane_parser.add_argument('--vertical', action='store_true', help='Split vertically?', default=False)
split_pane_parser.add_argument('--before', action='store_true', help='Spilt left or above target', default=False)
split_pane_parser.add_argument('--profile', type=str, nargs='?', help='Profile name')
split_pane_parser.set_defaults(func=split_pane)
get_buffer_parser = subparsers.add_parser("get-buffer", help="Get screen contents")
get_buffer_parser.add_argument("session", type=str, help="Session ID")
get_buffer_parser.set_defaults(func=get_buffer)
get_prompt_parser = subparsers.add_parser("get-prompt", help="Get info about prompt, if available. Gives either the current prompt or the last prompt if a command is being run. Requires shell integration for prompt detection.")
get_prompt_parser.add_argument("session", type=str, help="Session ID")
get_prompt_parser.set_defaults(func=get_prompt)
get_profile_property_parser = subparsers.add_parser("get-profile-property", help="Get a session's profile settings")
get_profile_property_parser.add_argument("session", type=str, help="Session ID")
get_profile_property_parser.add_argument("keys", type=str, nargs='?', help="Comma separated keys. Omit to get all. Valid keys are: " + ", ".join(profile_properties()))
get_profile_property_parser.set_defaults(func=get_profile_property)
set_profile_parser = subparsers.add_parser("set-profile-property", help="Set a session's profile setting")
set_profile_parser.add_argument("session", type=str, help="Session ID")
set_profile_parser.add_argument("key", type=str, help="Key to set. Valid keys are: " + ", ".join(profile_properties()))
set_profile_parser.add_argument("value", type=str, help="New value.")
set_profile_parser.set_defaults(func=set_profile_property)
read_parser = subparsers.add_parser("read", help="Wait for a input.")
read_parser.add_argument("session", type=str, help="Session ID")
read_parser.add_argument("mode", type=str, help="What to read", choices=[ "char", "line" ])
read_parser.set_defaults(func=read)
get_window_property_parser = subparsers.add_parser("get-window-property", help="Get a property of a window")
get_window_property_parser.add_argument("id", type=str, help="Window ID")
get_window_property_parser.add_argument("name", type=str, help="Property name", choices=["frame", "fullscreen"])
get_window_property_parser.set_defaults(func=get_window_property)
set_window_property_parser = subparsers.add_parser("set-window-property", help="Set a property of a window")
set_window_property_parser.add_argument("id", type=str, help="Window ID")
set_window_property_parser.add_argument("name", type=str, help="Property name", choices=["frame", "fullscreen"])
set_window_property_parser.add_argument("value", type=str, help="New value. For frame: x,y,width,height; for fullscreen: true or false")
set_window_property_parser.set_defaults(func=set_window_property)
inject_parser = subparsers.add_parser("inject", help="Inject a string as though it were program output")
inject_parser.add_argument("session", type=str, help="Session ID")
inject_parser.add_argument("data", type=str, help="Data to inject")
inject_parser.set_defaults(func=inject)
activate_parser = subparsers.add_parser("activate", help="Activate a session, tab, or window.")
activate_parser.add_argument("mode", type=str, help="What kind of object to activate", choices=["session", "tab", "window"])
activate_parser.add_argument("id", type=str, help="ID of object to activate")
activate_parser.set_defaults(func=activate)
activate_app_parser = subparsers.add_parser("activate-app", help="Activate the app")
activate_app_parser.add_argument('--raise_all_windows', action='store_true', help='Raise all windows?', default=False)
activate_app_parser.add_argument('--ignoring_other_apps', action='store_true', help='Activate ignoring other apps (may steal focus)', default=False)
activate_app_parser.set_defaults(func=activate_app)
set_variable_parser = subparsers.add_parser("set-variable", help="Set a user-defined variable in a session. See Badges documentation for details.")
set_variable_parser.add_argument("--session", type=str, nargs='?', help="Session ID")
set_variable_parser.add_argument("--tab", type=str, nargs='?', help="Tab ID")
set_variable_parser.add_argument("name", type=str, help="Variable name. Starts with \"user.\"")
set_variable_parser.add_argument("value", type=str, help="New value")
set_variable_parser.set_defaults(func=set_variable)
get_variable_parser = subparsers.add_parser("get-variable", help="Get a variable in a session. See Badges documentation for details.")
get_variable_parser.add_argument("--session", type=str, nargs='?', help="Session ID")
get_variable_parser.add_argument("--tab", type=str, nargs='?', help="Tab ID")
get_variable_parser.add_argument("name", type=str, help="Variable name. Starts with \"user.\"")
get_variable_parser.set_defaults(func=get_variable)
list_variables_parser = subparsers.add_parser("list-variables", help="Lists variable names available in a session.")
list_variables_parser.add_argument("--session", type=str, nargs='?', help="Session ID")
list_variables_parser.add_argument("--tab", type=str, nargs='?', help="Tab ID")
list_variables_parser.set_defaults(func=list_variables)
saved_arrangement_parser = subparsers.add_parser("saved-arrangement", help="Saves and restores window arrangements")
saved_arrangement_parser.add_argument("action", type=str, help="Action to perform", choices=["save", "restore"])
saved_arrangement_parser.add_argument("name", type=str, help="Arrangement name")
saved_arrangement_parser.add_argument('--window', type=str, nargs='?', help='Window ID to save/restore to')
saved_arrangement_parser.set_defaults(func=saved_arrangement)
show_focus_parser = subparsers.add_parser("show-focus", help="Show active windows, tabs, and panes")
show_focus_parser.set_defaults(func=show_focus)
list_profiles_parser = subparsers.add_parser("list-profiles", help="List profiles")
list_profiles_parser.add_argument("--guids", type=str, nargs='?', help="Comma-delimited list of profiles to list. Omit to get all of them.")
list_profiles_parser.add_argument("--properties", type=str, nargs='?', help="Comma-delimited list of properties to request. Omit to get all of them.")
list_profiles_parser.set_defaults(func=list_profiles)
set_grid_size_parser = subparsers.add_parser("set-grid-size", help="Set size of session")
set_grid_size_parser.add_argument("session", type=str, help="Session ID")
set_grid_size_parser.add_argument("width", type=int, help="Width in columns")
set_grid_size_parser.add_argument("height", type=int, help="Height in rows")
set_grid_size_parser.set_defaults(func=set_grid_size)
list_tmux_connections_parser = subparsers.add_parser("list-tmux-connections", help="List tmux integration connections")
list_tmux_connections_parser.set_defaults(func=list_tmux_connections)
send_tmux_command_parser = subparsers.add_parser("send-tmux-command", help="Send a tmux command to a tmux integration connection")
send_tmux_command_parser.add_argument("connection_id", type=str, help="tmux connection ID")
send_tmux_command_parser.add_argument("command", type=str, help="Command to send")
send_tmux_command_parser.set_defaults(func=send_tmux_command)
set_tmux_window_visible_parser = subparsers.add_parser("set-tmux-window-visible", help="Show or hide a tmux integration window (represented as a tab in iTerm2)")
set_tmux_window_visible_parser.add_argument("connection_id", type=str, help="tmux connection ID")
set_tmux_window_visible_parser.add_argument("window_id", type=str, help="tmux window ID (number)")
set_tmux_window_visible_parser.add_argument('--visible', dest='visible', action='store_true')
set_tmux_window_visible_parser.add_argument('--no-visible', dest='visible', action='store_false')
set_tmux_window_visible_parser.set_defaults(visible=True)
set_tmux_window_visible_parser.set_defaults(func=set_tmux_window_visible)
sort_tabs_parser = subparsers.add_parser("sort-tabs", help="Sort tabs alphabetically by name")
sort_tabs_parser.set_defaults(func=sort_tabs)
list_color_presets_parser = subparsers.add_parser("list-color-presets", help="Lists names of color presets")
list_color_presets_parser.set_defaults(func=list_color_presets)
set_color_preset_parser = subparsers.add_parser("set-color-preset", help="Lists names of color presets")
set_color_preset_parser.add_argument("profile", type=str, help="Profile name")
set_color_preset_parser.add_argument("preset", type=str, help="Color preset name")
set_color_preset_parser.set_defaults(func=set_color_preset)
monitor_variable_parser = subparsers.add_parser("monitor-variable", help="Monitor changes to a variable")
monitor_variable_parser.add_argument("name", type=str, help="variable name")
monitor_variable_parser.add_argument('--session', type=str, nargs='?', help='Session ID for the variable scope')
monitor_variable_parser.add_argument('--tab', type=str, nargs='?', help='Tab ID for the variable scope')
monitor_variable_parser.add_argument('--window', type=str, nargs='?', help='Window ID for the variable scope')
monitor_variable_parser.add_argument('--app', action='store_true', help='App scope', default=False)
monitor_variable_parser.set_defaults(func=monitor_variable)
monitor_focus_parser = subparsers.add_parser("monitor-focus", help="Monitor changes to focus")
monitor_focus_parser.set_defaults(func=monitor_focus)
set_cursor_color_parser = subparsers.add_parser("set-cursor-color", help="Set cursor color")
set_cursor_color_parser.add_argument("session", type=str, help="Session ID")
set_cursor_color_parser.add_argument("color", type=str, help="Color as red,green,blue where each value is in 0-255")
set_cursor_color_parser.set_defaults(func=set_cursor_color)
monitor_screen_parser = subparsers.add_parser("monitor-screen", help="Monitor screen contents")
monitor_screen_parser.add_argument("session", type=str, help="Session ID")
monitor_screen_parser.add_argument("query", type=str, help="Stop when this text is seen")
monitor_screen_parser.set_defaults(func=monitor_screen)
show_selection_parser = subparsers.add_parser("show-selection", help="Shows the selected text in a session")
show_selection_parser.add_argument("session", type=str, help="Session ID")
show_selection_parser.set_defaults(func=show_selection)
return parser
def main(argv):
logging.basicConfig()
parser = make_parser()
args = parser.parse_args(argv[1:])
if "func" not in args:
print(parser.format_help())
raise argparse.ArgumentTypeError('Missing command')
async def wrapper(connection):
try:
await args.func(connection, args)
except Exception as e:
print(traceback.format_exc())
iterm2.run_until_complete(wrapper)
if __name__ == "__main__":
try:
main(sys.argv)
except Exception as e:
print(traceback.format_exc())
sys.exit(1)

82
.local/bin/iterm2/it2attention
View file

@ -1,82 +0,0 @@
#!/usr/bin/env bash
# tmux requires unrecognized OSC sequences to be wrapped with DCS tmux;
# <sequence> ST, and for all ESCs in <sequence> to be replaced with ESC ESC. It
# only accepts ESC backslash for ST.
function print_osc() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\033Ptmux;\033\033]"
else
printf "\033]"
fi
}
# More of the tmux workaround described above.
function print_st() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\a\033\\"
else
printf "\a"
fi
}
function show_help() {
echo "Usage:" 1>& 2
echo " $(basename $0) start" 1>& 2
echo " Begin bouncing the dock icon if another app is active" 1>& 2
echo " $(basename $0) stop" 1>& 2
echo " Stop bouncing the dock icon if another app is active" 1>& 2
echo " $(basename $0) once" 1>& 2
echo " Bounce the dock icon once if another app is active" 1>& 2
echo " $(basename $0) fireworks" 1>& 2
echo " Show an explosion animation at the cursor" 1>& 2
}
function start_bounce() {
print_osc
printf "1337;RequestAttention=1"
print_st
}
function stop_bounce() {
print_osc
printf "1337;RequestAttention=0"
print_st
}
function bounce_once() {
print_osc
printf "1337;RequestAttention=once"
print_st
}
function fireworks() {
print_osc
printf "1337;RequestAttention=fireworks"
print_st
}
## Main
if [[ $# == 0 ]]
then
show_help
exit 1
fi
if [[ $1 == start ]]
then
start_bounce
elif [[ $1 == stop ]]
then
stop_bounce
elif [[ $1 == once ]]
then
bounce_once
elif [[ $1 == fireworks ]]
then
fireworks
else
show_help
exit 1
fi

90
.local/bin/iterm2/it2check
View file

@ -1,90 +0,0 @@
#!/usr/bin/env bash
# Make sure stdin and stdout are a tty.
if [ ! -t 0 ] ; then
exit 1
fi
if [ ! -t 1 ] ; then
exit 1
fi
# Read some bytes from stdin. Pass the number of bytes to read as the first argument.
function read_bytes()
{
numbytes=$1
dd bs=1 count=$numbytes 2>/dev/null
}
function read_dsr() {
# Reading response to DSR.
dsr=""
spam=$(read_bytes 2)
byte=$(read_bytes 1)
while [ "${byte}" != "n" ]; do
dsr=${dsr}${byte}
byte=$(read_bytes 1)
done
echo ${dsr}
}
# Extract the terminal name from DSR 1337
function terminal {
echo -n "$1" | sed -e 's/ .*//'
}
# Extract the version number from DSR 1337
function version {
echo -n "$1" | sed -e 's/.* //'
}
trap clean_up EXIT
_STTY=$(stty -g) ## Save current terminal setup
function clean_up() {
stty "$_STTY" ## Restore terminal settings
}
# Prepare to silently read any (>=0) characters with no timeout.
stty -echo -icanon raw min 0 time 0
# Consume all pending input.
while read none; do :; done
# Reset the TTY, so it behaves as expected for the rest of the it2check script.
clean_up
# Enter raw mode and turn off echo so the terminal and I can chat quietly.
stty -echo -icanon raw
# Support for the extension first appears in this version of iTerm2:
MIN_VERSION=2.9.20160304
if [ $# -eq 1 ]; then
MIN_VERSION=$1
fi
# Send iTerm2-proprietary code. Other terminals ought to ignore it (but are
# free to use it respectfully). The response won't start with a 0 so we can
# distinguish it from the response to DSR 5. It should contain the terminal's
# name followed by a space followed by its version number and be terminated
# with an n.
echo -n ''
# Report device status. Responds with esc [ 0 n. All terminals support this. We
# do this because if the terminal will not respond to iTerm2's custom escape
# sequence, we can still read from stdin without blocking indefinitely.
echo -n ''
version_string=$(read_dsr)
if [ -n "${version_string}" -a "${version_string}" != "0" -a "${version_string}" != "3" ]; then
# Already read DSR 1337. Read DSR 5 and throw it away.
dsr=$(read_dsr)
else
# Terminal didn't respond to the DSR 1337. The response we read is from DSR 5.
version_string=""
fi
# Extract the terminal name and version number from the response.
version=$(version "${version_string}")
term=$(terminal "${version_string}")
# Check if they match what we're looking for. This becomes the return code of the script.
test "$term" = ITERM2 -a \( "$version" \> "$MIN_VERSION" -o "$version" = "$MIN_VERSION" \)

78
.local/bin/iterm2/it2copy
View file

@ -1,78 +0,0 @@
#!/usr/bin/env bash
trap clean_up EXIT
trap clean_up INT
inosc=0
function clean_up() {
if [[ $inosc == 1 ]]
then
print_st
fi
}
function show_help() {
echo "Usage: $(basename $0)" 1>& 2
echo " Copies to clipboard from standard input" 1>& 2
echo " $(basename $0) filename" 1>& 2
echo " Copies to clipboard from file" 1>& 2
}
# tmux requires unrecognized OSC sequences to be wrapped with DCS tmux;
# <sequence> ST, and for all ESCs in <sequence> to be replaced with ESC ESC. It
# only accepts ESC backslash for ST.
function print_osc() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\033Ptmux;\033\033]"
else
printf "\033]"
fi
}
# More of the tmux workaround described above.
function print_st() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\a\033\\"
else
printf "\a"
fi
}
# Look for command line flags.
while [ $# -gt 0 ]; do
case "$1" in
-h|--h|--help)
show_help
exit
;;
-*)
error "Unknown option flag: $1"
show_help
exit 1
;;
*)
if [ -r "$1" ] ; then
data=$(base64 < "$1")
print_osc
inosc=1
printf '1337;Copy=:%s' "$data"
print_st
inosc=0
exit 0
else
error "it2copy: $1: No such file or directory"
exit 2
fi
;;
esac
shift
done
data=$(base64)
print_osc
inosc=1
printf '1337;Copy=:%s' "$data"
print_st
inosc=0

36
.local/bin/iterm2/it2dl
View file

@ -1,36 +0,0 @@
#!/usr/bin/env bash
if [ $# -lt 1 ]; then
echo "Usage: $(basename $0) file ..."
exit 1
fi
function load_version() {
if [ -z ${IT2DL_BASE64_VERSION+x} ]; then
export IT2DL_BASE64_VERSION=$(base64 --version 2>&1)
fi
}
function b64_encode() {
load_version
if [[ "$IT2DL_BASE64_VERSION" =~ GNU ]]; then
# Disable line wrap
base64 -w0
else
base64
fi
}
for fn in "$@"
do
if [ -r "$fn" ] ; then
[ -d "$fn" ] && { echo "$fn is a directory"; continue; }
printf '\033]1337;File=name=%s;' $(echo -n "$fn" | b64_encode)
wc -c "$fn" | awk '{printf "size=%d",$1}'
printf ":"
base64 < "$fn"
printf '\a'
else
echo File $fn does not exist or is not readable.
fi
done

133
.local/bin/iterm2/it2getvar
View file

@ -1,133 +0,0 @@
#!/usr/bin/env bash
set -o pipefail
# tmux requires unrecognized OSC sequences to be wrapped with DCS tmux;
# <sequence> ST, and for all ESCs in <sequence> to be replaced with ESC ESC. It
# only accepts ESC backslash for ST.
function print_osc() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\033Ptmux;\033\033]"
else
printf "\033]"
fi
}
# More of the tmux workaround described above.
function print_st() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\a\033\\"
else
printf "\a"
fi
}
function get_b64_version() {
if [[ -z "${BASE64_VERSION+x}" ]]; then
BASE64_VERSION=$(base64 --version 2>&1)
export BASE64_VERSION
fi
}
function b64_encode() {
get_b64_version
if [[ $BASE64_VERSION =~ GNU ]]; then
# Disable line wrap
base64 -w0
else
base64
fi
}
function b64_decode() {
get_b64_version
if [[ $BASE64_VERSION =~ fourmilab ]]; then
BASE64_ARG=-d
elif [[ $BASE64_VERSION =~ GNU ]]; then
BASE64_ARG=-di
else
BASE64_ARG=-D
fi
base64 $BASE64_ARG
}
function error() {
errcho "ERROR: $*"
}
function errcho() {
echo "$@" >&2
}
function show_help() {
errcho
errcho "Usage: it2getvar variable_name"
errcho
errcho "Output value of the iTerm2 variable"
errcho
errcho "See the Variables Reference for information about built-in iTerm2 variables:"
errcho " -> https://iterm2.com/documentation-variables.html"
errcho
}
function check_dependency() {
if ! (builtin command -V "$1" >/dev/null 2>&1); then
error "missing dependency: can't find $1"
exit 1
fi
}
# get_variable variable_name
#
# This function uses POSIX standard synonym for the controlling terminal
# associated with the current process group - /dev/tty. It is useful for programs
# that wish to be sure of writing or reading data from the terminal
# no matter how STDIN/STDOUT/STDERR has been redirected.
function get_variable() {
trap 'cleanup' EXIT
stty -echo < /dev/tty
exec 9<> /dev/tty
print_osc >&9
printf "1337;ReportVariable=%s" "$(echo -n "$1" | b64_encode)" >&9
print_st >&9
read -r -t 5 -d $'\a' iterm_response <&9
exec 9>&-
stty echo < /dev/tty
[[ "$iterm_response" =~ ReportVariable= ]] || {
error "Failed to read response from iTerm2"
exit 2
}
echo "$(b64_decode <<< ${iterm_response#*=})"
}
function cleanup() {
stty echo < /dev/tty
}
# Show help if no arguments
if [ $# -eq 0 ]; then
show_help
exit
fi
check_dependency stty
check_dependency base64
# Process command line arguments
case "$1" in
-h|--h|--help)
show_help
exit
;;
-*)
error "Unknown option: $1"
show_help
exit 1
;;
*)
[[ -z "$1" ]] && error "Variable name can't be empty" && exit 1
get_variable "$1"
;;
esac
exit 0

117
.local/bin/iterm2/it2git
View file

@ -1,117 +0,0 @@
#!/usr/bin/env bash
# This script sets iTerm2 user-defined variables describing the state of the git
# repo in the current directory.
#
# For more information on the status bar, see:
# https://www.iterm2.com/3.3/documentation-status-bar.html
#
# Installation instructions for this script:
#
# bash: Place this in .bashrc.
# --------------------------------------------------------------------------------------
# function iterm2_print_user_vars() {
# it2git
# }
# fish: Place this in ~/.config/fish/config.fish after the line
# "source ~/.iterm2_shell_integration.fish".
# --------------------------------------------------------------------------------------
# function iterm2_print_user_vars
# it2git
# end
# tcsh: Place this in .tcshrc
# --------------------------------------------------------------------------------------
# alias get_current_branch "bash -c '((git branch 2> /dev/null) | grep \* | cut -c3-)'"
# alias _iterm2_user_defined_vars 'it2git'
# zsh:Place this in .zshrc after "source /Users/georgen/.iterm2_shell_integration.zsh".
# --------------------------------------------------------------------------------------
# iterm2_print_user_vars() {
# it2git
# }
GIT_BINARY=/usr/bin/git
dirty() {
# Outputs "dirty" or "clean"
OUTPUT=$("$GIT_BINARY" status --porcelain --ignore-submodules -unormal 2>/dev/null)
if (($?)); then
echo "clean"
return
fi
if [ -z "$OUTPUT" ]; then
echo "clean"
else
echo "dirty"
fi
}
counts() {
OUTPUT=$("$GIT_BINARY" rev-list --left-right --count HEAD...@'{u}' 2>/dev/null)
if (($?)); then
echo "error"
return
fi
echo "$OUTPUT"
}
branch() {
OUTPUT=$("$GIT_BINARY" symbolic-ref -q --short HEAD 2>/dev/null || git rev-parse --short HEAD 2>/dev/null)
if (($?)); then
return
fi
echo "$OUTPUT"
}
adds() {
"${GIT_BINARY}" ls-files --others --exclude-standard | wc -l
}
deletes() {
"${GIT_BINARY}" ls-files --deleted --exclude-standard | wc -l
}
function iterm2_begin_osc {
printf "\033]"
}
function iterm2_end_osc {
printf "\007"
}
function iterm2_set_user_var() {
iterm2_begin_osc
printf "1337;SetUserVar=%s=%s" "$1" $(printf "%s" "$2" | base64 | tr -d '\n')
iterm2_end_osc
}
git_poll () {
DIRECTORY="$1"
cd "$DIRECTORY"
DIRTY=$(dirty)
COUNTS=$(counts)
PUSH_COUNT=$(cut -f1 <<< "$COUNTS")
PULL_COUNT=$(cut -f2 <<< "$COUNTS")
BRANCH=$(branch)
iterm2_set_user_var gitBranch "$BRANCH"
iterm2_set_user_var gitDirty "$DIRTY"
iterm2_set_user_var gitPushCount "$PUSH_COUNT"
iterm2_set_user_var gitPullCount "$PULL_COUNT"
iterm2_set_user_var gitAdds "$ADDS"
iterm2_set_user_var gitDeletes "$DELETES"
}
"$GIT_BINARY" rev-parse --git-dir 2>/dev/null >/dev/null
if (($?)); then
iterm2_set_user_var gitBranch ""
iterm2_set_user_var gitDirty ""
iterm2_set_user_var gitPushCount ""
iterm2_set_user_var gitPullCount ""
iterm2_set_user_var gitAdds ""
iterm2_set_user_var gitDeletes ""
else
git_poll "$PWD"
fi

170
.local/bin/iterm2/it2profile
View file

@ -1,170 +0,0 @@
#!/usr/bin/env bash
set -o pipefail
# tmux requires unrecognized OSC sequences to be wrapped with DCS tmux;
# <sequence> ST, and for all ESCs in <sequence> to be replaced with ESC ESC. It
# only accepts ESC backslash for ST.
function print_osc() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\033Ptmux;\033\033]"
else
printf "\033]"
fi
}
# More of the tmux workaround described above.
function print_st() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\a\033\\"
else
printf "\a"
fi
}
function get_b64_version() {
if [[ -z "${BASE64_VERSION+x}" ]]; then
BASE64_VERSION=$(base64 --version 2>&1)
export BASE64_VERSION
fi
}
function b64_encode() {
get_b64_version
if [[ $BASE64_VERSION =~ GNU ]]; then
# Disable line wrap
base64 -w0
else
base64
fi
}
function b64_decode() {
get_b64_version
if [[ $BASE64_VERSION =~ fourmilab ]]; then
BASE64_ARG=-d
elif [[ $BASE64_VERSION =~ GNU ]]; then
BASE64_ARG=-di
else
BASE64_ARG=-D
fi
base64 $BASE64_ARG
}
function error() {
errcho "ERROR: $*"
}
function errcho() {
echo "$@" >&2
}
function show_help() {
errcho
errcho "Usage: it2profile -s profile_name"
errcho " it2profile -g"
errcho
errcho "Change iTerm2 session profile on the fly"
errcho
errcho "Options:"
errcho
errcho " -s Set current iTerm2 session profile to specified profile name"
errcho " empty string refers to profile marked as Default"
errcho " -g Get current iTerm2 session profile name"
errcho " -r Reset to the session initial profile"
errcho
}
function check_dependency() {
if ! (builtin command -V "$1" >/dev/null 2>&1); then
error "missing dependency: can't find $1"
exit 1
fi
}
# get_profile / set_profile
#
# These functions uses POSIX standard synonym for the controlling terminal
# associated with the current process group - /dev/tty. It is useful for programs
# that wish to be sure of writing or reading data from the terminal
# no matter how STDIN/STDOUT/STDERR has been redirected.
#
# get_profile uses iTerm2 Session Context variable "profileName" to
# get currently active profile name.
#
function get_profile() {
trap 'cleanup' EXIT
stty -echo < /dev/tty
exec 9<> /dev/tty
print_osc >&9
printf "1337;ReportVariable=cHJvZmlsZU5hbWU=" >&9
print_st >&9
read -r -t 5 -d $'\a' iterm_response <&9
exec 9>&-
stty echo < /dev/tty
[[ "$iterm_response" =~ ReportVariable= ]] || {
error "Failed to read response from iTerm2"
exit 2
}
echo "$(b64_decode <<< ${iterm_response#*=})"
}
function cleanup() {
stty echo < /dev/tty
}
function set_profile() {
exec 9> /dev/tty
print_osc >&9
printf '1337;SetProfile=%s' "$1" >&9
print_st >&9
exec 9>&-
}
# Show help if no arguments
if [ $# -eq 0 ]; then
show_help
exit
fi
check_dependency stty
check_dependency base64
# Process command line arguments
case "$1" in
-h|--h|--help)
show_help
exit
;;
-s|--s|--set)
[[ $# -eq 2 ]] || {
error "-s option requires exactly 1 argument - profile name"
show_help
exit 1
}
set_profile "$2"
;;
-g|--g|--get)
[[ $# -eq 1 ]] || {
error "-g option does not accept any argument"
show_help
exit 1
}
get_profile
;;
-r|--r|--reset)
[[ $# -eq 1 ]] || {
error "-r option does not accept any argument"
show_help
exit 1
}
set_profile "${ITERM_PROFILE:-}"
;;
*)
error "Unknown option: $1"
show_help
exit 1
;;
esac
exit 0

116
.local/bin/iterm2/it2setcolor
View file

@ -1,116 +0,0 @@
#!/usr/bin/env bash
open=0
# tmux requires unrecognized OSC sequences to be wrapped with DCS tmux;
# <sequence> ST, and for all ESCs in <sequence> to be replaced with ESC ESC. It
# only accepts ESC backslash for ST.
function print_osc() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\033Ptmux;\033\033]"
else
printf "\033]"
fi
}
# More of the tmux workaround described above.
function print_st() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\a\033\\"
else
printf "\a"
fi
}
# set_color key rgb
function set_color() {
print_osc
printf '1337;SetColors=%s=%s' "$1" "$2"
print_st
}
function error() {
echo "ERROR: $*" 1>&2
}
function show_help() {
if [ $open = 1 ]; then
print_st
fi
echo "Usage"
echo ""
echo "1) To set a specific color to an RGB value:"
echo " it2setcolor name color [name color...]" 1>& 2
echo "For example:"
echo " it2setcolor fg fff"
echo ""
echo "name is one of:"
echo " fg bg bold link selbg selfg curbg curfg underline tab"
echo " black red green yellow blue magenta cyan white"
echo " br_black br_red br_green br_yellow br_blue br_magenta br_cyan br_white"
echo ""
echo "color is of the format:"
echo " RGB (three hex digits, like fff)"
echo " RRGGBB (six hex digits, like f0f0f0)"
echo " cs:RGB (cs is a color space name)"
echo " cs:RRGGBB (cs is a color space name)"
echo ""
echo " The color space names accepted in the color are:"
echo " srgb (sRGB, the default if none is specified)"
echo " rgb (Apple's old device-independent colorspace)"
echo " p3 (Apple's fancy large-gamut colorspace)"
echo ""
echo "2) To switch to a named color preset:"
echo " it2setcolor preset name"
echo "For example:"
echo " it2setcolor preset 'Light Background'"
echo ""
echo "3) To reset the current tab's color to the system default:"
echo " it2setcolor tab default"
}
# Show help if no arguments and no stdin.
if [ $# -eq 0 ]; then
show_help
exit
fi
# Look for command line flags.
while [ $# -gt 0 ]; do
case "$1" in
-h|--h|--help)
show_help
exit
;;
-*)
error "Unknown option flag: $1"
show_help
exit 1
;;
*)
if [ $# -lt 2 ]; then
show_help
exit
fi
if [ $open = 0 ]; then
open=1
print_osc
printf '1337;SetColors='
else
printf ","
fi
# name is not checked for validity because we'd like this to work with future colors, too.
printf "%s=%s" "$1" "$2"
shift
;;
esac
shift
done
if [ $open = 1 ]; then
print_st
else
show_help
fi
exit 0

123
.local/bin/iterm2/it2setkeylabel
View file

@ -1,123 +0,0 @@
#!/usr/bin/env bash
# tmux requires unrecognized OSC sequences to be wrapped with DCS tmux;
# <sequence> ST, and for all ESCs in <sequence> to be replaced with ESC ESC. It
# only accepts ESC backslash for ST.
function print_osc() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\033Ptmux;\033\033]"
else
printf "\033]"
fi
}
# More of the tmux workaround described above.
function print_st() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\a\033\\"
else
printf "\a"
fi
}
function show_help() {
echo "Usage:" 1>& 2
echo " $(basename $0) set Fn Label" 1>& 2
echo " Where n is a value from 1 to 20" 1>& 2
echo " $(basename $0) set status Label" 1>& 2
echo " Sets the touch bar status button's label" 1>& 2
echo " $(basename $0) push [name]" 1>& 2
echo " Saves the current labels with an optional name. Resets labels to their default value, unless name begins with a "." character." 1>& 2
echo " $(basename $0) pop [name]" 1>& 2
echo " If name is given, all key labels up to and including the one with the matching name are popped." 1>& 2
echo "" 1>& 2
echo "Example:" 1>& 2
echo "#!/usr/bin/env bash" 1>& 2
echo "# Wrapper script for mc that sets function key labels" 1>& 2
echo "NAME=mc_\$RANDOM" 1>& 2
echo "# Save existing labels" 1>& 2
echo "$(basename $0) push \$NAME" 1>& 2
echo "$(basename $0) set F1 Help" 1>& 2
echo "$(basename $0) set F2 Menu" 1>& 2
echo "$(basename $0) set F3 View" 1>& 2
echo "$(basename $0) set F4 Edit" 1>& 2
echo "$(basename $0) set F5 Copy" 1>& 2
echo "$(basename $0) set F6 Move" 1>& 2
echo "$(basename $0) set F7 Mkdir" 1>& 2
echo "$(basename $0) set F8 Del" 1>& 2
echo "$(basename $0) set F9 Menu" 1>& 2
echo "$(basename $0) set F10 Quit" 1>& 2
echo "$(basename $0) set F11 Menu" 1>& 2
echo "$(basename $0) set F13 View" 1>& 2
echo "$(basename $0) set F14 Edit" 1>& 2
echo "$(basename $0) set F15 Copy" 1>& 2
echo "$(basename $0) set F16 Move" 1>& 2
echo "$(basename $0) set F17 Find" 1>& 2
echo "mc" 1>& 2
echo "# Restore labels to their previous state" 1>& 2
echo "$(basename $0) pop \$NAME" 1>& 2
}
## Main
if [[ $# == 0 ]]
then
show_help
exit 1
fi
if [[ $1 == set ]]
then
if [[ $# != 3 ]]
then
show_help
exit 1
fi
print_osc
printf "1337;SetKeyLabel=%s=%s" "$2" "$3"
print_st
elif [[ $1 == push ]]
then
if [[ $# == 1 ]]
then
print_osc
printf "1337;PushKeyLabels"
print_st
elif [[ $# == 2 ]]
then
if [[ $2 == "" ]]
then
echo "Name must not be empty" 1>& 2
exit 1
fi
print_osc
printf "1337;PushKeyLabels=%s" "$2"
print_st
else
show_help
exit 1
fi
elif [[ $1 == pop ]]
then
if [[ $# == 1 ]]
then
print_osc
printf "1337;PopKeyLabels"
print_st
elif [[ $# == 2 ]]
then
if [[ $2 == "" ]]
then
echo "Name must not be empty" 1>& 2
exit 1
fi
print_osc
printf "1337;PopKeyLabels=%s" "$2"
print_st
else
show_help
exit 1
fi
else
show_help
exit 1
fi

36
.local/bin/iterm2/it2split
View file

@ -1,36 +0,0 @@
#!/usr/bin/env python3.11
"""
Name: iterm2-splits
AUTHOR: https://github.com/jessebot
DESCRIPTION: I wrote this quickly to just run a command in a split on iterm2
LICENSE: GNU AFFERO GENERAL PUBLIC LICENSE Version 3
"""
import iterm2
import argparse
# parse args
parser = argparse.ArgumentParser()
parser.add_argument("command4split",
help="str to run as a command in an iterm2 split")
args = parser.parse_args()
print()
async def main(connection):
"""
Create split pane to the right, make the right pane active, and send a
command to the newly created split
"""
app = await iterm2.async_get_app(connection)
# Create split pane to the right and make the right one active
left_pane = app.current_terminal_window.current_tab.current_session
right_pane = await left_pane.async_split_pane(vertical=True)
# send the command to the newly created split
await right_pane.async_send_text(args.command4split + "\n")
# run the iterm2 stuff
iterm2.run_until_complete(main)

405
.local/bin/iterm2/it2tip
View file

@ -1,405 +0,0 @@
#!/usr/bin/env python3
import os
import sys
tips = [
{
"title": "Shell Integration",
"body": "The big new feature of iTerm2 version 3 is Shell Integration. Click “Learn More” for all the details.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Timestamps",
"body": "“View > Show Timestamps” shows the time (and date, if appropriate) when each line was last modified."
},
{
"title": "Password Manager",
"body": "Did you know iTerm2 has a password manager? Open it with “Window > Password Manager.” You can define a Trigger to open it for you at a password prompt in “Prefs > Profiles > Advanced > Triggers.”"
},
{
"title": "Open Quickly",
"body": "You can quickly search through your sessions with “View > Open Quickly” (⇧⌘O). You can type a query and sessions whose name, badge, current hostname, current user name, recent commands, and recent working directories match will be surfaced. It works best with Shell Integration so the user name, hostname, command, and directories can be known even while sshed.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Undo Close",
"body": "If you close a session, tab, or window by accident you can undo it with “Edit > Undo” (⌘Z). By default you have five seconds to undo, but you can adjust that timeout in “Prefs > Profiles > Session.”"
},
{
"title": "Annotations",
"body": "Want to mark up your scrollback history? Right click on a selection and choose “Annotate Selection” to add a personal note to it. Use “View > Show Annotations” to show or hide them, and look in “Edit > Marks and Annotations” for more things you can do."
},
{
"title": "Copy with Styles",
"body": "Copy a selection with ⌥⌘C to include styles such as colors and fonts. You can make this the default action for Copy in “Prefs > Advanced.”"
},
{
"title": "Inline Images",
"body": "iTerm2 can display images (even animated GIFs) inline.",
"url": "https://iterm2.com/images.html"
},
{
"title": "Automatic Profile Switching",
"body": "Automatic Profile Switching changes the current profile when the username, hostname, or directory changes. Set it up in “Prefs > Profiles > Advanced.” It requires Shell Integration to be installed.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Captured Output",
"body": "iTerm2 can act like an IDE using the Captured Output feature. When it sees text matching a regular expression you define, like compiler errors, it shows the matching lines in the Toolbelt. You can click to jump to the line in your terminal and double-click to perform an action like opening an editor to the line with the error.",
"url": "https://iterm2.com/captured_output.html"
},
{
"title": "Badges",
"body": "You can display a status message in the top right of your session in the background. It’s called a “Badge.” If you install Shell Integration you can include info like user name, hostname, current directory, and more.",
"url": "https://iterm2.com/badges.html"
},
{
"title": "Dynamic Profiles",
"body": "Dynamic Profiles let you store your profiles as one or more JSON files. It’s great for batch creating and editing profiles.",
"url": "https://iterm2.com/dynamic-profiles.html"
},
{
"title": "Advanced Paste",
"body": "“Edit > Paste Special > Advanced Paste” lets you preview and edit text before you paste. You get to tweak options, like how to handle control codes, or even to base-64 encode before pasting."
},
{
"title": "Zoom",
"body": "Ever wanted to focus on a block of lines without distraction, or limit Find to a single command’s output? Select the lines and choose “View > Zoom In on Selection.” The session’s contents will be temporarily replaced with the selection. Press “esc” to unzoom."
},
{
"title": "Semantic History",
"body": "The “Semantic History” feature allows you to ⌘-click on a file or URL to open it."
},
{
"title": "Tmux Integration",
"body": "If you use tmux, try running “tmux -CC” to get iTerm2’s tmux integration mode. The tmux windows show up as native iTerm2 windows, and you can use iTerm2’s keyboard shortcuts. It even works over ssh!",
"url": "https://gitlab.com/gnachman/iterm2/wikis/TmuxIntegration"
},
{
"title": "Triggers",
"body": "iTerm2 can automatically perform actions you define when text matching a regular expression is received. For example, you can highlight text or show an alert box. Set it up in “Prefs > Profiles > Advanced > Triggers.”",
"url": "https://www.iterm2.com/documentation-triggers.html"
},
{
"title": "Smart Selection",
"body": "Quadruple click to perform Smart Selection. It figures out if you’re selecting a URL, filename, email address, etc. based on prioritized regular expressions.",
"url": "https://www.iterm2.com/smartselection.html"
},
{
"title": "Instant Replay",
"body": "Press ⌥⌘B to step back in time in a terminal window. Use arrow keys to go frame by frame. Hold ⇧ and press arrow keys to go faster."
},
{
"title": "Hotkey Window",
"body": "You can have a terminal window open with a keystroke, even while in other apps. Click “Create a Dedicated Hotkey Window” in “Prefs > Keys.”"
},
{
"title": "Hotkey Window",
"body": "Hotkey windows can stay open after losing focus. Turn it on in “Window > Pin Hotkey Window.”"
},
{
"title": "Cursor Guide",
"body": "The cursor guide is a horizontal line that follows your cursor. You can turn it on in “Prefs > Profiles > Colors” or toggle it with the ⌥⌘; shortcut."
},
{
"title": "Shell Integration: Alerts",
"body": "The Shell Integration feature lets you ask to be alerted (⌥⌘A) when a long-running command completes.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Cursor Blink Rate",
"body": "You can configure how quickly the cursor blinks in “Prefs > Advanced.”"
},
{
"title": "Shell Integration: Navigation",
"body": "The Shell Integration feature lets you navigate among shell prompts with ⇧⌘↑ and ⇧⌘↓.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Shell Integration: Status",
"body": "The Shell Integration feature puts a blue arrow next to your shell prompt. If you run a command that fails, it turns red. Right click on it to get the running time and status.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Shell Integration: Selection",
"body": "With Shell Integration installed, you can select the output of the last command with ⇧⌘A.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Bells",
"body": "The dock icon shows a count of the number of bells rung and notifications posted since the app was last active."
},
{
"title": "Shell Integration: Downloads",
"body": "If you install Shell Integration on a machine you ssh to, you can right click on a filename (for example, in the output of “ls”) and choose “Download with scp” to download the file.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Find Your Cursor",
"body": "Press ⌘/ to locate your cursor. It’s fun!"
},
{
"title": "Customize Smart Selection",
"body": "You can edit Smart Selection regular expressions in “Prefs > Profiles > Advanced > Smart Selection.”",
"url": "https://www.iterm2.com/smartselection.html"
},
{
"title": "Smart Selection Actions",
"body": "Assign an action to a Smart Selection rule in “Prefs > Profiles > Advanced > Smart Selection > Edit Actions.” They go in the context menu and override semantic history on ⌘-click.",
"url": "https://www.iterm2.com/smartselection.html"
},
{
"title": "Visual Bell",
"body": "If you want the visual bell to flash the whole screen instead of show a bell icon, you can turn that on in “Prefs > Advanced.”"
},
{
"title": "Tab Menu",
"body": "Right click on a tab to change its color, close tabs after it, or to close all other tabs."
},
{
"title": "Tags",
"body": "You can assign tags to your profiles, and by clicking “Tags>” anywhere you see a list of profiles you can browse those tags."
},
{
"title": "Tag Hierarchy",
"body": "If you put a slash in a profile’s tag, that implicitly defines a hierarchy. You can see it in the Profiles menu as nested submenus."
},
{
"title": "Downloads",
"body": "iTerm2 can download files by base-64 encoding them. Click “Learn More” to download a shell script that makes it easy.",
"url": "https://iterm2.com/download.sh"
},
{
"title": "Command Completion",
"body": "If you install Shell Integration, ⇧⌘; helps you complete commands. It remembers the commands you’ve run on each host that has Shell Integration installed. It knows how often that command was run and how recently to help make the best suggestions.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Recent Directories",
"body": "iTerm2 remembers which directories you use the most on each host that has Shell Integration installed. There’s a Toolbelt tool to browse them, and ⌥⌘/ gives you a popup sorted by frequency and recency of use.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Favorite Directories",
"body": "If you have Shell Integration installed, you can “star” a directory to keep it always at the bottom of the Recent Directories tool in the Toolbelt. Right click and choose “Toggle Star.”",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Shell Integration History",
"body": "Install Shell Integration and turn on “Prefs > General > Save copy/paste and command history to disk” to remember command history per host across restarts of iTerm2.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Paste File as Base64",
"body": "Copy a file to the pasteboard in Finder and then use “Edit > Paste Special > Paste File Base64-Encoded” for easy uploads of binary files. Use ”base64 -D” (or -d on Linux) on the remote host to decode it."
},
{
"title": "Split Panes",
"body": "You can split a tab into multiple panes with ⌘D and ⇧⌘D."
},
{
"title": "Adjust Split Panes",
"body": "Resize split panes with the keyboard using ^⌘-Arrow Key."
},
{
"title": "Move Cursor",
"body": "Hold ⌥ and click to move your cursor. It works best with Shell Integration installed (to avoid sending up/down arrow keys to your shell).",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Edge Windows",
"body": "You can tell your profile to create windows that are attached to one edge of the screen in “Prefs > Profiles > Window.” You can resize them by dragging the edges."
},
{
"title": "Tab Color",
"body": "You can assign colors to tabs in “Prefs > Profiles > Colors,” or in the View menu."
},
{
"title": "Rectangular Selection",
"body": "Hold ⌥⌘ while dragging to make a rectangular selection."
},
{
"title": "Multiple Selection",
"body": "Hold ⌘ while dragging to make multiple discontinuous selections."
},
{
"title": "Dragging Panes",
"body": "Hold ⇧⌥⌘ and drag a session into another session to create or change split panes."
},
{
"title": "Cursor Boost",
"body": "Adjust Cursor Boost in “Prefs > Profiles > Colors” to make all colors more muted, except the cursor. Use a bright white cursor and it pops!"
},
{
"title": "Minimum Contrast",
"body": "Adjust “Minimum Contrast” in “Prefs > Profiles > Colors” to ensure text is always legible regardless of text/background color combination."
},
{
"title": "Tabs",
"body": "Normally, new tabs appear at the end of the tab bar. There’s a setting in “Prefs > Advanced” to place them next to your current tab."
},
{
"title": "Base Conversion",
"body": "Right-click on a number and the context menu shows it converted to hex or decimal as appropriate."
},
{
"title": "Saved Searches",
"body": "In “Prefs > Keys” you can assign a keystroke to a search for a regular expression with the “Find Regular Expression…” action."
},
{
"title": "Find URLs",
"body": "Search for URLs using “Edit > Find > Find URLs.” Navigate search results with ⌘G and ⇧⌘G. Open the current selection with ⌥⌘O."
},
{
"title": "Triggers",
"body": "The “instant” checkbox in a Trigger allows it to fire while the cursor is on the same line as the text that matches your regular expression."
},
{
"title": "Soft Boundaries",
"body": "Turn on “Edit > Selection Respects Soft Boundaries” to recognize split pane dividers in programs like vi, emacs, and tmux so you can select multiple lines of text."
},
{
"title": "Select Without Dragging",
"body": "Single click where you want to start a selection and ⇧-click where you want it to end to select text without dragging."
},
{
"title": "Smooth Window Resizing",
"body": "Hold ^ while resizing a window and it won’t snap to the character grid: you can make it any size you want."
},
{
"title": "Pasting Tabs",
"body": "If you paste text containing tabs, you’ll be asked if you want to convert them to spaces. It’s handy at the shell prompt to avoid triggering filename completion."
},
{
"title": "Bell Silencing",
"body": "Did you know? If the bell rings too often, you’ll be asked if you’d like to silence it temporarily. iTerm2 cares about your comfort."
},
{
"title": "Profile Search",
"body": "Every list of profiles has a search field (e.g., in ”Prefs > Profiles.”) You can use various operators to restrict your search query. Click “Learn More” for all the details.",
"url": "https://iterm2.com/search_syntax.html"
},
{
"title": "Color Schemes",
"body": "The online color gallery features over one hundred beautiful color schemes you can download.",
"url": "https://www.iterm2.com/colorgallery"
},
{
"title": "ASCII/Non-Ascii Fonts",
"body": "You can have a separate font for ASCII versus non-ASCII text. Enable it in “Prefs > Profiles > Text.”"
},
{
"title": "Coprocesses",
"body": "A coprocess is a job, such as a shell script, that has a special relationship with a particular iTerm2 session. All output in a terminal window (that is, what you see on the screen) is also input to the coprocess. All output from the coprocess acts like text that the user is typing at the keyboard.",
"url": "https://iterm2.com/coprocesses.html"
},
{
"title": "Touch Bar Customization",
"body": "You can customize the touch bar by selecting “View > Customize Touch Bar.” You can add a tab bar for full-screen mode, a user-customizable status button, and you can even define your own touch bar buttons in Prefs > Keys. There’s also a new shell integration tool to customize touch bar function key labels."
},
{
"title": "Ligatures",
"body": "If you use a font that supports ligatures, you can enable ligature support in Prefs > Profiles > Text."
},
{
"title": "Floating Hotkey Window",
"body": "New in 3.1: You can configure your hotkey window to appear over other apps’ full screen windows. Turn on “Floating Window” in “Prefs > Profiles > Keys > Customize Hotkey Window.”"
},
{
"title": "Multiple Hotkey Windows",
"body": "New in 3.1: You can have multiple hotkey windows. Each profile can have one or more hotkeys."
},
{
"title": "Double-Tap Hotkey",
"body": "New in 3.1: You can configure a hotkey window to open on double-tap of a modifier in “Prefs > Profiles > Keys > Customize Hotkey Window.”"
},
{
"title": "Buried Sessions",
"body": "You can “bury” a session with “Session > Bury Session.” It remains hidden until you restore it by selecting it from “Session > Buried Sessions > Your session.”"
},
{
"title": "Python API",
"body": "You can add custom behavior to iTerm2 using the Python API.",
"url": "https://iterm2.com/python-api"
},
{
"title": "Status Bar",
"body": "You can add a configurable status bar to your terminal windows.",
"url": "https://iterm2.com/3.3/documentation-status-bar.html"
},
{
"title": "Minimal Theme",
"body": "Try the “Minimal” and “Compact” themes to reduce visual clutter. You can set it in “Prefs > Appearance > General.”"
},
{
"title": "Session Titles",
"body": "You can configure which elements are present in session titles in “Prefs > Profiles > General > Title.”"
},
{
"title": "Tab Icons",
"body": "Tabs can show an icon indicating the current application. Configure it in “Prefs > Profiles > General > Icon.”"
},
{
"title": "Drag Window by Tab",
"body": "Hold ⌥ while dragging a tab to move the window. This is useful in the Compact and Minimal themes, which have a very small area for dragging the window."
},
{
"title": "Composer",
"body": "Press ⇧⌘. to open the Composer. It gives you a scratchpad to edit a command before sending it to the shell."
},
{
"title": "Shell Integration: Uploads",
"body": "If you install Shell Integration on a machine you ssh to, you can drag-drop from Finder into the remote host by holding ⌥ while dragging. The destination directory is determined by where you drop the file in the terminal window: run cd foo, then drop the file below the cd command, and the file will go into the foo directory.",
"url": "https://iterm2.com/shell_integration.html"
},
{
"title": "Composer Power Features",
"body": "The composer supports multiple cursors. It also has the ability to send just one command out of a list, making it easy to walk through a list of commands one-by-one. Click the help button in the composer for details."
},
]
home = os.getenv("XDG_DATA_HOME")
if not home:
home = "~"
RCFILE = os.path.expanduser(os.path.join(home, '.it2totd'))
def last_index():
try:
with open(RCFILE) as f:
lines = f.readlines()
return int(lines[0].rstrip())
except:
return -1
def print_tip(i):
def dcs(args):
return "\x1bP" + ";".join(args)
def osc(args):
term = os.getenv("TERM")
if term.startswith("screen"):
return dcs(["tmux", "\x1b\x1b]"]) + ";".join(args) + "\a\x1b\\"
else:
return "\x1b]" + ";".join(args) + "\x1b\\"
tip = tips[i]
print(f'iTerm2 tip - {tip["title"]}:')
print(tip["body"])
if "url" in tip:
print("Learn more: " + osc(["8", "", tip["url"]]) + tip["url"] + osc(["8", "", ""]))
def save_index(i):
with open(RCFILE, "w") as f:
f.write(str(i))
i = last_index() + 1
if i >= len(tips) and len(sys.argv) > 1 and sys.argv[1] == "-w":
i = 0
if i < len(tips):
print_tip(i)
save_index(i)

98
.local/bin/iterm2/it2ul
View file

@ -1,98 +0,0 @@
#!/usr/bin/env bash
trap clean_up EXIT
_STTY=$(stty -g) ## Save current terminal setup
stty -echo ## Turn off echo
function clean_up() {
stty "$_STTY" ## Restore terminal settings
}
function show_help() {
echo "Usage: $(basename $0) [destination [tar flags]]" 1>& 2
echo " If given, the destination specifies the directory to place downloaded files."
echo " Further options are passed through to tar. See your system's manpage for tar for details."
}
function bad_input() {
echo "Bad input: %1" 1>& 2
exit 1
}
function die() {
echo "Fatal error: $1" 1>& 2
exit 1
}
function read_base64_stanza() {
value=""
while read line;
do
if [ "$line" == "" ]; then
break
fi
printf "%s" "$line"
done
}
function decode() {
VERSION=$(base64 --version 2>&1)
if [[ "$VERSION" =~ fourmilab ]]; then
BASE64ARG=-d
elif [[ "$VERSION" =~ GNU ]]; then
BASE64ARG=-di
else
BASE64ARG=-D
fi
base64 "$BASE64ARG" <<< "$1"
}
# tmux requires unrecognized OSC sequences to be wrapped with DCS tmux;
# <sequence> ST, and for all ESCs in <sequence> to be replaced with ESC ESC. It
# only accepts ESC backslash for ST.
function print_osc() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\033Ptmux;\033\033]"
else
printf "\033]"
fi
}
# More of the tmux workaround described above.
function print_st() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\a\033\\"
else
printf "\a"
fi
}
function send_request_for_upload() {
print_osc
printf '1337;RequestUpload=format=tgz' ""
print_st
}
location="$PWD"
if [[ $# > 0 ]]
then
location="$1"
shift
fi
send_request_for_upload
read status
if [[ $status == ok ]]
then
data=$(read_base64_stanza)
clean_up
decode "$data" | tar -x -z -C "$location" -f - $* 1>& 2
elif [[ $status == abort ]]
then
echo "Upload aborted" 1>& 2
else
die "Unknown status: $status" 1>& 2
fi

104
.local/bin/iterm2/it2universion
View file

@ -1,104 +0,0 @@
#!/usr/bin/env bash
# tmux requires unrecognized OSC sequences to be wrapped with DCS tmux;
# <sequence> ST, and for all ESCs in <sequence> to be replaced with ESC ESC. It
# only accepts ESC backslash for ST.
function print_osc() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\033Ptmux;\033\033]"
else
printf "\033]"
fi
}
# More of the tmux workaround described above.
function print_st() {
if [[ $TERM == screen* || $TERM == tmux* ]] ; then
printf "\a\033\\"
else
printf "\a"
fi
}
function show_help() {
echo "Usage:" 1>& 2
echo " $(basename $0) set 8" 1>& 2
echo " $(basename $0) set 9" 1>& 2
echo " $(basename $0) push [name]" 1>& 2
echo " Saves the current version with an optional name." 1>& 2
echo " $(basename $0) pop [name]" 1>& 2
echo " If name is given, all versions up to and including the one with the matching name are popped." 1>& 2
}
function set_version() {
print_osc
printf "1337;UnicodeVersion=$1"
print_st
}
function push_version() {
print_osc
printf "1337;UnicodeVersion=push $1"
print_st
}
function pop_version() {
print_osc
printf "1337;UnicodeVersion=pop $1"
print_st
}
## Main
if [[ $# == 0 ]]
then
show_help
exit 1
fi
if [[ $1 == set ]]
then
if [[ $# != 2 ]]
then
show_help
exit 1
fi
set_version $2
elif [[ $1 == push ]]
then
if [[ $# == 1 ]]
then
push_version ""
elif [[ $# == 2 ]]
then
if [[ $2 == "" ]]
then
echo "Name must not be empty" 1>& 2
exit 1
fi
push_version "$2"
else
show_help
exit 1
fi
elif [[ $1 == pop ]]
then
if [[ $# == 1 ]]
then
pop_version ""
elif [[ $# == 2 ]]
then
if [[ $2 == "" ]]
then
echo "Name must not be empty" 1>& 2
exit 1
fi
pop_version "$2"
else
show_help
exit 1
fi
else
show_help
exit 1
fi

1343
Library/Application Support/iTerm2/DynamicProfiles/Profiles.json
View file

File diff suppressed because it is too large Load diff

32
README.md
View file

@ -57,7 +57,6 @@ These directories/files are installed to your home directory and follow the [XDG
- [`~/.config/bash/alias.sh`](.config/bash/alias.sh)
- [`~/.config/bash/completion.sh`](.config/bash/completion.sh)
- [`~/.config/bash/history.sh`](.config/bash/history.sh)
- [`~/.config/bash/iterm2_shell_integration.sh`](.config/bash/iterm2_shell_integration.sh)
- [`~/.config/bash/k8s.sh`](.config/bash/k8s.sh)
- [`~/.config/bash/path.sh`](.config/bash/path.sh)
- [`~/.config/bash/minimal.sh`](.config/bash/minimal.sh)
@ -74,9 +73,6 @@ These directories/files are installed to your home directory and follow the [XDG
- sets default history size
- don't log duplicate history lines
#### [`iterm2_shell_integration.sh`](.config/bash/iterm2_shell_integration.sh)
sets up [iterm2] shell stuff
#### [`~/.config/bash/text_editing.sh`](.config/bash/text_editing.sh)
sets [neovim] as default text editor, or [vim] if neovim is not present
@ -200,25 +196,6 @@ These directories/files are installed to your home directory and follow the [XDG
</blockquote>
</details>
<details>
<summary><code>iterm2</code></summary>
<blockquote>
[iterm2] is a terminal emulator for macOS.
Symlinked File: [`~/.config/iterm2/Profiles.json -> ~/Library/Application\ Support/iTerm2/DynamicProfiles/Profiles.json`](Library/Application\ Support/iTerm2/DynamicProfiles/Profiles.json)
### Profiles.json
Sets some basic profiles:
- default - profile with [spacechalk.nvim]-like colorscheme,
- minimal - profile with basically nothing special and a plain `.bash_profile`.
###
</blockquote>
</details>
<details>
@ -446,7 +423,7 @@ These directories/files are installed to your home directory and follow the [XDG
- [`~/.config/ranger/rc.conf`](.config/ranger/rc.conf)
[ranger][ranger] is a [TUI] file manager. Current configurations:
- enable file previews using [iterm2]
- enable file previews using [iterm2] image protocol
- enable video previews using ffmpegthumbnailer
- enable svg previews.
@ -598,11 +575,8 @@ These directories/files are installed to your home directory and follow the [XDG
Directory:
- [`~/.local/bin/iterm2`](.local/bin/iterm2)
Everything in there are files written and provided by iTerm2 for integrating iterm2 magic into your terminal. The only custom one is the following:
This is just for `imgcat`, for printing images in iterm2/wezterm.
| Command | Description |
|:---------------:|:-----------------------------------------------|
| `it2split` | Open split in iterm2 with your default profile |
</blockquote>
@ -706,7 +680,7 @@ onboardme --git_url https://github.com/your_username/dot_files --git_branch main
### FAQ
<details>
<summary>Where are the config files for vim, terminator, etc?</summary>
<summary>Where are the config files for vim, iterm2, terminator, etc?</summary>
<blockquote>